Введение

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

Существует три основных типа тестирования программного обеспечения:

• Модульное тестирование Модульное Обучение в основном используется для тестовых программных модулей, чтобы убедиться, что код работает правильно. Модульное тестированиепишутся и управляются разработчикамитест。Обычно используетсяиспользоватьизтест РамкаJUnitилиTestNG。тестиспользовать Примеры обычно дляметодуровеньизтест。
• Интеграционное тестирование Интеграционное Проверка используется для определения того, может ли система работать правильно. Интеграционное тестирование также производится разработчиками теста вместе с Модульным компоненты личного кода тестирования разные, Интеграционное тестирование — это система, выполняющая межкомпонентное тестирование.
• функциональное тестирование функциональное тестирование — это процесс обеспечения качества и тест «черного ящика», основанный на спецификации компонентов тестового программного обеспечения от входа до выхода. функциональное тестированиеобычно состоит из разныхизтесткомандавыполнять,тестиспользоватьпримериз Напишите, чтобы следовать спецификациям компонентов,Затем сравните фактический результат, полученный на основе входных данных, с ожидаемым значением.,Определите, правильно ли работает функция.

Обзор

Эта статья предназначена только дляМодульное тестированиеПредставьтесь,В основном знакомят с тем, каксуществоватьAndroid Studioпродолжить дальше Модульное тестирование,Модульное тестированиеделатьиспользоватьизтест РамкаJUnit

выгода

Возможно, все еще существует большое количество разработчиков, которые еще неделатьиспользоватьМодульное тестированиеимизкодвыполнять,С одной стороны, возможно, в этом нет необходимости.,Потому что этоделать Нетруководить Модульное Кстати, программа по-прежнему работает очень хорошо, с другой стороны, возможно, некоторые люди также согласны с Модульным; тестированиеизвыгода,Однако из-за необходимости дополнительных затрат на обучение,У многих людей нет времениили Он сказал, что ему не хватило терпения учиться.······

Вот что я хочу сказать,Если все пойдут посмотреть этоgithubВ нынешнем мейнстримеиз Фреймворк с открытым исходным кодом,star Проекты с относительно большим количеством проектов обычно имеют очень подробные варианты использования. Итак, Модульное тестирование Для развития нашего проекта,Все равно весьма выгодно.

Что касается преимуществ Модульного обучения, позвольте мне упомянуть здесь несколько моментов:

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

Юнит-тестирование

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

1 Введение

JUnit — это среда модульного тестирования для языка Java. Она была создана Кентом Беком и Эрихом Гаммой и постепенно стала самой успешной в семействе xUnit.

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

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

2 функции

JUnit предоставляет аннотации и определенные методы тестирования;

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

JUnit-тесты элегантны, лаконичны и не занимают много времени;

Тестирование JUnit позволяет каждому писать код быстрее и повышать качество;

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

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

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

3 контента

3.1 Аннотации

@Test: эта аннотация указывает, что прикрепленный к ней общедоступный метод void (то есть метод типа void, измененный с помощью public) может использоваться в качестве тестового примера;

@Before: эта аннотация указывает, что прикрепленный к ней метод должен выполняться перед каждым тестом в классе, чтобы выполнить определенные необходимые предварительные условия для теста;

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

@After: эта аннотация указывает, что присоединенный метод будет выполняться после выполнения каждого теста, например, сброс определенных переменных после выполнения каждого теста, удаление временных переменных и т. д.;

@AfterClass: эта аннотация указывает, что, когда все тесты необходимо выполнить после класса тестового примера JUnit, аннотацию AfterClass можно использовать для очистки метода установления, например отключения базы данных. BeforeClass) должен быть определен как статический;

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

/
* JUnit аннотация示пример
*/
@Test
public void testYeepay(){
  System.out.println("Отметить тестовый метод @Test!");
}
@AfterClass
public static void paylus(){
  System.out.println("После выполнения метода существующего класса варианта использования, отмеченного @AfterClass!");
}

3.2 Утверждение

Здесь автор представит некоторые методы утверждения, все они взяты из класса org.junit.Assert, который расширяет класс java.lang.Object и предоставляет возможность писать для них тесты для обнаружения сбоев. Короче говоря, мы используем метод утверждения, чтобы определить, совпадает ли фактический результат с нашим ожидаемым результатом. Если он такой же, тест успешен, в противном случае тест не пройден.

