BattleCaseкомпьютерная помощь

Тест знаний Java, Основы. Тест для Java-программистов, или Не слишком ли я строг к претендентам?

- библиотека для модульного тестирования программ Java. Созданный Кентом Беком и Эриком Гаммой,

Тест знаний Java, Основы. Тест для Java-программистов, или Не слишком ли я строг к претендентам?
Содержание
  1. Необходимость использования JUnit
  2. Виды тестирования и место JUnit тестирования в классификации
  3. JUnit 3
  4. Дополнительные возможности, TestSuite
  5. JUnit 4
  6. Правила тастирования, JUnit Rule
  7. Наборы тестов, JUnit Suite, SuiteClasses
  8. Порядок выполнения тестов
  9. Список основных аннотаций
  10. Список типов проверок Asserts
  11. Пример JUnit тестирования
  12. Целевая аудитория теста по Java
  13. Предварительные требования к тесту Java
  14. Структура теста по Java
  15. Дальнейшее развитие теста по Java
  16. Заглянем в мой ящик с инструментами

JUnit

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

Кента Бека для Smalltalk. JUnit породил экосистему расширений - JMock, EasyMock, DbUnit, HttpUnit и т. Д.

Библиотека JUnit

Была портирована на другие языки, включая PHP (PHPUnit), C# (NUnit), Python (PyUnit),

Fortran (fUnit), Delphi (DUnit), Free Pascal (FPCUnit), Perl (Test::Unit), C++ (CPPUnit), Flex (FlexUnit),

JavaScript (JSUnit).

JUnit

- это Java фреймворк для тестирования, т. Е. Тестирования отдельных участков кода, например,

Методов или классов. Опыт, полученный при работе с JUnit, важен в разработке концепций тестирования

Программного обеспечения.

Пример теста JUnit

Import org.junit.Test;

import junit.framework.Assert;

