uh oh first commit

src/main/kotlin/Main.kt

@@ -0,0 +1,104 @@
+import collection.CollectionManager
+import commands.*
+import file.FileManager
+import input.ConsoleInputManager
+import input.InputManager
+import runner.CommandInvoker
+
+/**
+ * Оооооооо, точка входа приложения.
+ *
+ * Ожидает один аргумент командной строки — путь к CSV-файлу коллекции.
+ * При запуске загружает коллекцию из файла, затем запускает интерактивный REPL-цикл.
+ *
+ */
+fun main(args: Array<String>) {
+    // Проверяем аргументы
+    if (args.isEmpty()) {
+        System.err.println("Ошибка: укажите путь к файлу коллекции.")
+        System.err.println("Использование: java -jar lab5.jar <file.csv>")
+        return
+    }
+
+    val filePath = args[0]
+
+    // Включаем Nightcall
+    val fileManager = FileManager(filePath)
+    val manager = CollectionManager()
+    val inputManager : InputManager = ConsoleInputManager()
+    val invoker = CommandInvoker()
+
+    // Загружаем данные из файла
+    val loaded = fileManager.read()
+    manager.loadFromFile(loaded)
+
+    // Регистрируем команды
+    registerCommands(invoker, manager, fileManager, inputManager)
+
+    // Водила, стартуем. Я сказала стартуем!
+    println("Коллекция загружена. Введите 'help' для справки.")
+    runRepl(inputManager, invoker)
+}
+
+/**
+ * Запускает интерактивный режим.
+ *
+ * Читает строки из [inputManager] и передаёт их [invoker].
+ * Завершается при EOF (Ctrl+D).
+ *
+ * @param inputManager источник ввода
+ * @param invoker инвокер команд
+ */
+fun runRepl(inputManager: InputManager, invoker: CommandInvoker) {
+    while (true) {
+        if (inputManager.isInteractive) print("\n ☭ ") // genius idea™
+
+        val line = inputManager.readLine()
+
+        // EOF — завершаем без сохранения
+        if (line == null) {
+            println("\nНу ладно.")
+            break
+        }
+
+        if (line.isBlank()) continue
+
+        invoker.execute(line)
+    }
+}
+
+/**
+ * Регистрирует все команды приложения в [invoker].
+ *
+ * @param invoker инвокер команд
+ * @param manager менеджер коллекции
+ * @param fileManager менеджер файла
+ * @param inputManager источник ввода
+ */
+fun registerCommands(
+    invoker: CommandInvoker,
+    manager: CollectionManager,
+    fileManager: FileManager,
+    inputManager: InputManager
+) {
+    val activeScripts = mutableSetOf<String>()
+
+    listOf(
+        HelpCommand(invoker),
+        InfoCommand(manager),
+        ShowCommand(manager),
+        AddCommand(manager, inputManager),
+        UpdateCommand(manager, inputManager),
+        RemoveByIdCommand(manager),
+        ClearCommand(manager),
+        SaveCommand(manager, fileManager),
+        ExecuteScriptCommand(invoker, activeScripts),
+        ExitCommand(),
+        AddIfMaxCommand(manager, inputManager),
+        AddIfMinCommand(manager, inputManager),
+        HistoryCommand(invoker),
+        SumOfMinutesCommand(manager),
+        MinByNameCommand(manager),
+        PrintDescendingMinutesCommand(manager)
+    ).forEach { invoker.register(it) }
+}

src/main/kotlin/collection/CollectionManager.kt

