Зачем использовать JUnit для тестирования?

Ответ 1

Это не тестирование, это "просмотр результатов вручную" (известный в бизнесе как LMAO). Более формально это известно как "поиск аномального выхода вручную" (LMFAO). ^{(См. Примечание ниже)}

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

Теперь масштабируйте до 50К, 250К, 1м LOC или более и LMFAO каждый раз, когда вы вносите изменения в код. Это не только неприятно, но и невозможно: вы масштабировали комбинации входов, выходов, флагов, условий, и вам трудно использовать все возможные ветки.

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

Наконец, модульные и поведенческие тесты определяют поведение системы. Тесты могут выполняться сервером непрерывной интеграции и проверяться на правильность. Конечно, то же самое можно System.out и о System.out, но CI-сервер не узнает, является ли один из них неправильным, и если это так, то это модульные тесты, и вы также можете использовать фреймворк.

Независимо от того, насколько мы хороши, люди не являются хорошими средами для юнит-тестирования или CI-серверами.

Примечание: LMAO тестирует, но в очень ограниченном смысле. Это не повторяется каким-либо значимым образом для всего проекта или как часть процесса. Это похоже на постепенную разработку в REPL, но никогда не формализует эти дополнительные тесты.

Ответ 2

Мы пишем тесты для проверки правильности поведения программы.

Проверка правильности поведения программы путем проверки содержимого выводимых операторов с помощью глаз - это руководство или, более конкретно, визуальный процесс.

Можно утверждать, что

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

Теперь, прежде всего, хорошо, что вас интересует, правильно ли работает код. Это хорошо. Вы впереди кривой! К сожалению, в этом есть проблемы с этим.

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

Вторая проблема заключается в том, что используемая пара глаз тесно связана с мозгом владельца глаз. Если автор кода также владеет глазами, используемыми в процессе визуального контроля, процесс проверки правильности зависит от знаний о программе, интернализованной в мозге визуального инспектора.

Трудно найти новую пару глаз и проверить правильность кода просто потому, что они не объединены с мозгом оригинального кодера. Владельцу второй пары глаз придется поговорить с оригинальным автором кода, чтобы полностью понять этот код. Беседа как средство обмена знаниями, как известно, ненадежна. Точка, которая спорна, если исходный кодер недоступен для новых парных глаз. В этом случае новая пара глаз должна прочитать исходный код.

Чтение кода других людей, которое не распространяется на модульные тесты, сложнее, чем чтение кода, связанного с модульными тестами. В лучшем случае, чтение кода других людей - это сложная работа, в худшем случае это самая напряженная задача в разработке программного обеспечения. Там есть причина, по которой работодатели, рекламируя вакансии, подчеркивают, что проект является новым (или совершенно новым) проектом. Написание кода с нуля проще, чем изменение существующего кода, и тем самым делает рекламируемую работу более привлекательной для потенциальных сотрудников.

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

Это означает, что новая пара глаз имеет две строки живой и точной документации по рассматриваемому коду.

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

Единичные тесты захватывают и формально описывают знания, которыми обладал автор оригинала, когда они реализовали класс. Они предоставляют описание того, как ведет себя этот класс при использовании клиентом.

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

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

Мы автоматизируем процесс запуска тестов, чтобы они выполнялись каждый раз, когда мы выполняем сборку проекта. Мы также автоматизируем формирование отчетов о покрытии кода, в которых подробно описывается процентный коэффициент кода, который покрывается и осуществляется с помощью тестов. Мы стремимся к высоким процентам. Некоторые компании будут препятствовать проверке изменений кода в контроле исходного кода, если они не имеют достаточных модульных тестов, написанных для описания любых изменений в поведении кода. Обычно вторая пара глаз рассматривает изменения кода вместе с автором изменений. Рецензент проведет эти изменения, чтобы изменения были понятны и достаточно охвачены испытаниями. Таким образом, процесс обзора является ручным, но когда тесты (тесты на единицу и интеграцию и, возможно, пользовательские приемочные испытания) проходят этот процесс ручного обзора, становятся частью процесса автоматической сборки. Они запускаются каждый раз, когда изменяется изменение. continuous-integration сервер выполняет эту задачу как часть процесса сборки.

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

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

Существует предостережение Test Driven Development, и это то, что вам нужно писать код с целью его проверки. Это включает в себя кодирование для интерфейсов и использование таких методов, как Injection Dependency для создания экземпляров сотрудничающих объектов. Ознакомьтесь с работой Kent Beck, которая очень хорошо описывает TDD. Посмотрите кодирование на интерфейсы и изучите design-patterns

