Навіщо використовувати JUnit для тестування?

Можливо, моє запитання є новачком, але я не можу реально зрозуміти обставини, за яких я б користувався Джуніт?

Я пишу прості програми чи більші програми, я тестую їх із System.outтвердженнями, і це здається мені досить простим.

Навіщо створювати тестові класи за допомогою JUnit, непотрібних папок у проекті, якщо нам все-таки потрібно викликати одні й ті самі методи, перевіряти, що вони повертають, і тоді ми маємо накладні витрати на те, щоб анотувати все?

Чому б не написати клас і не перевірити його відразу, System.outале не створити Тестові класи?

PS. Я ніколи не працював над великими проектами, я просто навчаюся.

То яка мета?

Це не тестування, це "перегляд вручну на вихід" (відомий в бізнесі як LMAO). Більш офіційно він відомий як "вручну шукати ненормальний вихід" (LMFAO). ^{(Див. Примітку нижче)}

Щоразу, коли ви змінюєте код, потрібно запустити додаток та LMFAO для всіх кодів, на які впливають ці зміни. Навіть у невеликих проектах це проблематично та схильне до помилок.

Тепер масштабуйте до 50 К, 250 К, 1 М LOC або більше, і LMFAO кожного разу, коли Ви зробите зміну коду. Мало того, що це неприємно, це неможливо: ви масштабували комбінації входів, виходів, прапорів, умов, і важко виконувати всі можливі гілки.

Гірше, що LMFAO може означати відвідування сторінок на сторінках веб-додатків, запуск звітів, перенесення мільйонів ліній журналів через десятки файлів і машин, читання створених та доставлених електронних листів, перевірка текстових повідомлень, перевірка шляху роботи, заповнення пляшки соди, агрегування даних із сотні веб-сервісів, перевірка аудиторського сліду фінансової операції ... ви отримуєте ідею. "Вихід" не означає кілька рядків тексту, "вихід" означає сукупну поведінку системи.

Нарешті, тести блоку та поведінки визначають поведінку системи. Тести можуть виконуватися сервером безперервної інтеграції та перевіряти їх правильність. Звичайно, так можна System.out, але сервер CI не дізнається, чи один з них неправий - і якщо це так, вони одиничні тести, і ви можете також використовувати рамку.

Якими б хорошими ми не вважали, люди не є гарними тестовими рамками або CI-серверами.

Примітка: LMAO є тестування, але в дуже обмеженому сенсі. Це не можна повторювати жодним змістовним чином у всьому проекті або як частина процесу. Це схоже на розвиток поступово в системі REPL, але ніколи не формалізуючи ці додаткові тести.

Ми пишемо тести, щоб перевірити правильність поведінки програми.

Перевірка правильності поведінки програми за допомогою перевірки вмісту вихідних висловлювань за допомогою очей - це посібник , а точніше - візуальний процес.

Ви можете це аргументувати

візуальна інспекція працює , я перевіряю, що код виконує те, що він мав робити, для цих сценаріїв, і коли я можу побачити, що це правильно, ми добре піти.

По-перше, це здорово, що вас цікавить, чи працює код чи ні. Це гарна річ. Ти попереду кривої! На жаль, проблеми з цим як підходом є.

Перша проблема з візуальним оглядом полягає в тому, що ви трапили аварію при зварюванні далеко від того, що не зможете знову перевірити правильність свого коду.

Друга проблема полягає в тому, що використовувана пара очей щільно поєднується з мозком власника очей. Якщо автору коду також належать очі, які використовуються в процесі візуального огляду, процес перевірки правильності має залежність від знань про програму, інтерналізовану в мозку зорового інспектора.

Новій парі очей важко зайти і перевірити правильність коду просто тому, що вони не є партнером з мозку оригінального кодера. Власникові другої пари очей доведеться поговорити з оригінальним автором коду, щоб повністю зрозуміти код, про який йде мова. Бесіда як засіб обміну знаннями є сумнівно ненадійною. Точка, яка є суперечкою, якщо оригінальний кодер недоступний для нових пар очей. У цьому випадку нова пара очей повинна прочитати оригінальний код.

Читання коду інших людей, який не охоплюється одиничними тестами, складніше, ніж зчитування коду, що має пов'язані одиничні тести. У кращому випадку читання коду інших народів - хитра робота, в гіршому - це найжорсткіше завдання в інженерії програмного забезпечення. Існує причина, що роботодавці, рекламуючи вакансії, наголошують, що проект є зеленим полем (або абсолютно новим). Писати код з нуля простіше, ніж змінювати існуючий код і тим самим робить рекламоване завдання виглядати більш привабливим для потенційних співробітників.