@@ -0,0 +1,168 @@
+package collection
+
+import io.github.oshai.kotlinlogging.KotlinLogging
+
+import models.HumanBeing
+import java.time.LocalDate
+import java.util.TreeSet
+import java.util.UUID
+
+private val logger = KotlinLogging.logger {}
+
+/**
+ * Менеджер коллекции объектов [HumanBeing].
+ *
+ * Хранит элементы в [TreeSet].
+ *
+ * @property initDate дата инициализации коллекции
+ */
+class CollectionManager {
+
+    private val collection: TreeSet<HumanBeing> = TreeSet()
+    val initDate: LocalDate = LocalDate.now()
+
+    /**
+     * Добавляет элемент в коллекцию.
+     *
+     * @param humanBeing элемент для добавления
+     * @return true - если элемент был добавлен, false - если уже существует
+     */
+    fun add(humanBeing: HumanBeing): Boolean = collection.add(humanBeing)
+
+    /**
+     * Обновляет элемент с указанным [id].
+     * Удаляет старый элемент и добавляет новый с тем же id,
+     *
+     * @param id UUID элемента для обновления
+     * @param updated новые данные (id и creationDate будут сохранены от старого)
+     * @return true если элемент найден и обновлён
+     */
+    fun update(id: UUID, updated: HumanBeing): Boolean {
+        val old = getById(id) ?: return false
+        collection.remove(old)
+        // Сохраняем оригинальные id и creationDate
+        val replaced = updated.copy(id = old.id, creationDate = old.creationDate)
+        logger.info { "[COMMANDS] {UPDATE} Обновлен элемент ${old.id} от ${old.creationDate}" }
+        return collection.add(replaced)
+    }
+
+    /**
+     * Удаляет элемент по его [id].
+     *
+     * @param id UUID элемента для удаления
+     * @return true если элемент найден и удалён
+     */
+    fun removeById(id: UUID): Boolean {
+        val target = getById(id) ?: return false
+        logger.info { "[COMMANDS] {REMOVE_BY_ID} Удалён элемент ${target.id} от ${target.creationDate}" }
+        return collection.remove(target)
+    }
+
+    /**
+     * Очищает коллекцию.
+     */
+    fun clear() {
+        collection.clear()
+        logger.info { "[COMMANDS] {CLEAR} Коллекция очищена" }
+    }
+
+    /**
+     * Возвращает копию коллекции в виде [TreeSet].
+     */
+    fun getAll(): TreeSet<HumanBeing> {
+        logger.info { "[COMMANDS] {GET_ALL} Возвращена коллекция" }
+        return TreeSet(collection)
+    }
+
+    /**
+     * Ищет элемент по [id].
+     *
+     * @param id UUID искомого элемента
+     * @return элемент или null если не найден
+     */
+    fun getById(id: UUID): HumanBeing? {
+        logger.info { "[COMMANDS] {GET_BY_ID} поиск элемента по id: $id" }
+        return collection.firstOrNull { it.id == id }
+    }
+
+    /**
+     * Возвращает количество элементов в коллекции.
+     */
+    fun size(): Int {
+        logger.info { "[COMMANDS] {SIZE} Получен размер коллекции" }
+        return collection.size
+    }
+
+    /**
+     * Проверяет, пуста ли коллекция.
+     */
+    fun isEmpty(): Boolean {
+        logger.info { "[COMMANDS] {IS_EMPTY} Проверка наличия элементов в коллекции" }
+        return collection.isEmpty()
+    }
+
+    /**
+     * Возвращает наибольший элемент коллекции.
+     */
+    fun getMax(): HumanBeing? {
+        logger.info { "[COMMANDS] {GET_MAX} Получение максимального элемента коллекции" }
+        return if (collection.isEmpty()) null else collection.last()
+    }
+
+    /**
+     * Возвращает наименьший элемент коллекции.
+     */
+    fun getMin(): HumanBeing? {
+        logger.info { "[COMMANDS] {GET_MIN} Получение минимального элемента коллекции" }
+        return if (collection.isEmpty()) null else collection.first()}
+
+    /**
+     * Возвращает сумму значений поля [HumanBeing.minutesOfWaiting] для всех элементов.
+     */
+    fun sumOfMinutesOfWaiting(): Double {
+        logger.info { "[COMMANDS] {SUM_MIN_WAIT} Получение минимального элемента коллекции по времени ожидания" }
+        return collection.sumOf { it.minutesOfWaiting.toDouble() }
+    }
+
+    /**
+     * Возвращает любой элемент с минимальным значением поля [HumanBeing.name].
+     */
+    fun minByName(): HumanBeing? {
+        logger.info { "[COMMANDS] {MIN_BY_NAME} Получение минимального элемента коллекции по имени" }
+        return collection.minByOrNull { it.name }
+    }
+
+    /**
+     * Возвращает список значений [HumanBeing.minutesOfWaiting] в порядке убывания.
+     */
+    fun getMinutesOfWaitingDescending(): List<Float> {
+        logger.info { "[COMMANDS] {GET_MIN_WAIT_DESC} Получение списка элементов коллекции по времени ожидания" }
+        return collection.map { it.minutesOfWaiting }.sortedDescending()
+    }
+
+
+    /**
+     * Загружает список элементов в коллекцию (вызывается при старте из FileManager).
+     * Очищает текущую коллекцию перед загрузкой.
+     *
+     * @param items список элементов для загрузки
+     */
+    fun loadFromFile(items: List<HumanBeing>) {
+        collection.clear()
+        items.forEach { collection.add(it) }
+        logger.info { "[COMMANDS] {LOAD_FROM_FILE} Загрузка коллекции из файла" }
+    }
+
+    /**
+     * Возвращает ну очень красивую строку с информацией о коллекции для команды `info`.
+     */
+    fun getInfo(): String {
+        logger.info { "[COMMANDS] {GET_INFO} Получение информации о коллекции" }
+        return """
+        |Тип коллекции : ${collection::class.simpleName}
+        |Тип элементов : ${HumanBeing::class.simpleName}
+        |Дата инициал. : $initDate
+        |Кол-во элемен.: ${collection.size}
+    """.trimMargin()
+    }
+}

src/main/kotlin/commands/AddCommand.kt

@@ -0,0 +1,23 @@
+package commands
+
+import collection.CollectionManager
+import input.HumanBeingBuilder
+import input.InputManager
+
+/**
+ * Добавляет новый элемент в коллекцию.
+ * Поля вводятся интерактивно через [HumanBeingBuilder].
+ */
+class AddCommand(
+    private val manager: CollectionManager,
+    private val inputManager: InputManager
+) : Command {
+    override val name = "add"
+    override val description = "добавить новый элемент в коллекцию"
+
+    override fun execute(args: List<String>) {
+        val human = HumanBeingBuilder(inputManager).build()
+        if (manager.add(human)) println("Элемент добавлен: ${human.name} [${human.id}]")
+        else println("Элемент уже существует в коллекции.")
+    }
+}

src/main/kotlin/commands/AddIfMaxCommand.kt

@@ -0,0 +1,28 @@
+package commands
+
+import collection.CollectionManager
+import input.HumanBeingBuilder
+import input.InputManager
+
+/**
+ * Добавляет элемент в коллекцию, если он больше наибольшего элемента.
+ * Сравнение по [models.HumanBeing.compareTo].
+ */
+class AddIfMaxCommand(
+    private val manager: CollectionManager,
+    private val inputManager: InputManager
+) : Command {
+    override val name = "add_if_max"
+    override val description = "добавить элемент, если он больше максимального"
+
+    override fun execute(args: List<String>) {
+        val human = HumanBeingBuilder(inputManager).build()
+        val max   = manager.getMax()
+        if (max == null || human > max) {
+            manager.add(human)
+            println("Элемент добавлен (превышает максимум).")
+        } else {
+            println("Элемент не добавлен: не превышает текущий максимум (${max.name}).")
+        }
+    }
+}

src/main/kotlin/commands/AddIfMin.kt

@@ -0,0 +1,28 @@
+package commands
+
+import collection.CollectionManager
+import input.HumanBeingBuilder
+import input.InputManager
+
+/**
+ * Добавляет элемент в коллекцию, если он меньше наименьшего элемента.
+ * Сравнение по [models.HumanBeing.compareTo].
+ */
+class AddIfMinCommand(
+    private val manager: CollectionManager,
+    private val inputManager: InputManager
+) : Command {
+    override val name = "add_if_min"
+    override val description = "добавить элемент, если он меньше минимального"
+
+    override fun execute(args: List<String>) {
+        val human = HumanBeingBuilder(inputManager).build()
+        val min   = manager.getMin()
+        if (min == null || human < min) {
+            manager.add(human)
+            println("Элемент добавлен (меньше минимума).")
+        } else {
+            println("Элемент не добавлен: не меньше текущего минимума (${min.name}).")
+        }
+    }
+}

src/main/kotlin/commands/ClearCommand.kt

@@ -0,0 +1,17 @@
+package commands
+
+import collection.CollectionManager
+
+/**
+ * Очищает коллекцию.
+ * @property manager менеджер коллекции
+ */
+class ClearCommand(private val manager: CollectionManager) : Command {
+    override val name = "clear"
+    override val description = "очистить коллекцию"
+
+    override fun execute(args: List<String>) {
+        manager.clear()
+        println("Коллекция очищена.")
+    }
+}

src/main/kotlin/commands/Command.kt