Ответ 3

Когда вы тестируете что-то вроде System.out, вы проверяете только небольшое количество возможных вариантов использования. Это не очень тщательно, когда вы имеете дело с системами, которые могут принимать почти бесконечное количество разных входов.

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

Для того, чтобы человек мог протестировать все эти разные входы, могут потребоваться недели, в то время как для машины может потребоваться несколько минут.

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

Если вы нарушите что-то в своем коде, вы узнаете об этом прямо сейчас, а не после развертывания, а не когда тестер QA поймает ошибку, а не когда ваши клиенты отменили. У вас также будет больше шансов немедленно исправить глюк, так как ясно, что вещь, которая сломала часть рассматриваемого кода, скорее всего, произошла с момента последнего компиляции. Таким образом, объем исследовательской работы, необходимой для решения проблемы, значительно снижается.

Ответ 4

Модульные тесты гарантируют, что код работает по назначению. Они также очень полезны для обеспечения того, что код по-прежнему работает по назначению, если вам придется впоследствии его изменить, чтобы создать новые функции, чтобы исправить ошибку. Обладая высоким охватом тестированием вашего кода, вы можете продолжить разработку функций, не выполняя много ручных тестов.

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

в JUnit также есть еще несколько дополнительных функций, таких как

Утверждение утверждения

JUnit предоставляет методы для проверки определенных условий, эти методы обычно начинаются с утверждений и позволяют вам указывать сообщение об ошибке, ожидаемый и фактический результат

Некоторые из этих методов:

• fail([message]) - Позволяет выполнить сбой теста. Может быть использован для проверки того, что определенная часть кода не достигнута. Или выполнить тест с ошибкой до того, как будет реализован тестовый код.
• assertTrue(true)/assertTrue(false) - всегда будет true/false. Может использоваться для предопределения результата теста, если тест еще не реализован.
• assertTrue([message,] condition) - Проверяет, что логическое condition истинно.
• assertEquals([message,] expected, actual) - Проверяет, равны ли два значения (в соответствии с методом equals, если они реализованы, в противном случае с помощью сравнения ссылок ==). Примечание. Для массивов это проверка, а не содержимое, используйте assertArrayEquals([message,] expected, actual) для этого.
• assertEquals([message,] expected, actual, delta) - Проверяет, находятся ли два значения float или double на некотором расстоянии друг от друга, контролируется значением delta.
• assertNull([message,] object) - Проверяет, что объект null

и т.д. См. Полный Javadoc для всех примеров здесь.

Suites

С наборами тестов вы можете в определенном смысле объединить несколько тестовых классов в один блок, чтобы вы могли выполнять их все сразу. Простой пример: объединение тестовых классов 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 { } 

Ответ 5

Я добавил, что некоторые другие System.out не могут делать:

• Независимо от каждого теста (важно)

  JUnit может это сделать: каждый раз создается новый экземпляр тестового примера и вызывается @Before.

• Отделите код тестирования от источника

  JUnit может это сделать.

• Интеграция с CI

  JUnit может сделать это с помощью Ant и Maven.

• Упорядочить и объединить тестовые примеры легко

  JUnit может выполнять @Ignore и набор тестов.

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

  JUnit предлагает множество методов Assert (assertEquals, assertSame...)

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

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

Ответ 6

Основным преимуществом JUnit является то, что он автоматизирован, а не вручную проверяет ваши распечатки. Каждый тест, который вы пишете, остается в вашей системе. Это означает, что если вы внесете изменения, у которых есть неожиданный побочный эффект, ваш тест поймает его и потерпит неудачу, а не вам придется вручную проверять все после каждого изменения.

Ответ 7

JUnit - это модульная платформа для языка программирования Java. Это важно в разработке, основанном на тестах, и является одним из семейств модулей модульного тестирования, которые все вместе называются xUnit.

JUnit продвигает идею "первого тестирования, затем кодирования", в котором основное внимание уделяется настройке тестовых данных для части кода, которая может быть проверена первой, а затем может быть реализована. Этот подход похож на "немного тестируйте, немного кода, немного тестируйте, немного кода...", что увеличивает производительность программиста и стабильность программного кода, что снижает напряжение программы и время, затрачиваемое на отладку.

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

Предоставляет аннотацию для определения методов тестирования.

Предоставляет утверждения для проверки ожидаемых результатов.

Предоставляет тестовые бегуны для запуска тестов.

Тесты JUnit позволяют быстрее писать код, увеличивая качество

JUnit элегантно прост. Он менее сложный и занимает меньше времени.

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

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