void assertEquals([String message], expected value, actual значение): утверждение Два значения равны, а тип значения может быть int, short, long, byte, char или
java.lang.Object, где первым параметром является необязательное строковое сообщение;
void assertTrue([String message], boolean условие): утверждение Условие истинно;
void assertFalse([String message],boolean условие): утверждение Условие ложно;
void assertNotNull([String message], java.lang.Object объект): утверждение Объект не пуст (ноль);
void assertNull([String message], java.lang.Object объект): утверждение Объект пуст (ноль);
void assertSame([String message], java.lang.Object expected, java.lang.Object фактическое): утверждение Два объекта относятся к одному и тому же объекту;
void assertNotSame([String message], java.lang.Object unexpected, java.lang.Object фактическое): утверждение. Два объекта не относятся к одному и тому же объекту;
void assertArrayEquals([String message], expectedArray, resultArray): утверждение ожидаемого массива и массива результатов равны, тип массива может быть int, long, short, char, byte. или java.lang.Object

4 различия между JUnit 3.X и JUnit 4.X

4.1 JUnit 3.X

(1) При использовании версии JUnit 3.X для модульного тестирования тестовый класс должен наследовать от родительского класса TestCase;

(2) Принципы, которым должны следовать методы испытаний:

① общественный;

② недействителен;

③ Нет параметров метода;

④Имя метода должно начинаться с test;

(3) Различные тестовые примеры должны сохранять полную независимость и не могут иметь никакой корреляции;

(4) Необходимо освоить порядок методов тестирования и нельзя полагаться на порядок выполнения самих методов тестирования.

/
* использовать JUnit 3.X выполнять
*/
import junit.framework.Assert;
import junit.framework.TestCase;
public class TestOperation extends TestCase {
  private Operation operation;
  public TestOperation(String name) { // Конструктор
    super(name);
  }
  @Override
  public void setUp() throws Exception { // существование каждого метода испытаний выполняется [До] будет скорректированоиспользовать,многоиспользоватьинициализировать
    System.out.println("добро пожаловатьделатьиспользоватьJunitруководить Модульное тестирование...");
    operation = new Operation();
  }
  @Override
  public void tearDown() throws Exception { // существование каждого метода испытаний выполняется [после] будет скорректированоиспользовать,многоиспользоватьосвободить ресурсы
    System.out.println("Юнит-тестирование Заканчивать...");  }
  public void testDivideByZero() {
    Throwable te = null;
    try {
      operation.divide(6, 0);
      Assert.fail("тест не пройден"); //утверждениенеудача    } catch (Exception e) {
      e.printStackTrace();
      te = e;
    }
    Assert.assertEquals(Exception.class, te.getClass());
    Assert.assertEquals("Дивизор не может быть 0 ", te.getMessage());
  }
}

4.2 JUnit 4.X

(1) При использовании версии JUnit 4.X для модульного тестирования тестовый класс не обязан наследовать родительский класс TestCase;

(2) версия JUnit 4.X, в которой для модульного тестирования используются аннотации;

(3) Наши часто используемые аннотации для JUnit 4.X включают:

Аннотация @Before: имеет ту же функцию, что и метод setUp() в JUnit 3.X. Он выполняется перед каждым методом тестирования и в основном используется для инициализации;

@After аннотации: он имеет ту же функцию, что и методearDown() в JUnit 3.X. Он выполняется после каждого метода тестирования и в основном используется для освобождения ресурсов;

Аннотация @Test(timeout = xxx): установите текущий метод тестирования для запуска в течение определенного периода времени, в противном случае будет возвращена ошибка;

Аннотация @Test(expected = Exception.class): определяет, генерирует ли тестируемый метод исключение. Тип выдаваемого исключения: Exception.class;

Кроме того, мы можем узнать больше об аннотациях, прочитав вторую часть «2 аннотации» выше.