@@ -0,0 +1,18 @@
+package commands
+
+/**
+ * Базовый интерфейс для всех команд приложения.
+ */
+interface Command {
+    /** Имя команды. */
+    val name: String
+
+    /** Краткое описание для команды [HelpCommand]. */
+    val description: String
+
+    /**
+     * Выполняет команду.
+     * @param args аргументы, переданные в той же строке, что и имя команды
+     */
+    fun execute(args: List<String>)
+}

src/main/kotlin/commands/ExecuteScriptCommand.kt

@@ -0,0 +1,57 @@
+package commands
+
+import input.ScriptInputManager
+import runner.CommandInvoker
+
+/**
+ * Читает и выполняет команды из файла-скрипта.
+ * Синтаксис: execute_script <file_path>
+ *
+ * Защита от рекурсии: отслеживает стек вызванных скриптов.
+ */
+class ExecuteScriptCommand(
+    private val invoker: CommandInvoker,
+    private val activeScripts: MutableSet<String> = mutableSetOf()
+) : Command {
+    override val name = "execute_script"
+    override val description = "выполнить скрипт из файла: execute_script <file>"
+
+    override fun execute(args: List<String>) {
+        if (args.isEmpty()) {
+            println("[Ошибка] Укажите путь к файлу. Пример: execute_script script.txt")
+            return
+        }
+        val filePath = args[0]
+
+        if (filePath in activeScripts) {
+            println("[Ошибка] Обнаружена рекурсия: скрипт '$filePath' уже выполняется.")
+            return
+        }
+
+        val scriptInput = try {
+            ScriptInputManager(filePath)
+        } catch (e: Exception) {
+            println("[Ошибка] Не удалось открыть файл '$filePath': ${e.message}")
+            return
+        }
+
+        activeScripts.add(filePath)
+        println("Выполнение скрипта '$filePath'...")
+
+        try {
+            var line = scriptInput.readLine()
+            while (line != null) {
+                if (line.isNotBlank()) {
+                    println("  [скрипт] > $line")
+                    invoker.execute(line)
+                }
+                line = scriptInput.readLine()
+            }
+        } catch (e: IllegalStateException) {
+            println("[Ошибка] ${e.message}")
+        } finally {
+            activeScripts.remove(filePath)
+            println("Скрипт '$filePath' завершён.")
+        }
+    }
+}

src/main/kotlin/commands/ExitCommand.kt

@@ -0,0 +1,16 @@
+package commands
+
+import kotlin.system.exitProcess
+
+/**
+ * Завершает программу без сохранения.
+ */
+class ExitCommand : Command {
+    override val name = "exit"
+    override val description = "завершить программу (без сохранения)"
+
+    override fun execute(args: List<String>) {
+        println("Завершение работы.")
+        exitProcess(0)
+    }
+}

src/main/kotlin/commands/HelpCommand.kt

@@ -0,0 +1,18 @@
+package commands
+
+import runner.CommandInvoker
+
+/**
+ * Выводит справку по всем доступным командам.
+ * @property invoker инвокер, из которого берётся реестр команд
+ */
+class HelpCommand(private val invoker: CommandInvoker) : Command {
+    override val name = "help"
+    override val description = "вывести справку по доступным командам"
+
+    override fun execute(args: List<String>) {
+        invoker.getCommands().values
+            .sortedBy { it.name }
+            .forEach { println("  ${it.name.padEnd(40)} — ${it.description}") }
+    }
+}

src/main/kotlin/commands/HistoryCommand.kt

@@ -0,0 +1,21 @@
+package commands
+
+import runner.CommandInvoker
+
+/**
+ * Выводит последние 12 команд без аргументов.
+ * @property invoker инвокер с историей
+ */
+class HistoryCommand(private val invoker: CommandInvoker) : Command {
+    override val name = "history"
+    override val description = "вывести последние 12 команд"
+
+    override fun execute(args: List<String>) {
+        val history = invoker.getHistory()
+        if (history.isEmpty()) {
+            println("История пуста.")
+            return
+        }
+        history.forEachIndexed { i, cmd -> println("  ${i + 1}. $cmd") }
+    }
+}

src/main/kotlin/commands/InfoCommand.kt

@@ -0,0 +1,14 @@
+package commands
+
+import collection.CollectionManager
+
+/**
+ * Выводит информацию о коллекции (тип, дата инициализации, размер).
+ * @property manager менеджер коллекции
+ */
+class InfoCommand(private val manager: CollectionManager) : Command {
+    override val name = "info"
+    override val description = "вывести информацию о коллекции"
+
+    override fun execute(args: List<String>) = println(manager.getInfo())
+}

src/main/kotlin/commands/MinByNameCommand.kt

@@ -0,0 +1,17 @@
+package commands
+
+import collection.CollectionManager
+
+/**
+ * Выводит любой элемент с минимальным значением поля [models.HumanBeing.name].
+ */
+class MinByNameCommand(private val manager: CollectionManager) : Command {
+    override val name = "min_by_name"
+    override val description = "вывести элемент с минимальным именем"
+
+    override fun execute(args: List<String>) {
+        val min = manager.minByName()
+        if (min == null) println("Коллекция пуста.")
+        else println(min)
+    }
+}

src/main/kotlin/commands/PrintDescendingMinutesCommand.kt

@@ -0,0 +1,17 @@
+package commands
+
+import collection.CollectionManager
+
+/**
+ * Выводит значения поля [models.HumanBeing.minutesOfWaiting] в порядке убывания.
+ */
+class PrintDescendingMinutesCommand(private val manager: CollectionManager) : Command {
+    override val name = "print_field_descending_minutes_of_waiting"
+    override val description = "вывести minutesOfWaiting в порядке убывания"
+
+    override fun execute(args: List<String>) {
+        val values = manager.getMinutesOfWaitingDescending()
+        if (values.isEmpty()) println("Коллекция пуста.")
+        else values.forEach { println(it) }
+    }
+}

src/main/kotlin/commands/RemoveByIdCommand.kt

@@ -0,0 +1,28 @@
+package commands
+
+import collection.CollectionManager
+import java.util.UUID
+
+/**
+ * Удаляет элемент из коллекции по его id.
+ * Синтаксис: remove_by_id <uuid>
+ */
+class RemoveByIdCommand(private val manager: CollectionManager) : Command {
+    override val name = "remove_by_id"
+    override val description = "удалить элемент по id: remove_by_id <uuid>"
+
+    override fun execute(args: List<String>) {
+        if (args.isEmpty()) {
+            println("[Ошибка] Укажите id. Пример: remove_by_id <uuid>")
+            return
+        }
+        val id = try {
+            UUID.fromString(args[0])
+        } catch (e: IllegalArgumentException) {
+            println("[Ошибка] Некорректный UUID: '${args[0]}'")
+            return
+        }
+        if (manager.removeById(id)) println("Элемент удалён.")
+        else println("[Ошибка] Элемент с id '$id' не найден.")
+    }
+}

