[БЕЗ_ЗВУКА] В предыдущем видео мы с вами сделали так,
чтобы наши юнит-тесты выводили стандартный поток ошибок.
И это позволило нам не комментировать запуск
тестов при отправке решения в тестирующую систему.
И это, на самом деле, очень хорошая вещь,
что мы можем не комментировать запуск тестов, потому что
если мы их закомментируем для отправки, мы можем потом забыть их раскомментировать.
И мы можем изменять как-то нашу программу и забывать выполнять юнит-тесты.
На самом деле у нас может появиться в программе какая-то ошибка,
но мы перестали их вызывать, они у нас там закомментированы, и,
соответственно, мы перестали ими пользоваться.
Это неудобно.
Вообще нам хочется, чтобы юнит-тесты всегда выполнялись как-то автоматически.
И с каждым изменением нашей программы
они выполнялись и контролировали, что мы не сломали то, что работало.
При этом смотрите, сейчас в нашем фреймворке есть
вот какой недостаток: давайте возьмём ну вот,
например, TestCount и в очередной раз в функции
GetSynonymCount допустим намеренную ошибку.
Скомпилируем нашу программу, запустим её и посмотрим внимательно в консоль.
Я даже её увеличу.
Смотрите: мы видим,
что TestCount нашёл ошибку, при этом вот этот
вот красный квадратик говорит о том, что наша программа продолжает выполняться.
То есть она ждёт ввода с клавиатуры.
Это странно, потому что наш юнит-тест сказал,
что в нашей программе есть ошибка, а мы продолжаем молча,
мы переходим молча к основной программе и выполняем её,
выполняем решение нашей задачи.
Это как-то неправильно, потому что если юнит-тест нашёл ошибку,
он должен громко, звонко сообщить об этом пользователю, что «Эй, разработчик!
У тебя в программе ошибка!
Вот она, иди её исправь».
Сейчас же наши юнит-тесты просто молча пишут в консоли,
и если мы туда особо не смотрим, то мы будем выполнять наше решение и думать,
что в нём нет ошибок, что всё работает правильно.
Поэтому текущее поведение наших юнит-тестов нежелательное, неправильное.
Юнит-тесты должны сообщать о том, что они нашли ошибку, громко.
Поэтому давайте мы поменяем поведение нашего фреймворка следующим образом:
сделаем так, что если хотя бы один из юнит-тестов упал,
то есть нашёл какую-то ошибку, то наша программа будет завершаться аварийно.
Вернее, с ненулевым кодом возврата.
Если же все юнит-тесты прошли успешно, то начинает выполняться
основная программа, начинает выполняться решение нашей задачи.
Таким образом мы обеспечим, что если юнит-тесты нашли ошибку, то программа
заканчивает выполнение и мы видим, что у нас действительно есть ошибка.
Мы этот момент не пропустим.
Поэтому, во-первых, давайте всегда запускать юнит-тесты при старте программы.
У нас больше нет необходимости их комментировать, потому что даже
если мы вместе с ними отправим в тестирующую систему наше решение,
то никаких проблем не возникнет.
Поэтому мы будем выполнять тесты всегда.
И смотрите, что нам надо сделать.
Я сейчас переключусь обратно в Eclipse.
Смотрите, что нам надо сделать: вот здесь у нас есть вызовы RunTest,
нам надо выполнить RunTest сколько-то раз.
И когда все вызовы RunTest закончатся, нам нужно выполнить какие-то действия.
Нам нужно посчитать количество упавших тестов, и если оно больше нуля,
то завершить работу программы, а иначе — ничего не делать.
Как нам сделать так, как нам этого добиться?
Как нам где-то хранить какое-то состояние,
которое существует между вызовами тестов?
Давайте обернём вот эту вот функцию RunTest в класс.
Поступим мы таким образом: мы напишем класс,
назовём его TestRunner,
RunTest сделаем его методом.
Кстати, обратите внимание, у нас это раньше не встречалось:
RunTest становится шаблонным методом класса.
Ну так как это обычная функция, по сути, то тут как бы никаких премудростей.
Дальше.
В классе TestRunner заведём счётчик числа упавших тестов.
И когда у нас тест стреляет, в блоке catch мы
это количество тестов увеличиваем на один.
Дальше объявим функцию
TestAll и перенесём
в неё запуск наших тестов.
Соответственно, наша функция main будет начинаться с функции TestAll.
В TestAll объявим объект класса TestRunner; назовём его tr.
И выполним
наши тесты, вызвав у него метод RunTest.
Давайте скомпилируем.
Запустим.
Всё выполнено, всё работает, но пока что поведение не поменялось.
Тест нашёл ошибку, но программа продолжает исполняться.
Что нам надо?
Нам нужно в каком-то месте написать код,
который будет выполняться точно тогда, когда все юнит-тесты выполнились.
В этом месте нам нужно проанализировать вот это вот поле fail_count.
В каком месте функции TestAll мы точно знаем,
что все тесты выполнились?
В самом конце, вот здесь вот, перед этой скобочкой.
Когда объект tr, объект класса TestRunner,
будет разрушаться; раз он начал разрушаться, наша функция закончилась,
и никакие юнит-тесты больше мы запускать не будем.
Поэтому анализ переменной fail_count мы поставим в деструктор класса TestRunner.
Напишем деструктор.
И здесь напишем такое: если fail_count больше нуля,
то выведем сообщение:
fail_count << " tests failed.
Terminate".
И завершим нашу программу
с ненулевым кодом возврата, в данном случае — с единичкой.
Exit — это стандартная функция в C++, которая досталась ещё от C,
которая завершает выполнение программы с переданным в неё кодом возврата.
Давайте снова скомпилируем наш код.
Мы запустим его.
И видите: TestCount упал, у нас появилось в консоли дополнительное сообщение о том,
что один тест упал и вот здесь
вот нет красного квадратика, программа не выполняется.
Она закончила своё исполнение.
Теперь пойдём в TestCount.
Вернём правильное поведение для функции GetSynonymCount.
Скомпилируем нашу программу.
Запустим.
И видим, что тесты отработали, все вывели OK, и программа выполняется.
Мы можем вводить в неё запросы,
можем добавить синонимы a и b и ввести команду COUNT b.
И получить один.
Таким образом за счёт создания класса TestRunner,
подсчёта внутри него количества упавших тестов и
проверки этого количества упавших тестов в
деструкторе мы получили желаемое поведение наших тестов.
Если хоть один из них стреляет, то наша программа завершает своё выполнение.
Если все выполняются, то мы переходим к основному решению.
Тут, конечно же, ещё важно, что мы обернули это всё в функцию TestAll,
чтобы деструктор класса TestRunner выполнялся вот здесь,
грубо говоря, а не в конце функции main.
Именно поэтому мы TestRunner объявили не в функции main, а внутри TestAll.
Так что функция TestAll здесь важна.
И при этом за счёт того, что мы выполняли это в деструкторе,
мы вот здесь вот можем добавлять запуски каких угодно тестов,
и наша функциональность по проверке количества упавших
тестов в конце выполнения всех тестов, она никуда не денется,
она автоматически будет выполняться.
Вот даже давайте я тут запущу вот такой большой набор тестов.
Вот они все выполнились, и программа продолжила свою работу.
На этом мы закончим улучшение и разработку нашего юнит-тест фреймворка,
и, на самом деле, мы получили весьма удобный для использования фреймворк.
И в следующем видео мы ещё раз сделаем обзор того, что у нас в итоге получилось.
