Пример учебника JUnit 4, JWebUnit, Arquillian и JSFUnit

Автор оригинала: Pankaj Kumar.

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

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

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

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

На JUnit разработано множество фреймворков ; такие фреймворки, как HttpUnit , ServeltUnit , JSFUnit , JWebUnit .. и другие являются образцами для тех программ, которые вы можете использовать для проверки своих компонентов, независимо от того, настолько ли просты ваши компоненты или для их функционирования требуется определенный контейнер.

Здесь вы найдете все, что вам нужно, чтобы понять основную терминологию JUnit и эффективно использовать ее функции. Кроме того, вы увидите, как проверить простой класс Java, веб-страницу, портлет и компоненты JSF с помощью JUnit, JWebUnit и JSFUnit (Arquillian) соответственно.

Ниже приведены основные маркеры, которые будут обсуждаться в этом руководстве, поскольку вы можете перейти непосредственно к тому, что вам нужно:

• Настройка JUnit
• Используйте JUnit Через Eclipse
• Аннотации JUnit; @Тест, @До, @После, @после класса, @Перед классом
• Время ожидания и ожидаемое
• Бегуны и Тип бегунов
• Утверждения и типы утверждений
• Немного О Библиотеке Хамкреста
• Расширение JUnit – JWebUnit
• Расширение JUnit – JSFUnit
• Maven и JUnit
• Резюме

Чтобы убедиться, что вы будете полностью осведомлены обо всех концепциях, которые будут обсуждаться в этом руководстве, убедитесь, что вы также прочитали их ниже:

• JS Учебник для начинающих , который поможет вам понять основные понятия о фреймворке JSF и разъяснит вам наиболее простой пример.
• Учебник по Apache Pluto while поможет вам понять основные понятия о портлете, контейнере портлета и разъяснит вам портлет HelloWorld.

Настройка JUnit

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

• Загрузите JUnit JAR из Центрального репозитория Maven.
• Загрузите hamcrest библиотеку из Центрального репозитория Maven. JUnit на самом деле зависит от этой библиотеки для более привлекательных, простых и понятных утверждений.
• Добавление библиотек JUnit и hamcrest в свой путь к классам. Самый простой способ, который вы можете использовать, – это установить эти библиотеки в каталоге расширений JDK.
  • Укажите, на какой JDK ссылается ваша среда. Переменная JAVA_HOME должна помочь.
  • Укажите местоположение расширения JDK, вы всегда сможете найти этот путь под своим каталогом JDK. %JAVA_HOME%\ jre\lib\ext .

• Убедитесь, что у вас есть библиотека JUnit внутри вашего пути к классам, вызвав java-подробный на консоли, которая мгновенно распечатает все загруженные классы.

Выполнение java -подробного

[Loaded org.junit.runner.JUnitCore from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.notification.RunListener from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.internal.TextListener from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.Describable from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.Runner from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.manipulation.Filterable from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.manipulation.Sortable from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.internal.runners.JUnit38ClassRunner from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.internal.JUnitSystem from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.Computer from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runners.model.RunnerBuilder from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.Computer$1 from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runners.ParentRunner from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runners.Suite from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.notification.RunNotifier from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.notification.SynchronizedRunListener from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]
[Loaded org.junit.runner.notification.StoppedByUserException from file:/C:/Program%20Files/Java/jdk1.6.0_26/jre/lib/ext/junit-4.12.jar]

• Создайте самый простой тестовый пример, как показано ниже

Создайте самый простой тестовый пример, как показано ниже

import org.junit.Test;
import static org.junit.Assert.*;

public class HelloWorldTestCase {

	@Test
	public void testHelloWorld(){
		// Print a message before assertion
		System.out.println("Before Getting Test Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test Execution ::");
	}

	public static void main(String [] args){
		// JUnitCore is provided by JUnit to run your Tests through consols
		org.junit.runner.JUnitCore.runClasses(HelloWorldTestCase.class);
	}
}

• Откройте консоль и скомпилируйте класс, а затем выполните его. Мы использовали assertEquals, которые должны сравнивать значения двух последних аргументов ( Вызов equals() ). Подробнее позже.
• JUnitCore-это класс, предоставляемый JUnit, позволяющий запускать и отображать результаты непосредственно через консоль.
• Вызовите компиляцию и интерпретацию Java соответственно против вашего HelloWorldTestCase.

• Если у вас изменились аргументы (например, привет и Привет), вы, конечно, увидите результат ниже:

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

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

Используйте JUnit Через Eclipse

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

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

Ниже приведены необходимые шаги, которые приведут вас к правильному использованию JUnit в среде Eclipse IDE.

• Удалите банки JUnit и hamcrest из расширения JDK, чтобы вы могли ссылаться на те, которые предоставлены самим Eclipse. Убедитесь, что они удалены, вызвав java-подробный и поискав JUnit.
• Установите Eclipse IDE , для этого урока я буду использовать Eclipse Kepler.
• Создайте самый простой проект Maven, используя встроенный в Eclipse архетип быстрого запуска Maven.

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

• Заполните всю необходимую информацию, идентификатор группы, идентификатор артефакта и пакет, а затем завершите.

• Убедитесь, что в вашем проекте, созданном недавно, нет никаких проблем или ошибок. В случае, если да, это видно, просто удалите родительский раздел, так как большинство этих архетипов слишком старые.
• В вашем созданном проекте будет ссылка на библиотеку JUnit, которая абсолютно слишком стара и нуждается в некоторой доработке. Откройте файл pom и измените версию библиотеки JUnit на 4.12 и добавьте зависимость hamcrest maven. Ваш файл pom должен выглядеть следующим образом:

В вашем созданном проекте будет ссылка на библиотеку JUnit, которая абсолютно слишком стара и нуждается в некоторой доработке. Откройте файл pom и измените версию библиотеки JUnit на 4.12 и добавьте зависимость hamcrest maven. Ваш файл pom должен выглядеть следующим образом:

	4.0.0
	com.journaldev
	HelloWorldTestCase
	0.0.1-SNAPSHOT
	HelloWorldTestCase
	https://maven.apache.org
	
		UTF-8
	
	
		
			junit
			junit
			4.12
		
		
			org.hamcrest
			hamcrest-core
			1.3
		
	

• Выполните обычную очистку для вашего проекта, чтобы эти банки, на которые ссылаются, были установлены.
• Обратите внимание, что в вашем проекте есть два пакета; один представляет ваши классы, а другой-тестовые примеры. Я настоятельно рекомендую удалить их на данный момент, чтобы вы могли начать с чистого листа.

Не обращайте внимания на пакет com.journaldev, расположенный под src/test/java, так как у нас будет отдельный раздел, в котором показано, как интегрировать ваши тестовые наборы JUnit с инструментом сборки Maven.

• Создайте класс HelloWorldTestCase, который вы создали ранее в своем проекте и под своим пакетом.

Создайте класс HelloWorldTestCase, который вы создали ранее в своем проекте и под своим пакетом.

package com.journaldev;

import org.junit.Test;
import static org.junit.Assert.*;

public class HelloWorldTestCase {

	@Test
	public void testHelloWorld(){
		// Print a message before assertion
		System.out.println("Before Getting Test Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test Execution ::");
	}

	public static void main(String [] args){
		// JUnitCore is provided by JUnit to run your Tests through console
		org.junit.runner.JUnitCore.runClasses(HelloWorldTestCase.class);
	}
}

• Скомпилируйте свой проект и убедитесь, что у вас нет никаких ошибок.
• Чтобы выполнить свой проект, у вас есть два варианта:
  • Выполните его нормально, как вы делали выше, с любым обычным классом Java, у которого есть основной метод.
  • Выполните его с помощью средства JUnit среды разработки Eclipse.