/
* использовать JUnit 4.X выполнять
*/
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class TestOperation {
  private Operation operation;
  @BeforeClass
  public static void globalInit() { // существование выполняется до того, как будут выполнены все методы
    System.out.println("@BeforeClassотметкаизметод,существование выполняется до того, как будут выполнены все методы...");
  }
  @AfterClass
  public static void globalDestory() { // существование выполняется после выполнения всех методов
    System.out.println("@AfterClassотметкаизметод,существование выполняется после выполнения всех методов...");
  }
  @Before
  public void setUp() { // существуют, выполняются перед каждым методом тестирования
    System.out.println("@Beforeотметкаизметод,существуют, выполняются перед каждым методом тестирования...");
    operation = new Operation();
  }
  @After
  public void tearDown() { // существования выполняется после каждого тестового метода
    System.out.println("@Afterотметкаизметод,существования выполняется после каждого тестового метода...");
  }
  @Test(timeout=600)
  public void testAdd() { // Установите время выполнения ограниченного метода тестирования. Возвращать ошибку, если превышено
    System.out.println("тест add метод...");
    int result = operation.add(2, 3);
    assertEquals(5, result);
  }
  @Test
  public void testSubtract() {
    System.out.println("тест subtract метод...");
    int result = operation.subtract(1, 2);
    assertEquals(-1, result);
  }
  @Test
  public void testMultiply() {
    System.out.println("тест multiply метод...");
    int result = operation.multiply(2, 3);
    assertEquals(6, result);
  }
  @Test
  public void testDivide() {
    System.out.println("тест divide метод...");
    int result = 0;
    try {
      result = operation.divide(6, 2);
    } catch (Exception e) {
      fail();
    }
    assertEquals(3, result);
  }
  @Test(expected = Exception.class)
  public void testDivideAgain() throws Exception {
    System.out.println("тест divide метод, делитель 0 ситуация...");
    operation.divide(6, 0);
    fail("test Error");
  }
  public static void main(String[] args) {
  }
}

4.3 Специальное напоминание

Благодаря двум приведенным выше примерам мы уже можем примерно понять разницу между двумя версиями JUnit 3.X и JUnit 4.X!

Прежде всего, если мы используем JUnit 3.X, то при написании тестового класса мы должны наследовать класс TestCase. Но если мы используем JUnit 4.

В JUnit 3.X также обязательно указывать метод тестирования в формате «testXxxx»;

В Юните 4.

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

/
* Определяет правила сложения, вычитания, умножения и деления.
*/
public class Operation {
  public static void main(String[] args) {
    System.out.println("a + b = " + add(1,2));
    System.out.println("a - b = " + subtract(1,2));
    System.out.println("a * b = " + multiply(1,2));
    System.out.println("a / b = " + divide(4,2));
    System.out.println("a / b = " + divide(1,0));
  }
  public static int add(int a, int b) {
    return a + b;
  }
  public static int subtract(int a, int b) {
    return a - b;
  }
  public static int multiply(int a, int b) {
    return a * b;
  }
  public static int divide(int a, int b) {
    return a / b;
  }
}

5 тестовых примеров

5.1 Пример 1: Простой тест JUnit 3.X

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import java.util.ArrayList;
import java.util.Collection;
/
 * 1. Создайте тестовый класс и наследуйте класс TestCase.
 */
public class SimpleTestDemo extends TestCase {
  public SimpleTestDemo(String name) {
    super(name);
  }
  /
   * 2. Напишите метод тестирования, заявив желаемый результат.
   */
  public void testEmptyCollection(){
    Collection collection = new ArrayList();
    assertTrue(collection.isEmpty());
  }
  /
   * 3. Напишите метод suite(),это будетделатьиспользовать Динамика отраженияиз Создайте список, содержащий всеизtestXxxxметодизтестнабор
   */
  public static Test suit(){
    return new TestSuite(SimpleTestDemo.class);
  }
  /
   * 4. Напишите метод main() для удобного запуска теста в качестве средства обработки текста.
   */
  public static void main(String[] args) {
    junit.textui.TestRunner.run(suit());
  }
}

6 личных предложений

У некоторых детей могут возникать недопонимания, думая, что написание тестового кода бесполезно, что это увеличит их давление и приведет к потере времени. Но на самом деле все же есть большая разница между написанием тестового кода или нет. Если это в небольшом проекте, разница может быть неочевидной, но если это в большом проекте, как только возникает ошибка или исключение, используйте рабочую силу. Чтобы исправить это, устранение неполадок потребует много времени, и устранить неполадки может быть невозможно. Однако, если вы используете тестовый код, JUnit автоматически поможет нам определить, верны ли результаты некоторых кодов. таким образом, вы сэкономите гораздо больше времени, чем сможете написать. Время на тестирование вашего кода.

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