За допомогою тестування одиниць ми ділимо код на його складові частини. Потім для кожного компонента ми викладаємо стійло, вказуючи, як програма повинна вести себе . Кожен тестовий блок розповідає про те, як ця частина програми повинна діяти за певним сценарієм. Кожен тест на одиницю - це як у договорі, що описує, що має статися з точки зору клієнтського коду.

Це означає, що нова пара очей має дві нитки живої та точної документації щодо коду, про який йдеться.

Спочатку у них є сам код, реалізація, як це робилося ; по-друге, вони мають усі знання про те, що оригінальний кодер описаний у наборі формальних заяв, які розповідають про те, як повинен поводитися цей код .

Одиничні тести фіксують та формально описують знання, якими володів оригінальний автор, коли впроваджували клас. Вони надають опис того, як поводиться цей клас під час використання клієнтом.

Ви правильно ставите під сумнів корисність цього, оскільки можна писати одиничні тести, які є марними, не охоплюють весь код, про який йде мова, застаріли чи застаріли тощо. Як ми можемо гарантувати, що одиничні тести не лише імітують, але покращуються в процесі знаного, сумлінного автора, який візуально перевіряє вихідні заяви свого коду під час виконання? Спочатку напишіть одиничний тест, а потім введіть код, щоб зробити цей тест. Коли ви закінчите, нехай комп’ютери виконують тести, вони швидкі, вони чудово виконують повторювані завдання, які ідеально підходять для роботи.

Переконайтесь у якості тесту, переглядаючи їх щоразу, коли ви торкаєтесь коду, який вони перевіряють, та запускаючи тести для кожної збірки. Якщо тест не вдався, виправте його негайно.

Ми автоматизуємо процес запуску тестів, щоб вони виконувалися кожного разу, коли ми робимо збірку проекту. Ми також автоматизуємо генерацію звітів про покриття коду, які детально визначають, який відсоток коду охоплюється та використовується тестами. Ми прагнемо до високих відсотків. Деякі компанії не дозволять перевіряти зміни коду для контролю вихідного коду, якщо вони не мають достатньо одиничних тестів, щоб описати зміни в поведінці коду. Зазвичай друга пара очей буде розглядати зміни коду спільно з автором змін. Рецензент пройде через зміни, щоб гарантувати, що зміни зрозумілі та достатньо охоплені тестами. Тож процес огляду є ручним, але коли тести (одиничні та інтеграційні тести та, можливо, тести прийняття користувача) проходять цей посібник з перегляду вручну, стають частиною процесу автоматичного збирання. Вони запускаються кожного разу при реєстрації зміни. Aбезперервна інтеграція сервер виконує це завдання як частину процесу збирання.

Тести, які автоматично запускаються, підтримують цілісність поведінки коду та допомагають запобігти наступним змінам бази коду від порушення коду .

Нарешті, надання тестів дозволяє вам агресивно перефактувати код, оскільки ви можете зробити поліпшення великих кодів безпечними, знаючи, що ваші зміни не порушують існуючих тестів.

Існує застереження для тестування керованої розробки, і це те, що вам потрібно написати код з оком, щоб зробити його перевіреним. Це включає в себе кодування до інтерфейсів та використання таких методів, як залежність введення, для інстанцізації об'єктів, що співпрацюють. Перевірте роботу Кента Бека, який дуже добре описує TDD. Знайдіть кодування до інтерфейсів та вивчітьдизайн-візерунки

Під час тестування, використовуючи щось на кшталт System.out, ви протестуєте лише невеликий набір можливих випадків використання. Це не дуже ретельно, коли ви маєте справу з системами, які можуть приймати майже нескінченну кількість різних входів.

Блокові тести розроблені так, що дозволяють швидко запускати тести на вашій програмі, використовуючи дуже великий і різноманітний набір різних входів даних. Крім того, найкращі одиничні тести також враховують граничні випадки, такі як введення даних, що лежать прямо на межі того, що вважається дійсним.

Для того, щоб людина перевірила всі ці різні матеріали, може знадобитися тиждень, тоді як на машині може знадобитися кілька хвилин.

Подумайте про це так: Ви також не "тестуєте" щось, що буде статичним. Ваш додаток, швидше за все, відбувається через постійні зміни. Тому ці одиничні тести розроблені для запуску в різних точках циклу компіляції або розгортання. Мабуть, найбільша перевага в цьому:

Якщо ви зламаєте щось у своєму коді, ви дізнаєтесь про це прямо зараз , не після розгортання, не тоді, коли тестер якості перевірятиме помилку, а не тоді, коли ваші клієнти скасували. Ви також матимете більше шансів виправити глюк негайно , оскільки зрозуміло, що те, що порушило частину відповідного коду, швидше за все, сталося з моменту останньої компіляції. Таким чином, кількість слідчих робіт, необхідних для вирішення проблеми, значно зменшується.

Я додав деякі інші System.out НЕ МОЖЕТ:

• Зробіть незалежність кожного тестового випадку (важливо)

  JUnit може це зробити: кожен раз, коли буде створений і @Beforeвикликається новий екземпляр тестового випадку .

• Окремий код тестування від джерела

  JUnit може це зробити.

• Інтеграція з ІП

  JUnit може це зробити з Ant і Maven.

• Впорядковуйте та комбінуйте тестові справи легко

  JUnit може робити @Ignoreі тестувати набір.

• Легко перевірити результат

  JUnit пропонує безліч методів Assert ( assertEquals, assertSame...)

• Макет і заглушка змушують вас зосередитися на тестовому модулі.

  JUnit може зробити: Використання макету та заглушки змушує вас встановити правильний кріплення та зосередитись на логіці тестового модуля.

Блок тестів гарантує, що код працює за призначенням. Вони також дуже корисні для того, щоб код все ще працював за призначенням у випадку, якщо вам доведеться пізніше змінити його, щоб створити нові функції, щоб виправити помилку. Високий рівень тестового покриття коду дозволяє продовжувати розробляти функції без необхідності виконувати багато ручних тестів.

Ваш підхід вручну System.outхороший, але не найкращий. Це одноразове тестування, яке ви виконуєте. У реальному світі вимоги продовжують змінюватися і більшу частину часу ви вносите багато змін до існуючих функцій та класів. Отже… не кожен раз ви тестуєте вже написаний фрагмент коду.

Є також деякі більш вдосконалені функції, як у JUnit, як

Звітні заяви

JUnit надає методи тестування на певні умови, ці методи, як правило, починаються з тверджень і дозволяють вказати повідомлення про помилку, очікуваний і фактичний результат

Деякі з цих методів є

1. fail([message])- Дозволяє тесту вийти з ладу. Може використовуватися для перевірки того, що певна частина коду не досягнута. Або провалити тест до впровадження тестового коду.
2. assertTrue(true)/ assertTrue(false)- Буде завжди правдою / хибною. Можна використовувати для попереднього визначення результату тесту, якщо тест ще не виконаний.
3. assertTrue([message,] condition)- Перевіряє, що булева conditionправда.
4. assertEquals([message,] expected, actual)- Тестує, чи рівні два значення (відповідно до equalsметоду, якщо він реалізований, інакше використовуючи ==порівняльне порівняння). Примітка. Для масивів використовується перевірка посилань, а не вміст assertArrayEquals([message,] expected, actual).
5. assertEquals([message,] expected, actual, delta)- Тестує, чи знаходяться два поплавкові чи подвійні значення на певній відстані один від одного, контрольованому deltaзначенням.
6. assertNull([message,] object) - Перевіряє, що об’єкт недійсний

і так далі. Дивіться повний Javadoc для всіх прикладів тут .

Люкс

За допомогою тестових наборів ви можете певним чином об'єднати кілька тестових класів в одне ціле, щоб ви могли виконати їх усі одночасно. Простий приклад, поєднуючи тестові класи MyClassTestта MySecondClassTestодин сюїт під назвою AllTests:

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses({ MyClassTest.class, MySecondClassTest.class })
public class AllTests { } 

Основна перевага JUnit полягає в тому, що він автоматизований, а не вам потрібно вручну перевіряти свої роздруківки. Кожен тест, який ви пишете, залишається у вашій системі. Це означає, що якщо ви внесете зміни, які спричинили несподіваний побічний ефект, ваш тест сприйме це і не вдасться, а не вам доведеться пам'ятати, щоб перевірити все вручну після кожної зміни.

JUnit - це тестова рамка для мови програмування Java. Він важливий у розробці тестових розробок і є однією з сімейства одиничних рамок тестування, спільно відомих як xUnit.

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

Особливості JUnit - це рамка з відкритим кодом, яка використовується для написання та запуску тестів.

Надає анотацію для виявлення методів тестування.

Надає твердження для тестування очікуваних результатів.

Забезпечує тестові бігуни для виконання тестів

Тести JUnit дозволяють швидше писати код, що підвищує якість

JUnit елегантно простий. Він менш складний і вимагає менше часу.

Тести JUnit можна запустити автоматично, і вони перевіряють власні результати та надають негайний зворотній зв'язок. Немає необхідності вручну розчісувати звіт про результати тестів.

Тести JUnit можна організувати в тестові набори, що містять тестові приклади та навіть інші тестові набори.

Junit показує прогрес тесту в зеленій смузі, якщо тест проходить нормально, і він стає червоним, коли тест закінчується.

У мене трохи інша точка зору, чому потрібен JUnit.

Насправді ви можете написати всі тестові справи самостійно, але це громіздко. Ось проблеми:

1. Замість цього System.outми можемо додати if(value1.equals(value2))і повернути 0 або -1 або повідомлення про помилку. У цьому випадку нам потрібен "основний" тестовий клас, який запускає всі ці методи та перевіряє результати та підтримує, які тестові випадки не виконані та які передані.