src/main/kotlin/commands/SaveCommand.kt

@@ -0,0 +1,21 @@
+package commands
+
+import collection.CollectionManager
+import file.FileManager
+
+/**
+ * Сохраняет коллекцию в CSV-файл.
+ * @property manager менеджер коллекции
+ * @property fileManager менеджер файла
+ */
+class SaveCommand(
+    private val manager: CollectionManager,
+    private val fileManager: FileManager
+) : Command {
+    override val name = "save"
+    override val description = "сохранить коллекцию в файл"
+
+    override fun execute(args: List<String>) {
+        fileManager.write(manager.getAll())
+    }
+}

src/main/kotlin/commands/ShowCommand.kt

@@ -0,0 +1,20 @@
+package commands
+
+import collection.CollectionManager
+
+/**
+ * Выводит все элементы коллекции в строковом представлении.
+ * @property manager менеджер коллекции
+ */
+class ShowCommand(private val manager: CollectionManager) : Command {
+    override val name = "show"
+    override val description = "вывести все элементы коллекции"
+
+    override fun execute(args: List<String>) {
+        if (manager.isEmpty()) {
+            println("Коллекция пуста.")
+            return
+        }
+        manager.getAll().forEach { println(it) }
+    }
+}

src/main/kotlin/commands/SumOfMinutesCommands.kt

@@ -0,0 +1,14 @@
+package commands
+
+import collection.CollectionManager
+
+/**
+ * Выводит сумму значений поля [models.HumanBeing.minutesOfWaiting].
+ */
+class SumOfMinutesCommand(private val manager: CollectionManager) : Command {
+    override val name = "sum_of_minutes_of_waiting"
+    override val description = "вывести сумму minutesOfWaiting всех элементов"
+
+    override fun execute(args: List<String>) =
+        println("Сумма minutesOfWaiting: ${manager.sumOfMinutesOfWaiting()}")
+}

src/main/kotlin/commands/UpdateCommand.kt

@@ -0,0 +1,39 @@
+package commands
+
+import collection.CollectionManager
+import input.HumanBeingBuilder
+import input.InputManager
+import java.util.UUID
+
+/**
+ * Обновляет элемент коллекции по его id.
+ * Синтаксис: update <uuid>
+ * Новые поля вводятся интерактивно через [HumanBeingBuilder].
+ */
+class UpdateCommand(
+    private val manager: CollectionManager,
+    private val inputManager: InputManager
+) : Command {
+    override val name = "update"
+    override val description = "обновить элемент по id: update <uuid>"
+
+    override fun execute(args: List<String>) {
+        if (args.isEmpty()) {
+            println("[Ошибка] Укажите id элемента. Пример: update <uuid>")
+            return
+        }
+        val id = try {
+            UUID.fromString(args[0])
+        } catch (e: IllegalArgumentException) {
+            println("[Ошибка] Некорректный UUID: '${args[0]}'")
+            return
+        }
+        if (manager.getById(id) == null) {
+            println("[Ошибка] Элемент с id '$id' не найден.")
+            return
+        }
+        val updated = HumanBeingBuilder(inputManager).build()
+        manager.update(id, updated)
+        println("Элемент обновлён.")
+    }
+}

src/main/kotlin/file/FileManager.kt