public class MathTest {

@Test

public void testEquals() {

Assert.assertEquals(4, 2 + 2);

Assert.assertTrue(4 == 2 + 2);

@Test

public void testNotEquals() {

Assert.assertFalse(5 == 2 + 2);

Необходимость использования JUnit

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

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

Процесс лучше автоматизировать. Использование JUnit

Позволяет проверить код программы без значительных усилий и не

Занимает много времени.

Юнит тесты

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

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

Это удобно, и часто тесты разрабатывают как вместе, так и до реализации классов. Разработка через тестирование - крайне

Популярная технология создания серьезного программного обеспечения.

Виды тестирования и место JUnit тестирования в классификации

Тестирование программного обеспечение можно разделить на два вида:

  • Тестирование черного ящика;
  • Тестирование белого ящика.

Во время тестирования программы как черного ящика внутренняя структура приложения в расчет не принимается. Все, что имеет значение, это функциональность,

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

Кроме этого, тестирование можно разделить на четыре уровня:

  • Юнит тесты - тестирование отдельных участков кода;
  • Интеграционное тестирование - тестирование взаимодействия и совместной работы компонентов;
  • Системное тестирование - тестирование всей системы как целого;
  • Приемное тестирование - итоговое тестирование готовой системы на соответствие требованиям.

Юнит тестирование по определению является тестированием белого ящика.

Используется unit тестирование в двух вариантах - JUnit 3 и JUnit 4. Рассмотрим обе версии, так как в старых проектах до сих пор используется 3-я версия,

Которая поддерживает Java 1.4.

JUnit 3

Для создания теста следует наследовать тест-класс TestCase, переопределить методы setUp и tearDown при необходимости, ну и самое главное - разработать

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

В классе отдельный экземпляр класса), затем выполняется метод setUp, запускается сам тест, ну и в завершение выполняется метод tearDown. Если какой-либо

Из методов вызывает исключение, тест считается провалившимся.

Примечание: тестовые методы должны быть public void, могут быть static.

Тесты состоят из выполнения некоторого кода и проверок. Проверки чаще всего выполняются с помощью класса Assert

Хотя иногда используют ключевое

Слово assert.

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

В виде 16-ричной строки:

Public class JUnit3StringUtilsTest extends TestCase {

private final Map toHexStringData = new HashMap();

protected void setUp() throws Exception {

toHexStringData.put("", new byte);

toHexStringData.put("01020d112d7f", new byte{1,2,13,17,45,127});

toHexStringData.put("00fff21180" , new byte{0,-1,-14,17,-128 });

//

protected void tearDown() throws Exception {

toHexStringData.clear();

public void testToHexString() {

for (Iterator iterator = toHexStringData.keySet().iterator();

iterator.hasNext();)

final String expected = (String)iterator.next();

final byte testData = (byte)toHexStringData.get(expected);

final String actual = StringUtils.toHexString(testData);

assertEquals(expected, actual);

//

Дополнительные возможности, TestSuite

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

Public class JUnit3StringUtilsTestSuite extends TestSuite {

public JUnit3StringUtilsTestSuite() {

addTestSuite(StringUtilsJUnit3Test.class);

addTestSuite(OtherTest1.class);

addTestSuite(OtherTest2.class);

Можно исполнение теста повторить несколько раз. Для этого используется RepeatedTest:

Public class JUnit3StringUtilsRepeatedTest extends RepeatedTest {

public JUnit3StringUtilsRepeatedTest() {

super(new JUnit3StringUtilsTest(), 100);

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

Public class JUnit3StringUtilsExceptionTest extends ExceptionTestCase {

public JUnit3StringUtilsExceptionTest(final String name) {

super(name, NullPointerException.class);

public void testToHexString() {

StringUtils.toHexString(null);

Как видно из примеров все довольно просто и ничего лишнего - минимум кода для JUnit тестирования.

JUnit 4

В JUnit 4 добавлена поддержка новых возможностей из Java 5.0; тесты могут быть объявлены с помощью аннотаций.

При этом существует обратная совместимость с предыдущей версией фреймворка. Практически все рассмотренные выше примеры будут работать и

В JUnit 4 за исключением RepeatedTest, который отсутствует в новой версии.

Какие внесены изменения появились в JUnit 4? Рассмотрим тот же пример, но уже с использованием новых возможностей:

Public class JUnit4StringUtilsTest extends Assert {

private final Map<String, byte> toHexStringData =

new HashMap<String, byte>();

@Before

public static void setUpToHexStringData() {

toHexStringData.put("", new byte);

toHexStringData.put("01020d112d7f", new byte{1,2,13,17,45,127});

toHexStringData.put("00fff21180" , new byte{0,-1,-14,17,-128});

//

@After

public static void tearDownToHexStringData() {

toHexStringData.clear();

@Test

public void testToHexString() {

for (Map.Entry<String, byte>

entry: toHexStringData.entrySet())

final byte testData = entry.getValue();

final String expected = entry.getKey();

final String actual = StringUtils.toHexString(testData);

assertEquals(expected, actual);

Что изменилось в JUnit 4 ?

  • Для упрощения работы можно наследоваться от класса Assert , хотя это необязательно.
  • Аннотация @Before обозначает методы, которые будут вызваны перед исполнением тестов. Методы должны быть public void . Здесь обычно размещаются предустановки для теста, в нашем случае это генерация тестовых данных (метод setUpToHexStringData ).
  • Можно использовать аннотацию @BeforeClass , которая обозначает методы, которые будут вызваны до создания экземпляра тест-класса; методы должны быть public static void . Данную аннотацию (метод) имеет смысл использовать для тестирования в случае, когда класс содержит несколько тестов, использующих различные предустановки, либо когда несколько тестов используют одни и те же данные, чтобы не тратить время на их создание для каждого теста.
  • Аннотация @After обозначает методы, которые будут вызваны после выполнения тестов. Методы должны быть public void . Здесь размещаются операции освобождения ресурсов после теста; в нашем случае - очистка тестовых данных (метод tearDownToHexStringData ).
  • Аннотация @AfterClass связана по смыслу с @BeforeClass , но выполняет методы после тестирования класса. Как и в случае с @BeforeClass , методы должны быть public static void .
  • Аннотация @Test обозначает тестовые методы. Как и ранее, эти методы должны быть public void . Здесь размещаются сами проверки. Кроме того, в данной аннотации можно использовать два параметра, expected - задает ожидаемое исключение и timeout - задает время, по истечению которого тест считается провалившимся.

Примеры использования аннотаций с параметрами, JUnit Test

@Test(expected = NullPointerException.class)

public void testToHexStringWrong() {

StringUtils.toHexString(null);

@Test(timeout = 1000)

public void infinity() {

while (true);

Игнорирование выполнения теста, JUnit Ignore

Если один из тестов по какой-либо серьезной причине необходимо отключить, например, тест постоянно завершается с ошибкой. Исправление теста можно

Отложить до светлого будущего аннотированием @Ignore

. Если поместить эту аннотацию на класс, то все тесты в этом классе будут отключены.

@Ignore

@Test(timeout = 1000)

public void infinity() {

while (true);

Правила тастирования, JUnit Rule

JUnit

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

Есть встроенные правила для задания таймаута для теста (Timeout), для задания ожидаемых исключений (ExpectedException), для работы с временными

Файлами(TemporaryFolder) и др.

Для объявления правила необходимо создать public

Не static

Поле типа производного от MethodRule и аннотировать его

С помощью ключевого слова Rule

Public class JUnitOtherTest

@Rule

public final TemporaryFolder folder = new TemporaryFolder();

@Rule

public final Timeout timeout = new Timeout(1000);

@Rule

public final ExpectedException thrown = ExpectedException.none();

@Ignore

@Test

public void anotherInfinity() {

while (true);

@Test

public void testFileWriting() throws IOException

final File log = folder.newFile("debug.log");

final FileWriter logWriter = new FileWriter(log);

logWriter.append("Hello, ");

logWriter.append("World!!!");

logWriter.flush();

logWriter.close();

@Test

public void testExpectedException() throws IOException

thrown.expect(NullPointerException.class);

StringUtils.toHexString(null);

Наборы тестов, JUnit Suite, SuiteClasses

Запуск теста может быть сконфигурирован с помощью аннотации @RunWith

. Тестовые классы, которые содержат в себе тестовые методы,

Можно объединить в наборы тестов (Suite). Например, создано два класса тестирования объектов: TestFilter, TestConnect. Эти два тестовых класса

Можно объединить в один тестовый класс TestWidgets.java:

Package com.objects;

import org.junit.runner.RunWith;

import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses ({

TestFilter.class,

TestConnect.class

public class TestWidgets {}

Для настройки запускаемых тестов используется аннотация @SuiteClasses, в которую включены тестовые классы.

Аннотация Categories

Аннотация Categories

Позволяет объединить тесты в категории (группы). Для этого в тесте определяется категория @Category

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

Public class JUnitStringUtilsCategoriesTest extends Assert

//

@Category (Unit.class)

@Test

public void testIsEmpty() {

//

//

@RunWith (Categories.class)

@Categories.IncludeCategory (Unit.class)

@Suite.SuiteClasses ({

JUnitOtherTest.class,

JUnitStringUtilsCategoriesTest.class

public class JUnitTestSuite {}

Аннотация, JUnit Parameterized

Аннотация Parameterized

Позволяет использовать параметризированные тесты. Для этого в тест-классе объявляется статический метод,

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

@RunWith (Parameterized.class)

public class JUnitStringUtilsParameterizedTest extends Assert

private final CharSequence testData;

private final boolean expected;

public JUnitStringUtilsParameterizedTest(final CharSequence testData,

final boolean expected)

this.testData = testData;

this.expected = expected;

@Test

public void testIsEmpty () {

final boolean actual = StringUtils.isEmpty (testData);

assertEquals(expected, actual);

@Parameterized.Parameters

public static List<Object> isEmptyData() {

return Arrays.asList(new Object {

{ null, true },

{ "", true },

{ " ", false },

{ "some string", false },

Параметризирование метода: Theories.class, DataPoints, DataPoint, Theory

Аннотация Theories

Параметризирует тестовый метод, а не конструктор. Данные помечаются с помощью @DataPoints

И @DataPoint

Тестовый метод - с помощью @Theory

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

@RunWith (Theories.class)

public class JUnitStringUtilsTheoryTest extends Assert

@DataPoints

public static Object isEmptyData = new Object {

{ "", true },

{ " ", false },

{ "some string", false },

@DataPoint

public static Object nullData = new Object { null, true };

@Theory

public void testEmpty(final Object... testData)

final boolean actual =

StringUtils.isEmpty ((CharSequence) testData);

assertEquals(testData, actual);

Порядок выполнения тестов

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

@FixMethodOrder(MethodSorters.NAME_ASCENDING), определенной в JUnit 4.11. Например:

@FixMethodOrder(MethodSorters.NAME_ASCENDING)

public class MyTest {

@Test

public void test01(){...}

@Test

public void test02(){...}

@Test

public void test09(){...}

В противном случае можно использовать следующие 2 подхода.

Void test01();

void test02();

void test09();

@Test

public void testOrder1() { test1(); test3(); }

@Test(expected = Exception.class)

public void testOrder2() { test2(); test3(); test1(); }

@Test(expected = NullPointerException.class)

public void testOrder3() { test3(); test1(); test2(); }

@Test

public void testAllOrders() {

for (Object sample: permute(1, 2, 3)) {

for (Object index: sample) {

switch (((Integer) index).intValue()) {

case 1: test1(); break;

case 2: test2(); break;

case 3: test3(); break;

Список основных аннотаций

АннотацияОписание
@Test public void testMethod()метод является тестовым
@Test(timeout=100) public void testMethod()если время выполнения превысит параметр timeout, то тест будет завершен неудачно
@Test (expected = MyException.class) public void testMethod()метод должен выбросить исключение принадлежащие к классу MyException, в противном случае тест будет завершен неудачно
@Ignore public void testMethod()игнорировать тестовый метод
@BeforeClassметод вызывающийся один раз для класса перед выполнением тестовых методов; здесь можно разместить инициализацию которую нужно выполнять только один раз, например, прочитать данные, которые будут использоваться в тестовых методах или создать соединение с базой данных
@AfterClass public static void testMethod()метод вызывающийся один раз для класса после выполнения тестовых методов; здесь можно разместить деинициализацию которую нужно выполнять только один раз, например, закрыть соединение с базой данных или удалить данные, которые больше не нужны
@Before public static void beforeMethod()метод, вызывающийся перед каждым тестовым методом в тестовом классе; здесь можно выполнить необходимую инициализацию, например, выставить начальные параметры
@After public static void afterMethod()метод, вызывающийся после каждого тестового метода в тестовом классе; здесь можно выполнить необходимую деинициализацию, например, удалить данные, которые больше не нужны

Список типов проверок Asserts

Тип проверкиОписание
fail() fail(String message)прерывание теста с ошибкой, т.е. Тест будет неудачным
assertTrue(boolean condition) assertTrue(java.lang.String message, boolean condition)проверка на равенство условия condition значению true
assertFalse(boolean condition) assertFalse(String message, boolean condition)проверка на равенство условия condition значению false
assertEquals(<тип> expected, <тип> actual) assertEquals(String message, <тип> expected, <тип> actual)проверка на равенство; <тип> - это Object, int, double и т.д.
assertArrayEquals(byte expecteds, byte actuals) assertArrayEquals(String message, <тип> expecteds, <тип> actuals)проверка массивов на равенство; аналогично assertEquals; <тип> - это Object, int, double и т.д.
assertNotNull(Object object) assertNotNull(String message, Object object)проверка, что Object не null
assertNull(Object object) assertNull(String message, Object object)проверка, что Object null
assertSame(Object expected, Object actual) assertSame(String message, Object expected, Object actual)проверка на равенство двух объектов expected и actual, т.е. Один и тот же объект

Пример JUnit тестирования

Для демонстрации основных возможностей JUnit, используем примитивный java класс FuncMath, который имеет два метода - нахождение факториала

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

Public class FuncMath

int calls;

public int getCalls() {

return calls;

public long factorial(int number) {

calls++;

if (number < 0)

throw new IllegalArgumentException();

long result = 1;

if (number > 1) {

for (int i = 1; i < = number; i++)

result = result * i;

return result;

public long plus(int num1, int num2) {

calls++;

return num1 + num2;

Иногда для выполнения каждого тестового сценария необходим некоторый контекст, например, заранее созданные экземпляры классов.

А после выполнения нужно освободить зарезервированные ресурсы. В этом случае используют аннтоации @Before и @After. Метод,

Помеченный @Before будет выполняться перед каждым тестовым случаем, а метод, помеченный @After - после каждого тестового случая.

Если же инициализацию и освобождение ресурсов нужно сделать всего один раз - соответственно до и после всех тестов - то

Используют пару аннотаций @BeforeClass и @AfterClass.

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

Import org.junit.Test;

import org.junit.After;

import org.junit.Before;

import org.junit.Assert;

import org.junit.AfterClass;

import org.junit.BeforeClass;

public class JUnit_funcMath extends Assert

private FuncMath math;

@Before

public void init() {

math = new FuncMath();

@After

public void tearDown() {

math = null;

@Test

public void calls() {

assertEquals("math.getCalls() != 0", 0, dao.getConnection());

math.factorial(1);

assertEquals(1, math.getCalls());

math.factorial(1);

assertEquals(2, math.getCalls());

@Test

public void factorial() {

assertTrue(math.factorial(0) == 1);

assertTrue(math.factorial(1) == 1);

assertTrue(math.factorial(5) == 120);

@Test(expected = IllegalArgumentException.class)

public void factorialNegative() {

math.factorial(-1);

@Ignore

@Test

public void todo() {

assertTrue(math.plus(1, 1) == 3);

Метод calls тестирует правильность счетчика вызовов. Метод factorial проверяет правильность вычисления факториала

Для некоторых стандартных значений. Метод factorialNegative проверяет, что для отрицательных значений факотриала

Будет брошен IllegalArgumentException. Метод todo будет проигнорирован.

В статье представлены не все возможности использования JUnit. Но как видно из приведенных примеров,

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

Java - объектно-ориентированный строготипизированный язык программирования, разработанный компанией Sun Microsystems в 1991 году. Изначально язык назывался Oak и предназначался для программирования бытовой электроники, однако позже был переименован в Java. Официальный выпуск Java в 1995 году оказался очень успешным и вскоре после этого язык Java занял сильные позиции в качестве инструмента разработки серверных приложений.

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

Целевая аудитория теста по Java

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

Предварительные требования к тесту Java

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

Структура теста по Java

Тест "Java - Основы" освещает следующие темы:

Подробнее о тематиках вопросов теста можно прочесть ниже:

  • Объекты и классы: вопросы этой тематики покрывают такие понятия как класс, экземпляр класса (объект), конструкторы, методы и поля класса.
  • Синтаксис: вопросы этого раздела проверят знание ключевых слов языка, операторов, основных типов (примитивы, String), управляющих конструкций (if-else, while, for), а также понимание обработки исключительных ситуаций (Exception).
  • Другое: этот раздел содержит вопросы касающиеся основных понятий, терминов и аббревиатур, конвенций именования классов, переменных и методов. Также в этом разделе рассматриваются вопросы по файлам (.java, .class, .jar) и пакетам, жизненному циклу объектов, сборке мусора (garbage collection).

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

Надеемся, что данный тест будет для вас полезным и занимательным.

Дальнейшее развитие теста по Java

Тест по Java постоянно пополняется новыми вопросами.

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

Если у Вас есть замечания по поводу вопросов теста, обязательно пишите нам. Удачи.

Тестирование далеко не всегда бывает веселым и интересным.

Этот процесс обычно достаточно продолжителен и порой полон монотонной работы.

Кажется, еще совсем недавно программисты пользовались стандартным выводом или же дебаггером для тестирования java классов.

Для демонстрации основных возможностей JUnit Framework, напишем примитивный класс на языке Java и будем над ним издеваться.

Этот класс будет иметь два метода - нахождение факториала неотрицательного числа и суммы двух чисел.

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

Public class MathFunc {

int calls;

public int getCalls() {

return calls;

public long factorial(int number) {

calls++;

if (number 1) {

for (int i = 1; i

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

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

Чтобы runner тестов мог определить, кто есть кто, тестовые методы необходимо помечать аннтоацией @Test.

У аннотации могут быть проставлены такие параметры:

  • expected - указываем какое исключение будет сгенерировано методом (см. Пример ниже);
  • timeout - через какое время в милисекундах прекратить выполнение теста и засчитать его как неуспешный.

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

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

А после выполнения нужно освободить зарезервированные ресурсы. В этом случае вам понадобятся аннтоации @Before и @After. Метод, помеченный @Before

Будет выполняться перед каждым тестовым случаем, а метод, помеченный @After - после каждого тестового случая.

Если же инициализацию и освобождение ресурсов нужно сделать всего один раз - соответственно до и после всех тестов - то используйте пару аннотаций

@BeforeClass и @AfterClass.

А вот и сам тестовый класс с несколькими тестовыми сценариями:

Public class MathFuncTest {

private MathFunc math;

@Before

public void init() { math = new MathFunc(); }

@After

public void tearDown() { math = null; }

@Test

public void calls() {

assertEquals(0, math.getCalls());

math.factorial(1);

assertEquals(1, math.getCalls());

math.factorial(1);

assertEquals(2, math.getCalls());

@Test

public void factorial() {

assertTrue(math.factorial(0) == 1);

assertTrue(math.factorial(1) == 1);

assertTrue(math.factorial(5) == 120);

@Test(expected = IllegalArgumentException.class)

public void factorialNegative() {

math.factorial(-1);

@Ignore

@Test

public void todo() {

assertTrue(math.plus(1, 1) == 3);

Метод calls тестирует правильность счетчика вызовов.

Метод factorial проверяет правильность вычисления факториала для некоторых стандартных значений.

Метод factorialNegative проверяет, что для отрицательных значений факотриала будет брошен IllegalArgumentException.

Метод todo будет проигнорирован. Попробуйте убрать аннотацию @Ignore, когда будете экспериментировать с кодом.

Метод assertTrue проверяет, является ли результат выражения верным. Некоторые другие методы, которые могут пригодиться:

  • assertEquals - ожидаемый результат и полученный результат совпадают;
  • assertNull - результатом выражения есть null;
  • assertNotNull - результат выражения отличен от null;
  • assertSame - ожидаемый и полученный объекты это один и тот же объект.
  • fail - метод генерирует исключение AssertionError - добавляем туда, куда не должен дойти ход выполнения программы.

В нашем современном мире IDE умеют находить и просто запускать тесты в проекте.

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

Для этого можно воспользоваться Runner"ом.

Бывают текстовый - junit.textui.TestRunner, графические версии - junit.swingui.TestRunner, junit.awtui.TestRunner.

Но чуть более современный метод - это использование класса JUnitCore. Добавьте следующий метод main в класс MathFuncTest:

Public static void main(String args) throws Exception {

JUnitCore runner = new JUnitCore();

Result result = runner.run(MathFuncTest.class);

System.out.println("run tests: " + result.getRunCount());

System.out.println("failed tests: " + result.getFailureCount());

System.out.println("ignored tests: " + result.getIgnoreCount());

System.out.println("success: " + result.wasSuccessful());

И результат выполнения:

Run tests: 3

failed tests: 0

ignored tests: 1

success: true

В более ранних версиях JUnit для написания тестового класса нужно было создать наследника junit.framework.TestCase.

Затем необходимо было определить конструктор, принимающий в качестве параметра String - название метода - и передать его родительскому классу.

Каждый тестовый метод обязан был начинаться с префикса test. Для инициализации и освобождения ресурсов использовались методы setUp и tearDown.

Короче ужас. Ну а сейчас все просто, да.

Вот и все на сегодня. Уверен, JUnit Framework во многом поможет вам. Комментарии и вопросы по поводу статьи приветствуются.

В поисках тестовых задач для java-программистов наткнулся на любопытный сайт (пользователям Avast не ходить, определяется скриптовый троян, остальным видимо можно) - . Он проверяет квалификацию ява-программистов самым простым, но зато автоматическим способом: предлагая написать несколько функций (методов) повышающейся сложности и скопировать код в TextArea. Далее движок сайта что-то делает с заданиями (не иначе как юнит-тестит), вычисляет по критериям "скорость-качество" некий индекс квалификации и выдает конечную оценку в таком виде:

Далее начинаются вопросы. Сам я на Java программировал второй раз в жизни (а потому сложные задачи просто поскипал), так что 82% по этому тесту соответствуют уровню не-java программист

. Сколько же тогда должны набирать Java Junior, Java Programmer и уж тем более Java Senior?! Какой результат ожидать от настоящего

java-программиста - 90, 95, 99? И наконец, как быть, если "программист" набирает меньше чем 82, но тем не менее претендует на какую-то работу?!

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

  • Когда я должен использовать инструмент X?
  • Как я должен использовать инструмент X?

Автоматизированное тестирование - очень важная часть разработки ПО, но в блогах программистов немного постов про используемые инструменты. Эта же статья позволит вам заглянуть в мой "ящик с инструментами". Я расскажу о 12-ти библиотеках и фреймворках, которые я использую для написания unit- и интеграционных тестов, а также предоставлю ссылки на страницы, которые помогут вам понять, как их использовать.

Заглянем в мой ящик с инструментами

Перед тем, как вы сможете использовать описанные далее инструменты, вы должны настроить сборку, которая автоматически запускает интеграционные и unit-тесты. У меня есть 2 заметки по этой теме:

  • Интеграционное тестирование с Maven описывает, как мы можем настроить Maven-сборку с интеграционными и unit-тестами в разных директориях.
  • Начало работы с Gradle: интеграционное тестирование с плагином TestSets описывает то же самое для Gradle.

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

Итак, вот 12 инструментов, которые я использую при интеграционном и unit-тестировании.

Запуск тестов

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

Дополнительно

  • Использование Hamcrest в тестировании рассказывает, как использовать Hamcrest для написания тестов, а также как расширить его возможности с помощью пользовательских модулей.
  • Превращаем утверждения в предметно-ориентированный язык рассказывает, как создавать пользовательские утверждения в AssertJ.
  • Пишем чистые тесты: замена утверждений предметно-ориентированным языком . Рассказывает, почему мы должны заменить стандартные утверждения JUnit собственными, которые используют верный предметно-ориентированный язык.

Тестирование кода доступа к данным

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

Расширение для JUnit, которое может быть использовано для инициализации БД в известное состояние перед выполнением каждого интеграционного теста и заполнения БД нужными данными. У DbUnit есть свои недостатки, но это очень полезный инструмент, позволяющий разделить тестовые данные и тестовый код.

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

Рубрика: Новичкам и программирование

Похожие статьи