1. Не используйте конструктор TestCase для инициализации Fixture, а используйте методы setUp() и TearDown();

2. Не полагайтесь на порядок выполнения тестов и не предполагайте его, поскольку JUnit использует Vector для сохранения методов тестирования, поэтому разные платформы будут извлекать методы тестирования из Vector в разном порядке;

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

4. При наследовании тестового класса не забудьте вызвать методы setUp() и TearDown() родительского класса;

5. Соедините тестовый и рабочий код вместе, скомпилируйте и обновите их одновременно;

6. Классы тестов и методы тестирования должны иметь единую схему именования, например, добавление теста перед именем рабочего класса для формирования имени тестового класса;

7. Убедитесь, что тест не зависит от времени, и не используйте для тестирования просроченные данные, что затрудняет воспроизведение теста при последующем обслуживании;

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

9. Как можно чаще используйте методы утверждения и отказа, а также методы обработки исключений, предоставляемые JUnit, что может сделать код более кратким;

10. Тесты должны быть как можно меньшими и выполняться быстро;

11. Не указывайте жестко путь к файлу данных;

12. Используйте генератор документации для создания тестовой документации.

8 основных фреймворков модульного тестирования

1.Arquillian

Arquillian — это хорошо масштабируемая платформа тестирования на основе JVM, которая позволяет разработчикам создавать автоматизированные интеграционные, функциональные и приемочные тесты для Java. Arquillian позволяет выполнять тесты во время выполнения. Arquillian можно использовать для управления жизненным циклом контейнера (или контейнеров), привязки тестовых случаев, зависимых классов и ресурсов. Он также имеет возможность развертывать архивы в контейнеры, выполнять тесты в контейнере, фиксировать результаты и создавать отчеты.

Arquillian интегрируется со знакомыми платформами тестирования, такими как JUnit 4 и TestNG 5, и позволяет запускать тестирование с использованием существующих IDE. А благодаря модульной конструкции он может запускать тестовые плагины Ant и Maven. Цель Arquillian — упростить написание интеграционных и функциональных тестов проекта, сделав их такими же простыми, как модульные тесты.

2.JTEST

JTest, также известный как «Parasoft JTest», представляет собой программное обеспечение для автоматического тестирования программного обеспечения Java и статического анализа, созданное Parasoft. JTest включает в себя функциональные возможности для создания и выполнения модульных тестов, статического анализа кода, статического анализа потока данных и анализа показателей, регрессионного тестирования, обнаружения ошибок во время выполнения.

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

3.The Grinder

«The Grinder» — это среда нагрузочного тестирования Java. и облегчает распределенное тестирование за счет использования большого количества инжекторов нагрузки. Grinder может загружать тесты для чего угодно с помощью Java API. Сюда входят веб-серверы HTTP, SOAP, веб-службы REST, серверы приложений, включая специальные протоколы. Тестовые сценарии написаны на мощных языках Jython и Clojure. Консоль графического пользовательского интерфейса Grinder позволяет отслеживать и контролировать несколько инжекторов нагрузки, а также автоматически управлять клиентскими подключениями и файлами cookie, SSL, поддержкой прокси-серверов и ограничениями подключений. Более подробную информацию о возможностях измельчителя вы можете найти здесь.

4.TestNG

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

TestNG поддерживается различными инструментами и плагинами (такими как Eclipse, IDEA, Maven и т. д.).

5.JUnit

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

6.JWalk

JWalk разработан как набор инструментов модульного тестирования для языка программирования Java. Он предназначен для поддержки парадигмы тестирования, называемой «ленивое системное модульное тестирование».

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

7.Mockito

Mockito разработан как среда тестирования с открытым исходным кодом для Java, лицензия MIT. Mockito позволяет программистам создавать и тестировать двойные объекты (Mock-объекты) в автоматизированных модульных тестах для разработки через тестирование (TDD) или разработки через поведение (BDD).

8 Powermock

PowerMock — это Java-фреймворк для исходного кода модульного тестирования. Его можно использовать как расширение других фреймворков для макетирования, таких как прототип Mockito или EasyMock, но с более мощными функциями. PowerMock использует специальные загрузчики классов и манипуляторы байт-кода для реализации имитации статических методов, конструкторов, конечных классов и методов, частных методов и т. д. В основном он предназначен для расширения существующего API и использования небольшого количества методов и аннотаций для реализации дополнительных функций.