@@ -0,0 +1,181 @@
+package file
+
+import models.Car
+import models.Coordinates
+import models.HumanBeing
+import models.WeaponType
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.OutputStreamWriter
+import java.time.LocalDate
+import java.time.format.DateTimeParseException
+import java.util.Scanner
+import java.util.UUID
+
+/**
+ * Менеджер файлового хранилища коллекции.
+ *
+ * Читает данные с помощью [Scanner], записывает через [OutputStreamWriter].
+ * Формат хранения — CSV, одна строка = один объект [HumanBeing].
+ *
+ * Порядок полей в CSV:
+ * `id,name,coordX,coordY,creationDate,realHero,hasToothpick,
+ *  impactSpeed,soundtrackName,minutesOfWaiting,weaponType,carCool`
+ *
+ * @property filePath путь к CSV-файлу, полученный из аргумента командной строки
+ */
+class FileManager(private val filePath: String) {
+
+    companion object {
+        private const val DELIMITER = ","
+        private const val HEADER =
+            "id,name,coordX,coordY,creationDate,realHero," +
+                    "hasToothpick,impactSpeed,soundtrackName,minutesOfWaiting,weaponType,carCool"
+    }
+
+    /**
+     * Читает коллекцию из CSV-файла с помощью [Scanner].
+     *
+     * Пропускает заголовок и битые строки (с предупреждением в stderr).
+     * При отсутствии файла или проблемах с доступом возвращает пустой список.
+     *
+     * @return список корректно распарсенных объектов [HumanBeing]
+     */
+    fun read(): List<HumanBeing> {
+        val file = File(filePath)
+
+        if (!file.exists()) {
+            System.err.println("Файл '$filePath' не найден. Коллекция будет пустой.")
+            return emptyList()
+        }
+
+        if (!file.canRead()) {
+            System.err.println("Нет прав на чтение файла '$filePath'. Коллекция будет пустой.")
+            return emptyList()
+        }
+
+        val result = mutableListOf<HumanBeing>()
+        var lineNumber = 0
+
+        try {
+            Scanner(file, Charsets.UTF_8).use { scanner ->
+                while (scanner.hasNextLine()) {
+                    val line = scanner.nextLine().trim()
+                    lineNumber++
+
+                    // Пропускаем заголовок и пустые строки
+                    if (lineNumber == 1 && line.startsWith("id")) continue
+                    if (line.isBlank()) continue
+
+                    parseLine(line, lineNumber)
+                        ?.let { result.add(it) }
+                        ?: System.err.println("Строка $lineNumber пропущена: некорректные данные → '$line'")
+                }
+            }
+        } catch (e: FileNotFoundException) {
+            System.err.println("Файл не найден во время чтения: ${e.message}")
+        }
+
+        println("Загружено элементов: ${result.size} из файла '$filePath'")
+        return result
+    }
+
+    /**
+     * Парсит одну CSV-строку в объект [HumanBeing].
+     *
+     * @param line строка CSV
+     * @param lineNumber номер строки (для сообщений об ошибках)
+     * @return объект [HumanBeing] или null при ошибке парсинга
+     */
+    private fun parseLine(line: String, lineNumber: Int): HumanBeing? {
+        return try {
+            val parts = line.split(DELIMITER, limit = 12)
+            if (parts.size < 12) {
+                System.err.println("Строка $lineNumber: ожидалось 12 полей, найдено ${parts.size}")
+                return null
+            }
+
+            val id = UUID.fromString(parts[0].trim())
+            val name = parts[1].trim()
+            val coordX = parts[2].trim().toLong()
+            val coordY = parts[3].trim().toInt()
+            val creationDate = LocalDate.parse(parts[4].trim())
+            val realHero = parts[5].trim().toBoolean()
+            val hasToothpick = parts[6].trim().toBoolean()
+            val impactSpeed = parts[7].trim().toDouble()
+            val soundtrackName = parts[8].trim()
+            val minutesOfWaiting = parts[9].trim().toFloat()
+            val weaponType = parts[10].trim().let {
+                if (it.equals("null", ignoreCase = true) || it.isBlank()) null
+                else WeaponType.valueOf(it)
+            }
+            val carCool = parts[11].trim().toBoolean()
+
+            // самая лучшая валидация (100%)
+            require(name.isNotBlank()) { "name не может быть пустым" }
+
+            // от такого может быть диабет
+            HumanBeing(
+                id = id, name = name, coordinates = Coordinates(coordX, coordY),
+                creationDate = creationDate, realHero = realHero, hasToothpick = hasToothpick,
+                impactSpeed = impactSpeed, soundtrackName = soundtrackName,
+                minutesOfWaiting = minutesOfWaiting, weaponType = weaponType, car = Car(carCool)
+            )
+        } catch (e: IllegalArgumentException) {
+            System.err.println("Строка $lineNumber — ошибка данных: ${e.message}")
+            null
+        } catch (e: DateTimeParseException) {
+            System.err.println("Строка $lineNumber — неверный формат даты: ${e.message}")
+            null
+        } catch (e: Exception) {
+            System.err.println("Строка $lineNumber — неожиданная ошибка: ${e.message}")
+            null
+        }
+    }
+
+    /**
+     * Записывает коллекцию в CSV-файл с помощью [OutputStreamWriter].
+     *
+     * @param items коллекция объектов [HumanBeing] для записи
+     * @return true если запись прошла успешно
+     */
+    fun write(items: Collection<HumanBeing>): Boolean {
+        val file = File(filePath)
+
+        if (file.exists() && !file.canWrite()) {
+            System.err.println("Нет прав на запись в файл '$filePath'.")
+            return false
+        }
+
+        return try {
+            OutputStreamWriter(file.outputStream(), Charsets.UTF_8).use { writer ->
+                writer.write(HEADER)
+                writer.write("\n")
+                items.forEach { h ->
+                    writer.write(toCSVLine(h))
+                    writer.write("\n")
+                }
+            }
+            println("Коллекция сохранена в '$filePath' (${items.size} элементов).")
+            true
+        } catch (e: SecurityException) {
+            System.err.println("Отказано в доступе к файлу '$filePath': ${e.message}")
+            false
+        } catch (e: Exception) {
+            System.err.println("Ошибка записи в файл: ${e.message}")
+            false
+        }
+    }
+
+    /**
+     * Сериализует объект [HumanBeing] в строку CSV.
+     *
+     * @param h объект для сериализации
+     * @return строка в формате CSV
+     */
+    private fun toCSVLine(h: HumanBeing): String = listOf(
+        h.id, h.name, h.coordinates.x, h.coordinates.y, h.creationDate,
+        h.realHero, h.hasToothpick, h.impactSpeed, h.soundtrackName,
+        h.minutesOfWaiting, h.weaponType ?: "null", h.car.cool
+    ).joinToString(DELIMITER)
+}

src/main/kotlin/input/ConsoleInputManager.kt

@@ -0,0 +1,21 @@
+package input
+
+import java.io.BufferedReader
+import java.io.InputStreamReader
+
+/**
+ * Реализация [InputManager] для чтения из стандартного потока ввода.
+ * Использует [BufferedReader] с кодировкой системы по умолчанию,
+ * что обеспечивает корректную работу на Windows и Linux.
+ * Без этого - сломается. Не трогать!
+ */
+class ConsoleInputManager : InputManager {
+    override val isInteractive: Boolean = true
+
+    private val reader = BufferedReader(
+        InputStreamReader(System.`in`, Charsets.UTF_8)
+    )
+
+    override fun readLine(): String? = reader.readLine()
+}
+

src/main/kotlin/input/HumanBeingBuilder.kt