• Выполнение проекта первым способом приведет вас к следующему результату (CTRL + SHIFT + x & j):

• Выполнение проекта вторым способом приведет вас к следующему хорошему результату (CTRL + SHIFT + x & t:

• Как вы заметили выше, теперь рядом с приведенными выше сообщениями на консоли есть индикаторы, сообщающие вам о результатах тестирования.

Аннотации JUnit; @Тест, @До, @После, @после класса, @Перед классом

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

Это использование не предполагает определения основного метода, поэтому вам следует использовать CTRL + SHIFT + x & t каждый раз, когда вы хотите выполнить свои тесты.

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

Чтобы определить тестовый набор в вашем классе, вы должны использовать аннотацию @Test в сочетании с определенным вами методом. Этот класс и этот метод должны иметь следующие правила:

• Ваш класс должен быть определен как общедоступный и иметь конструктор по умолчанию (нулевой аргумент).
• Ваш метод тестирования должен быть определен как общедоступный, не принимать аргументов и возвращать значение void.

Как только платформа JUnit встретит аннотацию @Test, она создаст экземпляр этого класса, содержащий этот метод и вызывающий аннотированный метод @Test. Такова философия JUnit и то, как она работает.

Если в вашем тестовом классе есть два метода с аннотацией @Test, это означает, что JUnit создаст два экземпляра для вызова обоих из них и так далее. В связи с этим вы не можете повторно использовать значения переменных экземпляра в разных методах тестирования.

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

Не рекомендуется предоставлять еще одно утверждение в методе @Test, чтобы вы точно знали, какой тестовый случай не удался и из-за чего он получил. Но на самом деле никаких ограничений со стороны самой платформы JUnit не применялось.

Вы видели, как можно использовать один метод @Test, но давайте теперь посмотрим, как мы можем одновременно использовать еще один метод @Test.

Вы видели, как можно использовать один метод @Test, но давайте теперь посмотрим, как мы можем одновременно использовать еще один метод @Test.

package com.journaldev;

import org.junit.Test;
import static org.junit.Assert.*;

public class HelloWorldTestCase {

	@Test
	public void testHelloWorldOne(){
		// Print a message before assertion
		System.out.println("Before Getting Test #1 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #1 Execution ::");
	}

	@Test
	public void testHelloWorldTwo(){
		// Print a message before assertion
		System.out.println("Before Getting Test #2 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #2 Execution ::");
	}	

}

Выполнение приведенного выше примера приведет к следующему:

Результат Выполнения

Before Getting Test #1 Started ::
After Test #1 Execution ::
Before Getting Test #2 Started ::
After Test #2 Execution ::

• Как вы можете заметить, выполняются два теста, и результат выводится с помощью индикаторов Junit Eclipse.

Но то, что я вам хочу, чтобы некоторые предварительные/последующие выполнения для ваших тестов, что-то выполнялось непосредственно до или/и после любого метода @Test и без какого-либо уважения к тому, успешно ли завершен @Test или нет. Затем вы должны использовать @Before и @After соответственно. Давайте теперь посмотрим, как это работает после добавления этих методов, которые помечены @Before и @After.

Но то, что я вам хочу, чтобы некоторые предварительные/последующие выполнения для ваших тестов, что-то выполнялось непосредственно до или/и после любого метода @Test и без какого-либо уважения к тому, успешно ли завершен @Test или нет. Затем вы должны использовать @Before и @After соответственно. Давайте теперь посмотрим, как это работает после добавления этих методов, которые помечены @Before и @After.

package com.journaldev;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.*;

public class HelloWorldTestCase {

	@Before
	public void beforeExecutingTestCase(){
		System.out.println("Before Executing Test Case :: ");
	}

	@After
	public void afterExecutingTestCase(){
		System.out.println("After Executing Test Case :: ");
	}

	@Test
	public void testHelloWorldOne(){
		// Print a message before assertion
		System.out.println("Before Getting Test #1 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #1 Execution ::");
	}

	@Test
	public void testHelloWorldTwo(){
		// Print a message before assertion
		System.out.println("Before Getting Test #2 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #2 Execution ::");
	}	

}

Выполнение вышеперечисленного должно привести вас к следующему:

Результат Выполнения

Before Executing Test Case ::
Before Getting Test #1 Started ::
After Test #1 Execution ::
After Executing Test Case ::
Before Executing Test Case ::
Before Getting Test #2 Started ::
After Test #2 Execution ::
After Executing Test Case ::

Вы можете заметить выше выполнение метода @Before и @After, до и после каждого метода @Test.

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

С другой стороны, что делать, если вы хотите, чтобы методы вызывались прямо перед всеми вашими методами @Test и после всех ваших методов @Test. Это именно то, что вы получаете, когда используете @BeforeClass и @AfterClass.

С другой стороны, что делать, если вы хотите, чтобы методы вызывались прямо перед всеми вашими методами @Test и после всех ваших методов @Test. Это именно то, что вы получаете, когда используете @BeforeClass и @AfterClass.

package com.journaldev;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import static org.junit.Assert.*;

public class HelloWorldTestCase {

	@BeforeClass
	public static void beforeExecutingHelloWorldTestCases(){
		System.out.println("Before Executing HelloWorldTestCases :: ");
	}

	@AfterClass
	public static void afterExecutingHelloWorldTestCases(){
		System.out.println("After Executing HelloWorldTestCases :: ");
	}

	@Before
	public void beforeExecutingTestCase(){
		System.out.println("Before Executing Test Case :: ");
	}

	@After
	public void afterExecutingTestCase(){
		System.out.println("After Executing Test Case :: ");
	}

	@Test
	public void testHelloWorldOne(){
		// Print a message before assertion
		System.out.println("Before Getting Test #1 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #1 Execution ::");
	}

	@Test
	public void testHelloWorldTwo(){
		// Print a message before assertion
		System.out.println("Before Getting Test #2 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #2 Execution ::");
	}	

}

Результатом выполнения для вышеперечисленного будет:

Результат Выполнения

Before Executing HelloWorldTestCases ::
Before Executing Test Case ::
Before Getting Test #1 Started ::
After Test #1 Execution ::
After Executing Test Case ::
Before Executing Test Case ::
Before Getting Test #2 Started ::
After Test #2 Execution ::
After Executing Test Case ::
After Executing HelloWorldTestCases ::

Как вы можете заметить, методы @BeforeClass и @AfterClass были вызваны один раз до и после всех ваших методов @Test.

Время ожидания и ожидаемое

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

Хотя никакие конкретные аннотации не могут быть использованы, но @Test теперь будет иметь дополнительные атрибуты, которые вы можете использовать для разрешения этих функций.

Аргумент тайм-аута передается для аннотации @Test, чтобы указать, до какой миллисекунды(ов) этот метод будет ждать, прежде чем произойдет сбой. Это на самом деле очень полезно, когда вы собираетесь изучить и проверить производительность данного кода.

Следующий пример наглядно показывает, как это можно использовать:

Следующий пример наглядно показывает, как это можно использовать:

package com.journaldev;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import static org.junit.Assert.*;

public class HelloWorldTestCase {

	@BeforeClass
	public static void beforeExecutingHelloWorldTestCases(){
		System.out.println("Before Executing HelloWorldTestCases :: ");
	}

	@AfterClass
	public static void afterExecutingHelloWorldTestCases(){
		System.out.println("After Executing HelloWorldTestCases :: ");
	}

	@Before
	public void beforeExecutingTestCase(){
		System.out.println("Before Executing Test Case :: ");
	}

	@After
	public void afterExecutingTestCase(){
		System.out.println("After Executing Test Case :: ");
	}

	@Test
	public void testHelloWorldOne(){
		// Print a message before assertion
		System.out.println("Before Getting Test #1 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #1 Execution ::");
	}

	@Test
	public void testHelloWorldTwo(){
		// Print a message before assertion
		System.out.println("Before Getting Test #2 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #2 Execution ::");
	}	

	@Test(timeout=1)
	public void testWaitForATime(){
		// Print statement
		System.out.println("@Test Will Be Waiting For 100 Milliseconds :: Supposed Task Should Be Done Before Timeout");

		// Some adhoc processing
		for(int i = 0 ; i < 1000 ; i++){
			Math.random();
		}
		// Print statement
		System.out.println("Task Done Before Timeout :: This Test Has Finished Sucessfully ::");
	}

}

Вот подробная информация о коде, указанном выше:

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

Все дело в таймауте и в том, как указать его в сочетании с аннотацией @Test. Но что делать, если вы хотите, чтобы определенный метод тестирования потерпел неудачу, если не было создано определенное исключение или наоборот; при определенном исключении следует считать успешным. На самом деле это то, о чем вы говорили, когда использовали ожидаемый аргумент. В следующем примере показан метод тестирования, который генерирует число и находит результат % 2, чтобы указать, четное это число или нет. В случае четности будет инициализирована строковая переменная, в противном случае это не так.

Все дело в таймауте и в том, как указать его в сочетании с аннотацией @Test. Но что делать, если вы хотите, чтобы определенный метод тестирования потерпел неудачу, если не было создано определенное исключение или наоборот; при определенном исключении следует считать успешным. || На самом деле это то, о чем вы говорили, когда использовали || ожидаемый || аргумент. В следующем примере показан метод тестирования, который генерирует число и находит результат % 2, чтобы указать, четное это число или нет. В случае четности будет инициализирована строковая переменная, в противном случае это не так.

package com.journaldev;

import java.io.File;
import java.io.UnsupportedEncodingException;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import static org.junit.Assert.*;

public class HelloWorldTestCase {

	@BeforeClass
	public static void beforeExecutingHelloWorldTestCases(){
		System.out.println("Before Executing HelloWorldTestCases :: ");
	}

	@AfterClass
	public static void afterExecutingHelloWorldTestCases(){
		System.out.println("After Executing HelloWorldTestCases :: ");
	}

	@Before
	public void beforeExecutingTestCase(){
		System.out.println("Before Executing Test Case :: ");
	}

	@After
	public void afterExecutingTestCase(){
		System.out.println("After Executing Test Case :: ");
	}

	@Test
	public void testHelloWorldOne(){
		// Print a message before assertion
		System.out.println("Before Getting Test #1 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #1 Execution ::");
	}

	@Test
	public void testHelloWorldTwo(){
		// Print a message before assertion
		System.out.println("Before Getting Test #2 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #2 Execution ::");
	}	

	@Test(timeout=1)
	public void testWaitForATime(){
		// Print statement
		System.out.println("@Test Will Be Waiting For 100 Milliseconds :: Supposed Task Should Be Done Before Timeout");

		// Some adhoc processing
		for(int i = 0 ; i < 100 ; i++){
			Math.random();
		}
		// Print statement
		System.out.println("Task Done Before Timeout :: This Test Has Finished Sucessfully ::");
	}

	@Test(expected=NullPointerException.class)
	public void testNullPointerExceptionShouldBeRaised() throws UnsupportedEncodingException{
		// Define variable
		String variable = null;
		// Get random number
		double value = Math.random() * 100;

		// Print out value
		System.out.println("Value :: "+(int)value);

		if((int)value % 2 == 0){
			// Specify variable value
			variable = "Even Number";
		}
		// Print out variable content with UTF-8 encoding
		System.out.println("This number is :: "+new String(variable.getBytes(),"UTF-8"));
	}

}

Вот подробное объяснение кода, перечисленного выше:

• Чтобы указать, должен ли метод тестирования генерировать определенное исключение или нет, вы должны указать ожидаемый аргумент с аннотацией @Test.
• Если было вызвано исключение NullPointerException, этот тест будет успешно пройден. В противном случае он потерпит неудачу, даже если его утверждение(утверждения) будет выполнено.

Бегуны и типы бегунов

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

Независимо от способа, который вы выбрали для запуска своих тестовых наборов; либо с помощью командной консоли JUnit, либо с помощью среды разработки Eclipse, ваши тестовые наборы должны запускаться с использованием реализации Runner.

Пока мы использовали org.junit.runner.JUnitCore для выполнения наших тестовых примеров из командной строки или с помощью выполнения класса Eclipse по умолчанию (т. Е. класса с основным методом), Eclipse использует встроенный графический бегун по умолчанию для их выполнения.

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

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

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

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

То есть, если вы хотите использовать параметризованный бегун, вы должны определить аннотацию @RunWith в объявлении класса, за которой следует Parametrized.class значение. Посмотрите пример ниже:

То есть, если вы хотите использовать параметризованный бегун, вы должны определить аннотацию @RunWith в объявлении класса, за которой следует || Parametrized.class || значение. Посмотрите пример ниже:

package com.journaldev;

import static org.junit.Assert.assertEquals;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class ParametrizedHelloWorldTestCase{

	// Define parametrized's properties
	private String expected;
	private String actualValue;

	public ParametrizedHelloWorldTestCase(String expected, String actualValue) throws Throwable {
		// Set values
		this.expected = expected;
		this.actualValue = actualValue;
	}

	@Parameters
	public static Collection

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

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

• Чтобы использовать параметризованный бегун, вы должны определить следующее:

  • Определите атрибуты, которые будут использоваться для передачи параметров. Это было сделано путем предоставления ожидаемых и фактических значений переменных экземпляра.
  • Определите метод, который будет использоваться для заполнения Тестовых данных ; этот метод должен быть аннотирован @Parameters, он также должен быть статическим и возвращать тип коллекции<Объект []>.
  • Определите параметризованный конструктор, который будет использоваться для назначения переданных Тестовых данных .

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

Очень важно отметить следующие моменты в результате:

• Поскольку у вас есть две пары Тестовых данных {"Привет, мир","Привет , мир"} и {"Привет, мир","ПРИВЕТ, мир"} , и в соответствии с тем, что @Test вызывается в сочетании с созданием экземпляра, таким образом, вы должны заметить, что у нас есть два разных экземпляра с двумя парами параметров. Обратите внимание на ссылки на объекты.
• Поскольку ожидается, что первый assertEquals будет завершен должным образом, а второй-нет, ожидается, что он будет иметь следующие показатели ниже.

• Две пары параметров инициализировали бы два разных экземпляра и, следовательно, два разных тестовых случая. Если один из них потерпит неудачу, весь тестовый случай также потерпит неудачу.
• Ответственность за создание этих классов и передачу соответствующих параметров лежит на платформе JUnit.
• Количество созданных экземпляров равно количеству элементов, определенных в @Параметризованном методе.

Теперь давайте посмотрим на второго специального бегуна; это люкс. Если вы хотите агрегировать тестовые классы, обязательно используйте Suite Runner. Следующий пример, который покажет вам, как можно использовать SuiteRunner:

Теперь давайте посмотрим на второго специального бегуна; это люкс. Если вы хотите агрегировать тестовые классы, обязательно используйте Suite Runner. Следующий пример, который покажет вам, как можно использовать SuiteRunner:

package com.journaldev;

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

@RunWith(Suite.class)
@SuiteClasses({HelloWorldTestCase.class,ParametrizedHelloWorldTestCase.class})
public class SuiteHelloWorldTestCase {

}

Вот подробное объяснение кода, перечисленного выше:

• Если вы не упоминаете какой-либо метод @Test, но используете CTRL + SHIFT + x & t, это приведет к выполнению всех тестовых случаев внутри обоих HelloWorldTestCase и Параметризованный helloworldtestcase соответственно.
• Используйте @Suite и @SuiteClasses для объявления данного класса в качестве держателя для тестовых классов, а также для определения того, какие тестовые классы должны выполняться и к какому приоритету они должны быть отнесены.
• Если бы вы изменили приоритет упоминания тестовых классов в @SuiteClasses, приоритет выполнения также был бы изменен.
• Класс Suite останется пустым, так как он является всего лишь держателем аннотации объявления класса. То есть, если вы определите метод @Test в классе Suite, он больше не будет выполняться.
• Выполнение приведенного выше кода приведет вас к нижеприведенному результату. Этот результат ниже показывает вам все методы @Test, выполняемые из одного тестового класса под названием now suite.

Если вы правильно понимаете SuiteRunner, вы должны использовать первую категорию плавно и без каких-либо проблем. Все, что вам нужно сделать, это классифицировать свои тестовые классы и указать, какие тестовые классы вы хотели бы включить/исключить при выполнении.

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

Ниже приведен полный образец с необходимыми шагами для использования бегуна по категориям:

• Создайте свои категории, которые представляют собой набор интерфейсов.

Создайте свои категории, которые представляют собой набор интерфейсов.

package com.journaldev.categories;

public interface Mandatory {

}

Создайте свои категории, которые представляют собой набор интерфейсов.

package com.journaldev.categories;

public interface Optional {

}

• Аннотируйте свои тестовые классы нужной категорией. Например, созданный Параметризованный HelloWorldTestCase будет помечен как обязательный, в то время как HelloWorldTestCase является необязательным.

Аннотируйте свои тестовые классы нужной категорией. Например, созданный || Параметризованный HelloWorldTestCase || будет помечен как обязательный, в то время как || HelloWorldTestCase || является необязательным.

package com.journaldev;

import static org.junit.Assert.assertEquals;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

import com.journaldev.categories.Mandatory;

@RunWith(Parameterized.class)
@Category(Mandatory.class)
public class ParametrizedHelloWorldTestCase{

	// Define parametrized's properties
	private String expected;
	private String actualValue;

	public ParametrizedHelloWorldTestCase(String expected, String actualValue) throws Throwable {
		// Set values
		this.expected = expected;
		this.actualValue = actualValue;
	}

	@Parameters
	public static Collection

Аннотируйте свои тестовые классы нужной категорией. Например, созданный || Параметризованный HelloWorldTestCase || будет помечен как обязательный, в то время как || HelloWorldTestCase || является необязательным.

package com.journaldev;

import static org.junit.Assert.assertEquals;

import java.io.UnsupportedEncodingException;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.experimental.categories.Category;

import com.journaldev.categories.Optional;

@Category(Optional.class)
public class HelloWorldTestCase {

	@BeforeClass
	public static void beforeExecutingHelloWorldTestCases(){
		System.out.println("Before Executing HelloWorldTestCases :: ");
	}

	@AfterClass
	public static void afterExecutingHelloWorldTestCases(){
		System.out.println("After Executing HelloWorldTestCases :: ");
	}

	@Before
	public void beforeExecutingTestCase(){
		System.out.println("Before Executing Test Case :: ");
	}

	@After
	public void afterExecutingTestCase(){
		System.out.println("After Executing Test Case :: ");
	}

	@Test
	public void testHelloWorldOne(){
		// Print a message before assertion
		System.out.println("Before Getting Test #1 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #1 Execution ::");
	}

	@Test
	public void testHelloWorldTwo(){
		// Print a message before assertion
		System.out.println("Before Getting Test #2 Started ::");

		// If assertion goes wrong, the execution of Test would fail
		assertEquals("Would Say Hello","Hello","Hello");

		// Print a message after execution of Test; if assertion goes well, this message would be shown
		System.out.println("After Test #2 Execution ::");
	}	

	@Test(timeout=1)
	public void testWaitForATime(){
		// Print statement
		System.out.println("@Test Will Be Waiting For 100 Milliseconds :: Supposed Task Should Be Done Before Timeout");

		// Some adhoc processing
		for(int i = 0 ; i < 100 ; i++){
			Math.random();
		}
		// Print statement
		System.out.println("Task Done Before Timeout :: This Test Has Finished Sucessfully ::");
	}

	@Test(expected=NullPointerException.class)
	public void testNullPointerExceptionShouldBeRaised() throws UnsupportedEncodingException{
		// Define variable
		String variable = null;
		// Get random number
		double value = Math.random() * 100;

		assertEquals("Would Say Hello","Hello","Hello");

		// Print out value
		System.out.println("Value :: "+(int)value);

		if((int)value % 2 == 0){
			// Specify variable value
			variable = "Even Number";
		}
		// Print out variable content with UTF-8 encoding
		System.out.println("This number is :: "+new String(variable.getBytes(),"UTF-8"));
	}

}

• Предоставление категорий для созданных вами тестовых классов ничего не изменит для них, но они сделают их мишенью для бегуна по категориям. Ваши тестовые классы, как если бы они продолжали работать, как только на них были вызваны CTRL + SHIFT + x & t.

Предоставление категорий для созданных вами тестовых классов ничего не изменит для них, но они сделают их мишенью для бегуна по категориям. Ваши тестовые классы, как если бы они продолжали работать, как только на них были вызваны CTRL + SHIFT + x & t.

package com.journaldev;

import org.junit.experimental.categories.Categories;
import org.junit.experimental.categories.Categories.ExcludeCategory;
import org.junit.experimental.categories.Categories.IncludeCategory;
import org.junit.runner.RunWith;
import org.junit.runners.Suite.SuiteClasses;

import com.journaldev.categories.Mandatory;
import com.journaldev.categories.Optional;

@RunWith(Categories.class)
@IncludeCategory(Mandatory.class)
@ExcludeCategory(Optional.class)
@SuiteClasses({ParametrizedHelloWorldTestCase.class,HelloWorldTestCase.class})
public class CategorizeHelloWorldTestCase {

}

Вот подробное объяснение кода, перечисленного выше:

• Поскольку бегун категории – это особый тип набора, поэтому вы должны использовать @RunWith, но на этот раз с Category.class ценность.
• @SuiteClasses будет содержать все целевые тестовые классы.
• @IncludeCategory и @ExcludeCategory должны использоваться для включения и исключения тестовых классов соответственно.
• Выполнение бегуна по категориям, реализованного выше, приведет вас к результату ниже:

• Будучи @IncludeCategory упомянул Параметризованный HelloWorldTestCase в круглых скобках, то он будет выполняться.
• Будучи @Excludecategory упомянул HelloWorldTestCase в круглых скобках, то он не будет выполняться.

Утверждения и типы утверждений

Вы видели перед использованием assert(*) внутри нашего метода @Test, и в соответствии с рекомендациями каждый метод @Test должен включать один из статических методов assert (*), чтобы платформа JUnit могла проверить этот тестовый случай и убедиться, что он прошел или не прошел.

Весь наш пример был использован assertEquals , который известен как тип утверждений, которые вы можете использовать. Этот раздел приведен здесь, чтобы помочь вам увидеть все типы утверждений, чтобы использовать то, что вы хотите, в своих методах @Test.

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

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

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

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

Существует также дельта-аргумент, который вы иногда использовали с некоторыми типами утверждений, такими как assertEquals , когда он принимает двойные аргументы. Это значение дельты используется для определения того, находится ли ваше фактическое значение (результат вашего уравнения) в пределах ожидаемого – дельта и ожидаемого + дельта.

Теперь следующий пример показывает вам все эти упомянутые утверждения в одной полной демонстрации:

Теперь следующий пример показывает вам все эти упомянутые утверждения в одной полной демонстрации:

package com.journaldev;

import org.junit.Test;

public class AssertionTypesTestCases {
	@Test
	public void assertEqualArrays(){

		// Declare first array
		int [] arr1 = {1,2,3,4};

		// Declare second array
		int [] arr2 = {1,2,3,4};

		// Assert
		org.junit.Assert.assertArrayEquals("Arrays Aren't Equal ::", arr1, arr2);
	}

	@Test
	public void assertNoEqualArrays(){
		// Declare first array
		int [] arr1 = {1,2,3,4};

		// Declare second array
		int [] arr2 = {1,2,3,5};

		// Assert
		org.junit.Assert.assertArrayEquals("Arrays Aren't Equal ::", arr1, arr2);
	}	

	@Test
	public void assertEquals(){
		// Declare first object
		String message1 = "Hi World";

		// Declare second object
		String message2 = "Hi World";

		// Assert
		org.junit.Assert.assertEquals("Objects Aren't Equal ::", message1, message2);
	}

	@Test
	public void assertNotEquals(){
		// Declare first object
		String message1 = "Hi World";

		// Declare second object
		String message2 = "HI World";

		// Assert
		org.junit.Assert.assertEquals("Objects Aren't Equal ::", message1, message2);
	}	

	@Test
	public void assertSame(){
		// Declare first object
		String message1 = "Hi World";

		// Declare second object
		String message2 = message1;

		// Assert
		org.junit.Assert.assertSame("Objects Aren't Same ::", message1, message2);
	}

	@Test
	public void assertNotSame(){
		// Declare first object
		String message1 = "Hi World";

		// Declare second object
		String message2 = "HI World"; // if you make it Hi World, this assertion would pass

		// Assert
		org.junit.Assert.assertSame("Objects Aren't Same ::", message1, message2);
	}

	@Test
	public void assertTrue(){
		// Declare first object
		String message1 = "Hi World";

		// Declare second object
		String message2 = message1;

		// Assert
		org.junit.Assert.assertTrue("Result Isn't True ::", message1.equals(message2));
	}

	@Test
	public void assertNotTrue(){
		// Declare first object
		String message1 = "Hi World";

		// Declare second object
		String message2 = "Hi World";

		// Assert
		org.junit.Assert.assertSame("Result Isn't True ::", message1.equals(message2));
	}	

	@Test
	public void assertNull(){
		// Declare first object
		String message1 = null;

		// Assert
		org.junit.Assert.assertNull("Result Is Null ::", message1);
	}

	@Test
	public void assertNotNull(){
		// Declare first object
		String message1 = "Hi World";

		// Assert
		org.junit.Assert.assertNull("Result Isn't True ::", message1);
	}		

}

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

Обратите внимание, что все неудачные утверждения будут иметь отображаемое сообщение об ошибке. Это сообщение передается через само assert (*).

Немного О Библиотеке Хамкреста

Вы видели выше, насколько метод Assert(*) помогает вам судить о заданных уравнениях и утверждать их, чтобы в конечном итоге составить ваши тестовые примеры. Эти утверждения не являются просто утверждениями, предоставленными самим JUnit. Библиотека Hamcrest также создает расширение для JUnit и предоставляет вам еще один их набор (давайте назовем их сопоставителями).

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

И вот ниже приведен пример, в котором будут использоваться все эти совпадения:

И вот ниже приведен пример, в котором будут использоваться все эти совпадения:

package com.journaldev;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.hamcrest.object.IsCompatibleType;
import org.junit.Test;

public class HamcrestTestCases {

	@Test
	public void testStartWith(){

		// Create Employee instance
		Employee employee = new Employee();

		// Using assertThat to evaluate specific matcher
		assertThat(employee.getName(), startsWith("Empty"));
	}

	@Test
	public void testEndsWith(){

		// Create Employee instance
		Employee employee = new Employee();

		// Using assertThat to evaluate specific matcher
		assertThat(employee.getName(), endsWith("Name"));
	}	

	@Test
	public void testContainsWith(){

		// Create Employee instance
		Employee employee = new Employee();

		// Using assertThat to evaluate specific matcher
		assertThat(employee.getName(), containsString("y N"));
	}	

	@Test
	public void testEqualToIgnoringCase(){
		// Create Employee instance
		Employee employee = new Employee();

		// Using assertThat to evaluate specific matcher
		assertThat(employee.getName(), equalToIgnoringCase("eMpTy NaMe"));
	}

	@Test
	public void testEqualToIgnoringWhiteSpace(){
		// Create Employee instance
		Employee employee = new Employee();

		// Using assertThat to evaluate specific matcher
		assertThat(employee.getName(), equalToIgnoringWhiteSpace("    Empty       Name       "));
	}	

	@Test
	public void testhasItem(){
		// Create Employee instance
		Employee employee = new Employee();

		// Create employees list
		List employees = new ArrayList();

		// Add employee
		employees.add(employee);

		// Using assertThat to evaluate specific matcher
		assertThat(employees,hasItem(employee));
	}	

	@Test
	public void testhasItems(){
		// Create Employee instance
		Employee employee1 = new Employee();

		// Create Employee instance
		Employee employee2 = new Employee();		

		// Create employees list
		List employees = new ArrayList();

		// Add employee
		employees.add(employee1);

		// Add employee
		employees.add(employee2);

		// Using assertThat to evaluate specific matcher
		assertThat(employees,hasItems(employee1,employee2));
	}	

	@Test
	public void testhasEntry(){
		// Create Employee instance
		Employee employee1 = new Employee();

		employee1.setName("Mohammad");

		// Create a Map
		HashMap employees = new HashMap();

		// Add employee 1
		employees.put(employee1.getName(), employee1);

		// Assert
		assertThat(employees, hasEntry(employee1.getName(), employee1));
	}	

	@Test
	public void testhasProperty(){
		// Create Employee instance
		Employee employee = new Employee();

		// Assert
		assertThat(employee, hasProperty("name"));
	}	

	@Test
	public void testNotNull(){
		// Create Employee instance
		Employee employee = new Employee();

		// Assert
		assertThat(employee, notNullValue());
	}	

	@Test
	public void testSameInstance(){
		// Create employee
		Employee employee = new Employee();

		// Declare another employee variable
		Employee employee2 = employee;

		// Assert
		assertThat(employee, sameInstance(employee2));
	}

	@Test
	public void testInstanceOf(){
		// Create employee
		Employee employee = new Employee();

		// Assert
		assertThat(employee, instanceOf(Person.class));
	}	

	@Test
	public void testNotInstanceOf(){
		// Create employee
		Person person = new Person();

		// Assert
		assertThat(person, not(instanceOf(Employee.class)));
	}

	@Test
	public void testIsCompatibleType(){

		// Create isCompatible Matcher
		IsCompatibleType isPersonCompatible = new IsCompatibleType(Person.class);

		// Create isCompatible Matcher
		IsCompatibleType isEmployeeCompatible = new IsCompatibleType(Employee.class);

		// Assert; Employee class definition is compatible (instance) with/of Person
		assertThat(Employee.class,isPersonCompatible);

		// Assert; Person class definition is compatible (instance) with/of Person
		assertThat(Person.class,isPersonCompatible);

		// Assert; Person class definition is not compatible (instance) with/of Employee
		assertThat(Person.class,not(isEmployeeCompatible));
	}

	@Test
	public void testIsNotCompatibleType(){

		// Create isCompatible Matcher
		IsCompatibleType isNotCompatible = new IsCompatibleType(String.class);

		// Assert; employee class definition isn't compatible/instance with/of String
		assertThat(Employee.class,not(isNotCompatible));
	}

	@Test
	public void testAnyOf(){

		// Create isCompatible Matcher
		IsCompatibleType isPersonCompatible = new IsCompatibleType(Person.class);

		// Create isCompatible Matcher
		IsCompatibleType isEmployeeCompatible = new IsCompatibleType(Employee.class);

		// Assert; employee class is instance of Person OR employee
		assertThat(Employee.class,anyOf(isPersonCompatible,isEmployeeCompatible));
	}

	@Test
	public void testAllOf(){

		// Create isCompatible Matcher
		IsCompatibleType isPersonCompatible = new IsCompatibleType(Person.class);

		// Create isCompatible Matcher
		IsCompatibleType isEmployeeCompatible = new IsCompatibleType(Employee.class);

		// Assert; Person class is an instance of Person AND not of Employee
		assertThat(Person.class,allOf(isPersonCompatible,not(isEmployeeCompatible)));
	}					

}

class Person {

	private String type;

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

}

class Employee extends Person{

	private int id = 0;
	private String name = "Empty Name";

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

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

Теперь вы можете выполнить его, нажав CTRL + SHIFT + x + t, чтобы получить следующий результат:

Расширение JUnit – JWebUnit

JWebUnit-это платформа, созданная на основе JUnit, и она предоставляет способ написания тестовых примеров для целей тестирования веб-приложений. В следующем примере показано, как его можно использовать для написания тестовых примеров для самого простого Портлета Hello World , который был написан ранее в одном из этих учебных пособий, предоставленных для Портала Apache Pluto .

Использование портала Apache Pluto сделало бы написание обращений JWebUnit намного интереснее, так как вы должны пройти экран входа в систему и перейти на страницы своего портала, прежде чем проверять свой HelloWorldПортлет – Фактически ваш веб – ресурс.

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

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

package com.journaldev.portlet;

import java.io.IOException;

import javax.portlet.ActionRequest;
import javax.portlet.ActionResponse;
import javax.portlet.GenericPortlet;
import javax.portlet.PortletConfig;
import javax.portlet.PortletException;
import javax.portlet.RenderRequest;
import javax.portlet.RenderResponse;

public class HelloWorldPortlet extends GenericPortlet {
	private static int renderCount = 0;
	private static int actionCount = 0;

	public void doView(RenderRequest request, RenderResponse response)
			throws PortletException, IOException {

		synchronized(this){
			renderCount++;
		}
		response.getWriter().print("
"
				+ "
Render has executed "+renderCount+"
"
				+ "
Action has executed "+actionCount+"
"
				+ "Submit"
				+ "
");
	}

	public void processAction(ActionRequest actionRequest, ActionResponse actionResponse){
		synchronized(this){
			actionCount++;
		}
	}

    public void init( PortletConfig config ) throws PortletException {
        super.init( config );
    }
}

Ниже приведены подсказки для компонента, написанного выше:

• Портлет Hello World – это простой ресурс портлета, который отвечает за отображение простой формы с возможностью отправки на нее.
• Доступ к странице портала HelloWorldPortlet увеличит счетчик рендеринга на единицу.
• Кнопка отправки действия против helloworldпортлета увеличит запрос на действие на единицу.

Следующая ниже серия изображений прояснит выполнение портлета Hello World и бизнес-сценарии, которые вы должны изучить с помощью JWebUnit.

• Доступ к базовому URL-адресу портала Apache Pluto https://10.10.90.3:8080/pluto .

• Убедитесь, что вы изменили tomcat-users.xml чтобы пользователю tomcat был разрешен доступ и управление.
• Введите tomcat в качестве имени пользователя и пароля и отправьте логин.
• Перейдите на домашнюю страницу Apache Pluto.

Портлет не является автономным веб-ресурсом, поэтому, чтобы сделать его доступным, вы должны встроить его в страницу Портала. Мы создали страницу портала HelloWorld, и вы можете сделать это, следуя основным инструкциям в приведенном выше руководстве по Apache Pluto.

• Создайте страницу портала Hello World и добавьте в нее Портлет Hello World .

• Первоначально по каждому запросу на странице портала HelloWorld портлет Hello World будет отображаться еще один. В случае, если у вас есть копия ссылки https://10.10.90.3:8080/pluto/portal/HelloWorld еще раз и введите его на другой вкладке в том же браузере, вы увидите Рендеринг выполнил 2 и так далее.
• Запрос на действие-это второй тип запроса, поддерживаемый портлетом. Портлет имеет два различных типа запросов в своем жизненном цикле.
• Чтобы убедиться, что вы получаете запрос на действие, вам следует нажать кнопку Отправить. Это также инициировало бы другой запрос на рендеринг, так что вы должны увидеть, что Рендеринг выполнил 2, а действие выполнил 1.

Теперь вы видели, как HelloWorldПортлет работает против ваших действий, которые вы на нем совершили. Но что делать, если вы не хотите обрабатывать это непосредственно в браузере и хотите выполнить это с помощью JWebUnit.

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

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

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

package com.journaldev;

import net.sourceforge.jwebunit.junit.JWebUnit;

import org.junit.Before;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

@FixMethodOrder(MethodSorters.JVM)
public class HelloWorldPortletTestCase {

	@Before
	public void prepareBaseURL(){
		// Set base URL that JWebUnit will start from
		JWebUnit.setBaseUrl("https://10.10.90.3:8080/pluto");
	} 

	@Test
	public void testBaseUrl(){
		// Begin a conversation
		JWebUnit.beginAt("/portal");
	}

	@Test
	public void testShowingAndPopulatingLoginScreen(){

		// Assert if login screen is displayed, so that username and password field would be shown

		JWebUnit.assertTextFieldEquals("j_username", "");
		JWebUnit.assertTextFieldEquals("j_password", "");		

		// Populating login screen with the required values
		JWebUnit.setTextField("j_username", "tomcat");
		JWebUnit.setTextField("j_password", "tomcat");

		// Assert populating is done properly
		JWebUnit.assertTextFieldEquals("j_username", "tomcat");
		JWebUnit.assertTextFieldEquals("j_password", "tomcat");

		// Login Into Portal
		JWebUnit.clickButtonWithText("Login");
	}

	@Test
	public void testNavigateIntoHelloWorldPortalPage(){
		// Check if HelloWorld Portal page is exist or not
		JWebUnit.assertLinkPresentWithText("HelloWorld");
	}

	@Test
	public void testDoActualNavigationIntoHelloWorldPortalPage(){
		// Navigate into HelloWorld Portal page
		JWebUnit.clickLinkWithExactText("HelloWorld");

		// Check of the Render has executed message
		JWebUnit.assertTextPresent("Render has executed 1");
	}	

	@Test
	public void testInitiateActionRequestUponHelloWorldPortlet(){
		// Check if the submit button is exist
		JWebUnit.assertButtonPresent("submit");

		// Click submit against HelloWorld Portlet
		JWebUnit.clickButton("submit");
	}

	@Test
	public void testMessagesAfterActionRequestUponHelloWorldPortlet(){
		// Check of the Render has executed message
		JWebUnit.assertTextPresent("Render has executed 2");

		// Check of the Action has executed message
		JWebUnit.assertTextPresent("Action has executed 1");
	}
}

Вот подробная информация о коде, указанном выше:

• Я разбил вышеприведенный вариант функционального использования на несколько тестовых случаев.
• Эти тестовые примеры не будут выполняться последовательно, если вы не использовали @FixMethodOrder(MethodSorters.JVM) . Как и JUnit, предположим, что каждый @тестовый случай настолько зависит от другого, хотя на самом деле их нет, по крайней мере, в нашем примере.
• Каждый функциональный случай был рассмотрен, в то время как обычная навигация в браузере написана в приведенном выше примере в качестве тестового случая. Найдите базовую страницу, начните разговор, Отобразите и заполните экран входа в систему, проверьте наличие страницы HelloWorld Портала, перейдите на нее, проверьте результат навигации, инициируйте запрос на действие, проверьте, правильно ли инициирован запрос на действие.
• @Fixmethod был выпущен после выпуска JUnit 4.11, поэтому будьте осторожны при выполнении одного и того же приложения с использованием другого выпуска JUnit, а не того, который упоминается в файле pom или в одном из последующих.

Ниже приведен результат выполнения вышеуказанных тестовых примеров; в случае, если у вас нет этого правильного результата, вы можете использовать JWebUnit.getPageSource () , который будет использовать возвращенный HTML.

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

На самом деле использовать JWebUnit против любого веб-ресурса, такого как сервлет, JSP, HTML и любого ресурса, который привел к ответу HTML, было бы намного проще, чем использовать его против веб-приложения портала Apache. Чтобы убедиться, что у нас было большинство случаев, которые следует охватить, данный образец был на портале Apache Pluto.

Расширение JUnit – JSFUnit

В случае, если вы можете найти в Интернете JSFUnit для JBoss, но на самом деле это не простая структура, и вам нужна некоторая осведомленность о ее сути, чтобы она использовалась добровольно.

Говоря о JSF, это означает, что у вас есть контейнер сервлетов, который обслуживает ваше приложение. И есть много компонентов, которые необходимо изучить; Управляемые компоненты, идентификаторы представлений, оценка выражений и многие другие. Все эти компоненты не являются простыми классами Java, и поэтому им нужно иметь доступ к ним и легко указывать свои значения.

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

Arquillian-это массивный фреймворк, который можно использовать для написания реальных тестовых случаев, соответствующих концепции Тестирование в контейнере для Java Enterprise Edition.

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

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

Приведенный выше образец немного изменен с помощью faces-config.xml файл, а не использование аннотаций JSF. Это сделано таким образом, чтобы убедиться, что концепция Микро-развертывания настолько ясна и подходит для тех, кто использует JSF 1.x.

Прежде чем приступить к объяснению полного примера того, как можно использовать Арквиллиан для выполнения этой миссии, давайте сначала рассмотрим те активы, которыми должен обладать ваш тестовый случай Арквиллиана:

• @RunWith, который будет относиться к Arquillian Test Runner.
• Общедоступный статический метод с аннотацией @Deployment.
• По крайней мере, один метод с аннотацией @Test.

Примите во внимание также:

• Используя последнюю версию интеграции Arquillian JSFUnit.
  • Arquillian JSFUnit 2.0.0.Бета2
  • API термоусадочной пленки 1.2.2
• Использование Tomcat 7.
• Использование JDK 1.6.

Прежде всего, давайте быстро рассмотрим каждый компонент, который использовал Arquillian framework:

• @Deployment : является обязательным методом для тестов, которые выполняются внутри контейнера для создания развертывания архива (Микро-развертывания); Архива Java (JAR), Веб-архива (WAR) и Корпоративного архива (EAR). Это развертывание архива было подготовлено с помощью термоусадочной пленки.

Термоусадочная пленка – это Java API для создания архивов (jar, war и ear) на Java. Используя термоусадочную пленку, вы фокусируетесь на своих Тестовых примерах , принося все необходимые библиотеки вместо того, чтобы приносить их все. Как вы можете видеть ниже в примере, нет необходимости включать все библиотеки в свой архив.

• @RunWith : обсуждается ранее, так как он используется для обозначения другого тестового бегуна, который будет использоваться. С помощью Arquillian framework вы должны аннотировать свои тестовые случаи, используя его, чтобы убедиться, что он выполняется правильно.

Если вы вернетесь к упомянутому образцу, вы увидите, что это очень простое приложение JSF, поскольку оно содержит:

• Простой веб-ресурс hello World.xhtml.
• Просто faces-config.xml это содержит один определенный управляемый компонент.
• Простой веб-XML-файл.
• Простой управляемый компонент, содержащий один атрибут с именем s1 .
• Реализация JSF и библиотеки API.
• Библиотека JSTL.

Здесь будет использоваться тот же образец, за исключением, как мы упоминали, использования faces-config.xml скорее, используя его аннотации.

Теперь посмотрите ниже на тестовый класс Arquillian, за которым следуют необходимые библиотеки в вашем файле pom:

Теперь посмотрите ниже на тестовый класс Arquillian, за которым следуют необходимые библиотеки в вашем файле pom:

package com.journaldev;

import java.io.File;
import java.io.IOException;

import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.jsfunit.api.InitialPage;
import org.jboss.jsfunit.jsfsession.JSFClientSession;
import org.jboss.jsfunit.jsfsession.JSFServerSession;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(Arquillian.class)
public class ArquillianHelloWorldTestCase {

	@Deployment
	public static WebArchive createDeployment() {

		// Create a WAR (Micro deployment) with a given name called
		// helloworld.war
		WebArchive webArchive = ShrinkWrap.create(WebArchive.class,
				"helloworld.war");

		// Set web.xml inside created micro WAR
		webArchive.setWebXML(new File("src/main/webapp/WEB-INF/web.xml"));

		// Add classes
		webArchive.addPackage("com.journaldev.jsf.helloworld");

		// Add web resource
		webArchive.addAsWebResource(new File("src/main/webapp","helloWorld.xhtml"));

		// Add faces-config.xml as a web-inf resource
		webArchive.addAsWebInfResource(new File("src/main/webapp/WEB-INF/faces-config.xml"),"faces-config.xml");

		// Add required libraries
		webArchive.addAsLibrary(new File("C:/Users/mohammad.amr/.m2/repository/com/sun/faces/jsf-impl/2.1.13/jsf-impl-2.1.13.jar"));
		webArchive.addAsLibrary(new File("C:/Users/mohammad.amr/.m2/repository/com/sun/faces/jsf-api/2.1.13/jsf-api-2.1.13.jar"));
		webArchive.addAsLibrary(new File("C:/Users/mohammad.amr/.m2/repository/jstl/jstl/1.2/jstl-1.2.jar"));

		// return the deployment
		return webArchive;
	}

	@Test
	@InitialPage("/faces/helloWorld.xhtml")
	public void testInitialPage(JSFServerSession server, JSFClientSession client)
			throws IOException {

		// Test navigation to initial viewID
		Assert.assertEquals("/helloWorld.xhtml", server.getCurrentViewID());

	}

	@Test
	@InitialPage("/faces/helloWorld.xhtml")
	public void testHelloWorldBeanNotNull(JSFServerSession server, JSFClientSession client){

		// Test if Managed Bean is null
		Assert.assertNotNull(server.getFacesContext().getExternalContext().getSessionMap().get("helloWorld"));
	}

	@Test
	@InitialPage("/faces/helloWorld.xhtml")
	public void testS1Value(JSFServerSession server, JSFClientSession client){

		// Test if Managed Bean is null
		Assert.assertEquals("Hello World!!",server.getManagedBeanValue("#{helloWorld.s1}"));
	}
}

Теперь посмотрите ниже на тестовый класс Arquillian, за которым следуют необходимые библиотеки в вашем файле pom:

	4.0.0
	com.journaldev
	HelloWorldTestCase
	0.0.1-SNAPSHOT
	HelloWorldTestCase
	https://maven.apache.org
	
		maven-surefire-plugin
		2.17
	
	
		UTF-8
	
	
		
		
			net.sourceforge.htmlunit
			htmlunit
			2.8
		
		
		
			junit
			junit
			4.12
		
		
		
			org.hamcrest
			hamcrest-core
			1.3
		
		
		
			net.sourceforge.jwebunit
			jwebunit-htmlunit-plugin
			3.0
		
		
		
			org.jboss.arquillian.junit
			arquillian-junit-container
			1.1.8.Final
		
		
		
			org.jboss.arquillian.container
			arquillian-tomcat-remote-7
			1.0.0.CR7
		
		
		
			com.sun.faces
			jsf-api
			2.1.13
		
		
			com.sun.faces
			jsf-impl
			2.1.13
		
		
		
			javax.servlet
			servlet-api
			2.5
			provided
		
		
		
			jstl
			jstl
			1.2
		
		
		
			org.jboss.jsfunit
			jsfunit-arquillian
			2.0.0.Beta2
		
		
		
			org.jboss.jsfunit
			jboss-jsfunit-core
			2.0.0.Beta2
		
		
		
			org.jboss.shrinkwrap
			shrinkwrap-api
			1.2.2
		
		
			org.jboss.shrinkwrap.resolver
			shrinkwrap-resolver-api
			2.2.0-beta-2
		
		
			org.jboss.shrinkwrap.resolver
			shrinkwrap-resolver-impl-maven
			2.2.0-beta-2
		
		
			org.jboss.shrinkwrap.descriptors
			shrinkwrap-descriptors-api
			1.0.0-beta-1
		
		
			org.jboss.shrinkwrap.descriptors
			shrinkwrap-descriptors-impl
			1.0.0-beta-1
		
	

Вот подробное объяснение кода, перечисленного выше:

• Вы создали один тестовый класс под названием ArquillianHelloWorldTestCase.java .
• Этот класс содержит один обязательный метод @Deployment , поскольку для его тестовых случаев требуется контейнер (контейнер сервлета).
• @Deployment метод вернул веб-архив.
• Возвращенный веб-архив содержал один веб-XML-ресурс, один пакет, один веб-ресурс, один faces-config.xml и три необходимые библиотеки; реализация JSF и JSTL. Эти ресурсы были упомянуты явно, чтобы веб-архив содержал их соответствующим образом, как только @Deployment завершит выполнение.
• Если вы не привязали имя для своего веб-архива, то он будет случайным образом привязан к заданному имени реализацией ShrinkWrap . Имя развертывания helloworld.war .
• @Deployment будет взаимодействовать с вашим (под управлением Tomcat 7), чтобы развертывание было установлено там как helloworld.war .
• Как только развертывание будет успешно опубликовано, начнется выполнение тестовых случаев.
• Все методы тестовых случаев упоминали два параметра; JSFServerSession и JSFClientSession , которые автоматически вводятся Arquillian framework.
• Все методы тестовых случаев предполагают, что начальная страница, которая будет запрошена, и на ней выполняется тестовый случай, – это /faces/HelloWorld.xhtml , который использует реализацию facelets для визуализации компонента пользовательского интерфейса.
• Передача утверждений внутри этих методов будет отмечать их прохождение зеленым светом. В противном случае сбой и его сообщение были бы там.
• TestInitialPage проверит, имеет ли отображаемое представление JSF идентификатор/HelloWorld.xhtml в качестве идентификатора представления.
• Тестовый компонент HelloWorld Not Null проверит, вводится ли компонент HelloWorld фреймворком JSF или нет.
• Тесты 1 Значение будет проверять, равно ли значение атрибута s1 Hello World!! или нет.

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

• Ваш Tomcat 7 запущен и работает.
• Ваши исходные пути или ресурсы (src/main/ресурсы) упоминали конфигурацию контейнера Arquillian arquillian.xml который будет использовать JMX для подключения вашего кота.

Ваши исходные пути или ресурсы (src/main/ресурсы) упоминали конфигурацию контейнера Arquillian || arquillian.xml || который будет использовать JMX для подключения вашего кота.

    
        
            tomcat
            tomcat
        
    

• Убедитесь, что ваша конфигурация Tomcat разрешила соединение JMX с вашим Tomcat. Это можно сделать, добавив нижеприведенную строку в переменную JAVA_OPTS в вашей catalina.bat

Новые JAVA_OPTS

set JAVA_OPTS=%JAVA_OPTS% %LOGGING_CONFIG% -Dcom.sun.management.jmxremote.port=8089 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false

• Разрешить пользователю Tomcat иметь роль диспетчера-скрипта, которая будет использоваться для выполнения команды развертывания.

Разрешить пользователю Tomcat иметь роль диспетчера-скрипта, которая будет использоваться для выполнения команды развертывания.

Если вы выполните этот пример, вызвав CTRL + SHIFT + x + t, вы увидите:

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

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

Иногда это удаление было небезопасным, поэтому развернутая папка вашего развертывания все еще находится там, пока ВОЙНА удалена. Там вам нужно остановить своего кота и удалить его самостоятельно или убедиться, что вы используете context.xml с защитой от блокировки.

Maven и JUnit

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

Используя mvn-тест , вы используете инструмент Maven для выполнения тестовых случаев, которые находятся под вашим src/тестом/java .

Для этой цели я скопировал все созданные тестовые случаи выше и добился некоторых незначительных изменений, которые позволили бы эффективно запускать эти тестовые случаи во время работы Maven. Эти небольшие изменения были:

• Добавьте плагин maven-surefire-report - , который будет использоваться для отчетности обо всех результатах выполнения ваших тестовых случаев.
• Увеличить время ожидания в HelloWorldTestCase.java .
• Изменение test NullPointerException Должно быть вызвано внутри одного и того же вышеприведенного класса, чтобы вызывать его каждый раз, когда этот метод вызывается с помощью.
• Создайте новый пакет в src/test/java и скопируйте в него все тестовые классы.

Структура приложения будет выглядеть следующим образом:

Из-за различных тестовых случаев, которые у нас есть, и того, что оба сервера Apache 7 и Apache Pluto были использованы, и они должны быть запущены и запущены, чтобы эти тестовые случаи выполнялись должным образом; я изменил порты Tomcat из самого Eclipse для Apache 7.

После выполнения mvn-теста вы должны увидеть, что ваши тестовые примеры были написаны, и результат будет показан как на консоли, так и в вашей целевой папке target/surefire-reports .

Перед выполнением тестовых наборов убедитесь, что у вас установлены и запущены Apache Pluto и Apache Tomcat 7, чтобы тестовые наборы Arquillian и портлетов выполнялись должным образом.

Результатом выполнения, который вы получите, будет:

Как вы можете заметить, Maven выполнил свою фазу тестирования и успешно выполнил все тестовые случаи, определенные в src/test/java .

Это не тот способ, с помощью которого вы можете точно знать, что происходит с вашим тестовым случаем. Помимо сообщений консоли, у вас также есть возможность получить доступ к папке target/surefire-reports , которая будет содержать набор файлов, отображающих результаты выполнения, полученные в ваших тестовых случаях.

Давайте посмотрим на результат выполнения тестового случая Арквиллиана:

Резюме

Платформа JUnit-это платформа с открытым исходным кодом, которая используется для выполнения набора тестовых случаев. В то время как этап тестирования принимает различные формы: Приемочный тест, Интеграционный тест, Функциональный тест и Модульный тест; наиболее важным из них является модульный тест, который будет проверять ваши компоненты индивидуально, чтобы убедиться, что они работают должным образом.

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

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

В соответствии с различными формами технологий и компонентов, которые были предоставлены в наши дни, так важно использовать надежные инструменты и API для тестирования этих компонентов. Наличие JUnit, JWebUnit, подразделения JSF и многого другого поможет вам выполнить эту миссию.

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