Junit показывает ход теста в зеленой полосе, если тест идет нормально, и при кратковременном тестировании становится красным.

Ответ 8

У меня немного другая перспектива, почему нужен JUnit.

Вы можете написать все тестовые примеры самостоятельно, но это громоздко. Вот проблемы:

• Вместо System.out мы можем добавить if(value1.equals(value2)) и вернуть 0 или -1 или сообщение об ошибке. В этом случае нам нужен "основной" тестовый класс, который запускает все эти методы и проверяет результаты и поддерживает, какие тестовые случаи не выполняются и которые передаются.

• Если вы хотите добавить еще несколько тестов, вам необходимо добавить их в этот "основной" тестовый класс. Изменения существующего кода. Если вы хотите автоматически обнаруживать тестовые примеры из тестовых классов, вам нужно использовать отражение.

• Все ваши тесты и ваш основной класс для запуска тестов не обнаруживаются eclipse, и вам нужно написать настраиваемые конфигурации отладки/запуска для запуска этих тестов. Тем не менее, вы все еще не видите эти яркие зеленые/красные выходы.

Вот что делает JUnit:

• Он имеет методы assertXXX(), которые полезны для печати полезных сообщений об ошибках из условий и передачи результатов в "основной" класс.

• "Основной" класс называется runner, который предоставляется JUnit, поэтому нам не нужно писать. И он автоматически определяет методы теста путем отражения. Если вы добавите новые тесты с аннотацией @Test, то они будут автоматически обнаружены.

• JUnit имеет интеграцию eclipse и интеграцию maven/ gradle, поэтому легко запускать тесты, и вам не придется писать настраиваемые конфигурации запуска.

Я не эксперт в JUnit, так что теперь я понял, добавит больше в будущем.

Ответ 9

Вы не можете написать какой-либо тестовый пример без использования рамки тестирования, иначе вам придется написать свой тест framewok, чтобы оправдать ваши тестовые примеры. Вот некоторая информация о JUnit Framework, кроме того, что вы можете использовать платформу TestNG.

Что такое Junit?

Junit - широко используемая среда тестирования вместе с языком программирования Java. Вы можете использовать эту инфраструктуру автоматизации как для модульного тестирования, так и для тестирования пользовательского интерфейса. Он помогает нам определить поток выполнения нашего кода с различными аннотациями. Junit построен на идее "первого тестирования, а затем кодирования", что помогает нам повысить производительность тестовых примеров и стабильность кода.

Важные особенности тестирования Junit -

• Это платформа тестирования с открытым исходным кодом, позволяющая пользователям эффективно писать и запускать тестовые примеры.
• Предоставляет различные типы аннотаций для идентификации методов тестирования.
• Предоставляет различные типы утверждений для проверки результатов выполнения тестового примера.
• Он также дает тест-бегунам для эффективного выполнения тестов.
• Это очень просто и, следовательно, экономит время.
• Он предоставляет способы организации ваших тестовых случаев в форме тестовых материалов.
• Это дает результаты теста случайным и элегантным способом.
• Вы можете интегрировать jUnit с Eclipse, Android Studio, Maven и Ant, Gradle и Jenkins

Ответ 10

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

Ответ 11

JUNIT: НАБЛЮДЕНИЕ И РЕГУЛИРОВАНИЕ

Вот моя перспектива JUNIT.

JUNIT можно использовать для,
1) Наблюдайте за поведением системы, когда новый блок добавляется в эту систему.
2) Внесите корректировки в систему, чтобы приветствовать "новое" устройство в системе.
Какие? Точно.

Реальная жизнь, например.

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

В терминах программирования

Система: Ваш код
UNIT: новая функциональность.
Поскольку среда JUNIT используется для JAVA-языка, поэтому JUNIT = JAVA UNIT (может быть).

Предположим, что у вас уже есть пуленепробиваемый код, но появилось новое требование, и вам нужно добавить новое требование в свой код. Это новое требование может нарушить ваш код для некоторого ввода (testcase).

Простой способ адаптировать это изменение - это модульное тестирование (JUNIT).
Для этого вы должны написать несколько тестовых файлов для своего кода при создании своей кодовой базы. И всякий раз, когда приходит новое требование, вы просто запускаете все тестовые примеры, чтобы проверить, не завершился ли какой-либо тест. Если "Нет", вы являетесь художником BadA **, и вы готовы развернуть новый код.
Если какой-либо из тест-систем не работает, вы меняете свой код и снова запускаете тестовые окна, пока не получите зеленый статус.