@@ -0,0 +1,175 @@
+package input
+
+import models.Car
+import models.Coordinates
+import models.HumanBeing
+import models.WeaponType
+
+/**
+ * Интерактивный построитель объекта [HumanBeing].
+ *
+ * Читает поля по одному из [inputManager], показывает приглашения,
+ * валидирует ввод и повторяет запрос при ошибке.
+ *
+ * Поля [HumanBeing.id] и [HumanBeing.creationDate] генерируются
+ * автоматически и не запрашиваются у пользователя.
+ *
+ * @property inputManager источник ввода
+ */
+class HumanBeingBuilder(private val inputManager: InputManager) {
+
+    /**
+     * Запускает интерактивный ввод всех полей и возвращает готовый [HumanBeing].
+     *
+     * @throws IllegalStateException если EOF
+     */
+    fun build(): HumanBeing {
+        val name = readNonBlankString("Введите имя:")
+        val coordinates = readCoordinates()
+        val realHero = readBoolean("Герой? (true/false):")
+        val hasToothpick = readBoolean("Есть зубочистка? (true/false):")
+        val impactSpeed = readDouble("Введите скорость удара (impactSpeed):")
+        val soundtrackName = readNonBlankString("Введите название саундтрека:")
+        val minutesOfWaiting = readFloat("Введите минуты ожидания (minutesOfWaiting):")
+        val weaponType = readNullableWeaponType()
+        val car = readCar()
+
+        return HumanBeing(
+            name = name, coordinates = coordinates, realHero = realHero,
+            hasToothpick = hasToothpick, impactSpeed = impactSpeed,
+            soundtrackName = soundtrackName, minutesOfWaiting = minutesOfWaiting,
+            weaponType = weaponType, car = car
+        )
+    }
+
+    private fun readCoordinates(): Coordinates {
+        val x = readLong("Введите координату X (тип Long):")
+        val y = readInt("Введите координату Y (тип Int):")
+        return Coordinates(x, y)
+    }
+
+    private fun readCar(): Car {
+        val cool = readBoolean("Крутой автомобиль ? (true/false):")
+        return Car(cool)
+    }
+
+    /**
+     * Читает непустую строку. Повторяет запрос при пустом вводе.
+     */
+    private fun readNonBlankString(prompt: String): String {
+        while (true) {
+            printPrompt(prompt)
+            val input = inputManager.readLine()
+                ?: throw IllegalStateException("EOF")
+            if (input.isNotBlank()) return input.trim()
+            println("[Ошибка] Строка не может быть пустой.")
+        }
+    }
+
+    /**
+     * Читает Long. Повторяет запрос при некорректном вводе.
+     */
+    private fun readLong(prompt: String): Long {
+        while (true) {
+            printPrompt(prompt)
+            val input = inputManager.readLine()
+                ?: throw IllegalStateException("EOF")
+            try {
+                return input.trim().toLong()
+            } catch (e: NumberFormatException) {
+                println("[Ошибка] Ожидается целое число (Long). Попробуйте снова.")
+            }
+        }
+    }
+
+    /**
+     * Читает Int. Повторяет запрос при некорректном вводе.
+     */
+    private fun readInt(prompt: String): Int {
+        while (true) {
+            printPrompt(prompt)
+            val input = inputManager.readLine()
+                ?: throw IllegalStateException("EOF")
+            try {
+                return input.trim().toInt()
+            } catch (e: NumberFormatException) {
+                println("[Ошибка] Ожидается целое число (Int). Попробуйте снова.")
+            }
+        }
+    }
+
+    /**
+     * Читает Double. Повторяет запрос при некорректном вводе.
+     */
+    private fun readDouble(prompt: String): Double {
+        while (true) {
+            printPrompt(prompt)
+            val input = inputManager.readLine()
+                ?: throw IllegalStateException("EOF")
+            try {
+                return input.trim().toDouble()
+            } catch (e: NumberFormatException) {
+                println("[Ошибка] Ожидается число с плавающей точкой (Double). Попробуйте снова.")
+            }
+        }
+    }
+
+    /**
+     * Читает Float. Повторяет запрос при некорректном вводе.
+     */
+    private fun readFloat(prompt: String): Float {
+        while (true) {
+            printPrompt(prompt)
+            val input = inputManager.readLine()
+                ?: throw IllegalStateException("EOF")
+            try {
+                return input.trim().toFloat()
+            } catch (e: NumberFormatException) {
+                println("[Ошибка] Ожидается число (Float). Попробуйте снова.")
+            }
+        }
+    }
+
+    /**
+     * Читает Boolean (true/false). Повторяет запрос при некорректном вводе.
+     */
+    private fun readBoolean(prompt: String): Boolean {
+        while (true) {
+            printPrompt(prompt)
+            val input = inputManager.readLine()
+                ?: throw IllegalStateException("EOF")
+            when (input.trim().lowercase()) {
+                "true"  -> return true
+                "false" -> return false
+                else    -> println("[Ошибка] Ожидается 'true' или 'false'. Попробуйте снова.")
+            }
+        }
+    }
+
+    /**
+     * Читает [WeaponType] или null (пустая строка).
+     * Перед вводом выводит список допустимых констант.
+     */
+    private fun readNullableWeaponType(): WeaponType? {
+        val constants = WeaponType.entries.joinToString(", ")
+        while (true) {
+            printPrompt("Введите тип оружия (доступные: $constants) или оставьте пустым для null:")
+            val input = inputManager.readLine()
+                ?: throw IllegalStateException("EOF")
+            if (input.isBlank()) return null
+            try {
+                return WeaponType.valueOf(input.trim().uppercase())
+            } catch (e: IllegalArgumentException) {
+                println("[Ошибка] Неизвестный тип оружия '$input'. Допустимые значения: $constants")
+            }
+        }
+    }
+
+    /**
+     * Выводит приглашение к вводу только в интерактивном режиме.
+     * В режиме скрипта приглашения не выводятся.
+     */
+    private fun printPrompt(message: String) {
+        if (inputManager.isInteractive) print(" > $message ")
+    }
+}

src/main/kotlin/input/InputManager.kt

@@ -0,0 +1,21 @@
+package input
+
+/**
+ * Интерфейс источника ввода.
+ *
+ * Подменяет консольный ввод на чтение из файла
+ * при выполнении команды [commands.ExecuteScriptCommand].
+ */
+interface InputManager {
+    /**
+     * Читает следующую строку из источника.
+     * @return строка или null при достижении конца потока (EOF)
+     */
+    fun readLine(): String?
+
+    /**
+     * Возвращает true если источник — интерактивная консоль.
+     * Используется для управления выводом приглашений (prompt).
+     */
+    val isInteractive: Boolean
+}

src/main/kotlin/input/ScriptInputManager.kt

@@ -0,0 +1,21 @@
+package input
+
+import java.io.File
+import java.util.Scanner
+
+/**
+ * Реализация [InputManager] для чтения команд из файла.
+ *
+ * Используется командой [commands.ExecuteScriptCommand].
+ * При достижении конца файла возвращает null.
+ *
+ * @property filePath путь к файлу
+ */
+class ScriptInputManager(filePath: String) : InputManager {
+    override val isInteractive: Boolean = false
+
+    private val scanner = Scanner(File(filePath), Charsets.UTF_8)
+
+    override fun readLine(): String? =
+        if (scanner.hasNextLine()) scanner.nextLine() else null
+}

src/main/kotlin/models/Car.kt

@@ -0,0 +1,10 @@
+package models
+
+/**
+ * Автомобиль, которым владеет [HumanBeing].
+ *
+ * @property cool признак того, что автомобиль крутой
+ */
+data class Car(
+    val cool: Boolean
+)

src/main/kotlin/models/Coordinates.kt

@@ -0,0 +1,12 @@
+package models
+
+/**
+ * Координаты местоположения [HumanBeing].
+ *
+ * @property x координата X
+ * @property y координата Y
+ */
+data class Coordinates(
+    val x: Long,
+    val y: Int
+)

src/main/kotlin/models/HumanBeing.kt