2. Якщо ви хочете додати ще кілька тестів, вам потрібно також додати їх до цього "основного" тестового класу. Зміни до існуючого коду. Якщо ви хочете автоматично виявити тестові випадки з тестових класів, тоді вам потрібно використовувати рефлексію.

3. Всі ваші тести та ваш основний клас для запуску тестів не виявляються затемненням, і вам потрібно написати спеціальні конфігурації налагодження / запуску для запуску цих тестів. Ви все ще не бачите цих гарних зелених / червоних кольорів.

Ось що робить JUnit:

1. У ньому є assertXXX()методи, які корисні для друку корисних повідомлень про помилки з умов та передачі результатів "головному" класу.

2. "Основним" класом називається runner, який надає JUnit, тому нам не потрібно писати жодного. І він визначає методи тестування автоматично за допомогою відображення. Якщо ви додасте нові тести з @Testанотацією, вони автоматично виявляться.

3. JUnit також має інтеграцію затемнення та інтеграцію maven / gradle, тому легко запускати тести, і вам не доведеться писати власні конфігурації запуску.

Я не є експертом у JUnit, тому це, що я зрозумів, зараз, додасть більше у майбутньому.

Ви не можете написати жодний тестовий випадок, не використовуючи тестовий фреймворк, інакше вам доведеться написати тестовий фреймворк, щоб надати правосуддя вашим тестовим кейсам. Ось деякі відомості про JUnit Framework, окрім того, що ви можете використовувати рамки TestNG.

Що таке Джуніт?

Junit широко застосовується для тестування, а також мови програмування Java. Ви можете використовувати цю рамку автоматизації як для тестування одиниць, так і для тестування інтерфейсу користувача. Це допомагає нам визначити потік виконання нашого коду з різними анотаціями. Junit побудований на ідеї "спочатку тестування, а потім кодування", що допомагає нам підвищити продуктивність тестових випадків та стабільність коду.

Важливі особливості тестування Junit -

1. Це тестова основа з відкритим кодом, яка дозволяє користувачам ефективно писати та запускати тестові справи.
2. Надає різні типи анотацій для виявлення методів тестування.
3. Надає різні типи тверджень для перевірки результатів виконання тестового випадку.
4. Це також дає тестовим бігунам для ефективного запуску тестів.
5. Це дуже просто, а значить, економить час.
6. Він пропонує способи впорядкування тестових випадків у формі тестових костюмів.
7. Це дає результати тесту просто та елегантно.
8. Ви можете інтегрувати jUnit за допомогою Eclipse, Android Studio, Maven & Ant, Gradle та Jenkins

JUNIT - метод, який зазвичай приймається розробником Java. Якщо вони можуть надати аналогічний очікуваний вклад у функцію і відповідно вирішити, що письмовий код ідеально написаний або якщо тестовий випадок не вдається, тоді може знадобитися і інший підхід. JUNIT зробить розвиток швидко і забезпечить 0 дефектів функції.

ЮНІТ: ЗАБЕЗПЕЧЕННЯ ТА РЕГУЛЮВАННЯ

Ось мій погляд на JUNIT.

JUNIT можна використовувати, щоб:
1) спостерігати за поведінкою системи, коли в цю систему додається новий блок.
2) Внесіть налаштування в систему, щоб вітати "новий" блок в системі.
Що? Саме так.

Реальне життя, наприклад.

Коли ваш родич відвідує кімнату гуртожитку коледжу,
1) Ви будете робити вигляд, що ви відповідальніші.
2) Ви будете тримати всі речі там, де вони повинні бути, як взуття в взуттєвій стійці, а не на стільці, одяг у шафі, а не на стільці.
3) Ви позбудетесь усіх контрабанди.
4) ви почнете очищення кожного пристрою, яким ви володієте.

У плані програмування

Система: Ваш код
UNIT: нова функціональність.
Як рамки JUNIT використовуються для мови JAVA, так JUNIT = JAVA UNIT (можливо).

Припустимо, у вас вже є добре пробитий код, але прийшла нова вимога, і вам доведеться додати нову вимогу у свій код. Ця нова вимога може порушити ваш код для деякого вводу (тестовий зразок).

Простий спосіб адаптувати цю зміну - це тестування одиниць (JUNIT).
Для цього вам слід написати кілька тестів для свого коду, коли ви будуєте свою кодову базу. І щоразу, коли з’являється нова вимога, ви просто запустіть усі тестові випадки, щоб побачити, чи не виходить якийсь тестовий випадок. Якщо ні, то ви художник BadA ** і готовий розгорнути новий код.
Якщо будь-яка з тестів не виходить, ви змінюєте свій код і знову запускаєте тести, поки не отримаєте зелений статус.