@@ -0,0 +1,79 @@
+package models
+
+import java.time.LocalDate
+import java.util.UUID
+
+/**
+ * Основная сущность коллекции — Райан Гослинг.
+ *
+ * @property id уникальный идентификатор, генерируется автоматически
+ * @property name имя героя (Райан Гослинг), не может быть null или пустой строкой
+ * @property coordinates координаты героя, не может быть null
+ * @property creationDate дата создания записи, генерируется автоматически
+ * @property realHero является ли настоящим героем (конечно)
+ * @property hasToothpick есть ли зубочистка (естественно)
+ * @property impactSpeed скорость удара, не может быть null
+ * @property soundtrackName название саундтрека, не может быть null (Nightcall - Kavinsky)
+ * @property minutesOfWaiting количество минут ожидания
+ * @property weaponType тип оружия, может быть null
+ * @property car автомобиль героя, не может быть null
+ */
+data class HumanBeing(
+    val id: UUID = UUID.randomUUID(),
+    val name: String,
+    val coordinates: Coordinates,
+    val creationDate: LocalDate = LocalDate.now(),
+    val realHero: Boolean,
+    val hasToothpick: Boolean,
+    val impactSpeed: Double,
+    val soundtrackName: String,
+    val minutesOfWaiting: Float,
+    val weaponType: WeaponType?,
+    val car: Car
+) : Comparable<HumanBeing> {
+
+    init {
+        require(name.isNotBlank()) { "Имя не может быть пустым" }
+    }
+
+    /**
+     * Сравниваем по имени и id
+     */
+    override fun compareTo(other: HumanBeing): Int {
+        val byName = this.name.compareTo(other.name)
+        if (byName != 0) return byName
+        return this.id.toString().compareTo(other.id.toString())
+    }
+
+    /**
+     * Два объекта считаются одинаковыми, если совпадают их [id].
+     */
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is HumanBeing) return false
+        return id == other.id
+    }
+
+    override fun hashCode(): Int = id.hashCode()
+
+    // убил на этот вывод часа 5-6. Зря я сюда полез
+    /**
+     * Красивое строковое представление для команды [show].
+     */
+    override fun toString(): String =
+        """
+        |HumanBeing (It Drives) {
+        |  id             = $id
+        |  name           = $name (a.k.a. Ryan Gosling)
+        |  coordinates    = (x=${coordinates.x}, y=${coordinates.y})
+        |  creationDate   = $creationDate
+        |  realHero       = $realHero
+        |  hasToothpick   = $hasToothpick
+        |  impactSpeed    = $impactSpeed
+        |  soundtrackName = $soundtrackName
+        |  minutesOfWait  = $minutesOfWaiting
+        |  weaponType     = ${weaponType ?: "null"}
+        |  car.cool       = ${car.cool}
+        |}
+        """.trimMargin()
+}

src/main/kotlin/models/WeaponType.kt

@@ -0,0 +1,11 @@
+package models
+
+/**
+ * Перечисление типов оружия, которым может владеть [HumanBeing].
+ * Поле [weaponType] в [HumanBeing] может быть null.
+ */
+enum class WeaponType {
+    HAMMER,
+    SHOTGUN,
+    BAT;
+}

src/main/kotlin/runner/CommandInvoker.kt

@@ -0,0 +1,65 @@
+package runner
+
+import commands.Command
+
+/**
+ * Инвокер команд.
+ *
+ * Хранит реестр команд и историю последних 12 вызовов.
+ * Разбирает введённую строку на имя команды и аргументы.
+ *
+ * @property commands зарегистрированные команды: имя → реализация
+ */
+class CommandInvoker {
+
+    private val commands = mutableMapOf<String, Command>()
+    private val history  = ArrayDeque<String>(12)
+
+    /**
+     * Регистрирует команду в реестре.
+     * @param command команда для регистрации
+     */
+    fun register(command: Command) {
+        commands[command.name] = command
+    }
+
+    /**
+     * Разбирает строку и выполняет соответствующую команду.
+     * Добавляет имя команды в историю.
+     *
+     * @param input строка ввода от пользователя
+     */
+    fun execute(input: String) {
+        val parts = input.trim().split(" ")
+        val name  = parts[0].lowercase()
+        val args  = parts.drop(1)
+
+        val command = commands[name]
+        if (command == null) {
+            println("Неизвестная команда: '$name'. Введите 'help' для справки.")
+            return
+        }
+
+        addToHistory(name)
+        try {
+            command.execute(args)
+        } catch (e: IllegalStateException) {
+            println("[Ошибка выполнения] ${e.message}")
+        }
+    }
+
+    /**
+     * Возвращает неизменяемый список последних 12 команд.
+     */
+    fun getHistory(): List<String> = history.toList()
+
+    /**
+     * Возвращает все зарегистрированные команды для вывода справки.
+     */
+    fun getCommands(): Map<String, Command> = commands.toMap()
+
+    private fun addToHistory(name: String) {
+        if (history.size >= 12) history.removeFirst()
+        history.addLast(name)
+    }
+}

src/main/resources/logback.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+
+    <property name="LOG_DIR" value="logs"/>
+    <property name="LOG_FILE" value="application.log"/>
+
+    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+        <file>${LOG_DIR}/${LOG_FILE}</file>
+        <append>true</append>
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT"/>
+        <appender-ref ref="FILE"/>
+    </root>
+</configuration>

src/test/kotlin/AddIfCommandsTest.kt

@@ -0,0 +1,56 @@
+import collection.CollectionManager
+import commands.AddIfMaxCommand
+import commands.AddIfMinCommand
+import input.InputManager
+import input.HumanBeingBuilder
+import io.mockk.*
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class AddIfCommandsTest {
+
+    private lateinit var manager: CollectionManager
+    private lateinit var inputManager: InputManager
+
+    @BeforeEach
+    fun setUp() {
+        manager = CollectionManager()
+        inputManager = mockk()
+    }
+
+    /**
+     * Тест 5: add_if_max добавляет элемент, если он больше максимального.
+     */
+    @Test
+    fun `add_if_max should add element greater than current max`() {
+        manager.add(TestData.human("Alice"))   // min элемент
+        val bigHuman = TestData.human("Zorro") // 'Z' > 'A' по compareTo
+
+        // Мокируем HumanBeingBuilder через InputManager
+        mockkConstructor(HumanBeingBuilder::class)
+        every { anyConstructed<HumanBeingBuilder>().build() } returns bigHuman
+
+        AddIfMaxCommand(manager, inputManager).execute(emptyList())
+
+        assertEquals(2, manager.size())
+        unmockkConstructor(HumanBeingBuilder::class)
+    }
+
+    /**
+     * Тест 6: add_if_min НЕ добавляет элемент, если он больше минимального.
+     */
+    @Test
+    fun `add_if_min should NOT add element greater than current min`() {
+        manager.add(TestData.human("Alice"))
+        val bigHuman = TestData.human("Zorro")
+
+        mockkConstructor(HumanBeingBuilder::class)
+        every { anyConstructed<HumanBeingBuilder>().build() } returns bigHuman
+
+        AddIfMinCommand(manager, inputManager).execute(emptyList())
+
+        assertEquals(1, manager.size()) // не добавлен
+        unmockkConstructor(HumanBeingBuilder::class)
+    }
+}

src/test/kotlin/CollectionManagerTest.kt

@@ -0,0 +1,39 @@
+import collection.CollectionManager
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class CollectionManagerTest {
+
+    private lateinit var manager: CollectionManager
+
+    @BeforeEach
+    fun setUp() {
+        manager = CollectionManager()
+    }
+
+    /**
+     * Тест 3: add добавляет элемент, size увеличивается.
+     */
+    @Test
+    fun `add should increase collection size`() {
+        val human = TestData.human("Bob")
+        assertTrue(manager.add(human))
+        assertEquals(1, manager.size())
+    }
+
+    /**
+     * Тест 4: removeById удаляет существующий элемент.
+     */
+    @Test
+    fun `removeById should remove existing element`() {
+        val human = TestData.human("Carol")
+        manager.add(human)
+        assertTrue(manager.removeById(human.id))
+        assertEquals(0, manager.size())
+        assertNull(manager.getById(human.id))
+    }
+}

src/test/kotlin/CommandInvokerHistoryTest.kt

@@ -0,0 +1,34 @@
+import commands.Command
+import runner.CommandInvoker
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class CommandInvokerHistoryTest {
+
+    /**
+     * Тест 8: история хранит не более 12 последних команд.
+     */
+    @Test
+    fun `history should not exceed 12 entries`() {
+        val invoker = CommandInvoker()
+
+        // Регистрируем 15 команд с именами cmd1..cmd15
+        repeat(15) { i ->
+            val cmd = mockk<Command>()
+            every { cmd.name } returns "cmd${i + 1}"
+            every { cmd.description } returns ""
+            every { cmd.execute(any()) } returns Unit
+            invoker.register(cmd)
+        }
+
+        repeat(15) { i -> invoker.execute("cmd${i + 1}") }
+
+        val history = invoker.getHistory()
+        assertEquals(12, history.size)
+        // Должны остаться последние 12: cmd4..cmd15
+        assertEquals("cmd4", history.first())
+        assertEquals("cmd15", history.last())
+    }
+}

src/test/kotlin/HumanBeingValidationTest.kt

@@ -0,0 +1,34 @@
+import models.Car
+import models.Coordinates
+import models.HumanBeing
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertEquals
+
+class HumanBeingValidationTest {
+
+    /**
+     * Тест 1: HumanBeing с пустым именем должен бросать исключение.
+     */
+    @Test
+    fun `blank name should throw IllegalArgumentException`() {
+        assertThrows<IllegalArgumentException> {
+            HumanBeing(
+                name = "   ", coordinates = Coordinates(0L, 0),
+                realHero = false, hasToothpick = false,
+                impactSpeed = 1.0, soundtrackName = "track",
+                minutesOfWaiting = 1f, weaponType = null,
+                car = Car(false)
+            )
+        }
+    }
+
+    /**
+     * Тест 2: weaponType может быть null.
+     */
+    @Test
+    fun `weaponType can be null`() {
+        val human = TestData.human(weaponType = null)
+        assertEquals(null, human.weaponType)
+    }
+}

src/test/kotlin/MinByNameTest.kt

@@ -0,0 +1,19 @@
+import collection.CollectionManager
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class MinByNameTest {
+
+    /**
+     * Тест 9: minByName возвращает элемент с минимальным (который идёт выше по алфавиту) именем.
+     */
+    @Test
+    fun `minByName should return element with smallest name`() {
+        val manager = CollectionManager()
+        manager.add(TestData.human("Zorro"))
+        manager.add(TestData.human("Alice"))
+        manager.add(TestData.human("Mike"))
+
+        assertEquals("Alice", manager.minByName()?.name)
+    }
+}

src/test/kotlin/PrintDescendingMinutesTest.kt

@@ -0,0 +1,20 @@
+import collection.CollectionManager
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class PrintDescendingMinutesTest {
+
+    /**
+     * Тест 10: getMinutesOfWaitingDescending возвращает список в порядке убывания.
+     */
+    @Test
+    fun `minutes should be sorted descending`() {
+        val manager = CollectionManager()
+        manager.add(TestData.human("A", minutesOfWaiting = 5f))
+        manager.add(TestData.human("B", minutesOfWaiting = 15f))
+        manager.add(TestData.human("C", minutesOfWaiting = 10f))
+
+        val result = manager.getMinutesOfWaitingDescending()
+        assertEquals(listOf(15f, 10f, 5f), result)
+    }
+}

src/test/kotlin/SumOfMinutesCommand.kt

@@ -0,0 +1,19 @@
+import collection.CollectionManager
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class SumOfMinutesTest {
+
+    /**
+     * Тест 7: сумма minutesOfWaiting считается корректно.
+     */
+    @Test
+    fun `sumOfMinutesOfWaiting returns correct sum`() {
+        val manager = CollectionManager()
+        manager.add(TestData.human("Alice", minutesOfWaiting = 10f))
+        manager.add(TestData.human("Bob",   minutesOfWaiting = 20f))
+        manager.add(TestData.human("Carol", minutesOfWaiting = 5f))
+
+        assertEquals(35.0, manager.sumOfMinutesOfWaiting(), absoluteTolerance = 0.001)
+    }
+}

src/test/kotlin/TestData.kt

@@ -0,0 +1,18 @@
+import models.Car
+import models.Coordinates
+import models.HumanBeing
+import models.WeaponType
+
+object TestData {
+    fun human(
+        name: String = "Alice",
+        minutesOfWaiting: Float = 30f,
+        weaponType: WeaponType? = WeaponType.HAMMER
+    ) = HumanBeing(
+        name = name, coordinates = Coordinates(10L, 20),
+        realHero = true, hasToothpick = false,
+        impactSpeed = 9.5, soundtrackName = "Test Track",
+        minutesOfWaiting = minutesOfWaiting, weaponType = weaponType,
+        car = Car(true)
+    )
+}