Меню

Няколко начина за изпълнение на JUnit тестове

multiple ways execute junit tests

Опитайте Нашия Инструмент За Премахване На Проблемите

Този урок показва множество начини за изпълнение на JUnit тестове, като например стартиране като JUnit тест, използване на клавишни комбинации или стартиране на JUnit тест от командния ред и т.н.:

Видяхме как да напишем основните тестови случаи на JUnit и да използваме подхода за тестово приспособление като една от добрите практики за програмиране на JUnit в нашия предишен урок.

В този урок нека да разгледаме различните начини, които можем да използваме за изпълнение на тестове за JUnit. Ще бъдете изненадани да разгледате броя на наличните опции за изпълнение на тези тестови случаи.

=> Внимавайте тук за простите серии за обучение JUnit.

Няколко начина за изпълнение на JUnit тестове

Какво ще научите:

Различни начини за изпълнение на JUnit тестове

За да изпълните JUnit тестове, има определени начини, по които можете да стартирате файл с един клас с един или няколко метода за тестване чрез следните опции:

  1. Опция ‘Run as JUnit test’.
  2. Изпълнете последния изпълнен тест JUnit през опцията от менюто.
  3. Стартирайте с помощта на клавишни комбинации.
  4. Изпълнете само един тестов метод в клас.
  5. Изпълнете командния ред.
  6. Изпълнете с помощта на файла на класа на Testrunner.
  7. Изпълнете и с Maven.

Забележка: Изпълнението на JUnit теста чрез Maven ще бъде разгледано в отделен урок за JUnit Maven.

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

# 1) Изпълнете като JUnit тест

Най-простият начин, по който можете да изпълните JUnit тестовете, е:

Метод 1:

  1. Щракнете с десния бутон върху файла на класа в изгледа на скрипта
  2. Изберете Изпълнете като -> JUnit тест
  3. Файлът на класа се изпълнява.

Метод 2:

  1. По същия начин можете да изберете файла на класа от изгледа на Package Explorer
  2. Щракнете с десния бутон върху файла
  3. Изберете Изпълнете като -> JUnit тест
  4. Файлът на класа се изпълнява.

Забележка: По този начин можете да изпълнявате по един файл от класа наведнъж.

Изпълнете като JUnit тест

# 2) Стартирайте последно изпълнен тест JUnit чрез опцията от менюто

Можете да стартирате файл с клас JUnit, като държите файл от клас отворен в редактора. Отидете в горното меню на Затъмнение => Изберете Run => Run . Опцията Run -> Run по същество означава повторно пускане на теста, който сте провели последен.

Нека разгледаме клас JUnit с множество методи / тестове за по-голяма яснота как Run-> Run върши работа:

  • Сценарий 1 : Ако бяхте пуснали a единичен метод с @Test, след това когато щракнете Run-> Run , единственият метод, който се изпълнява последен, ще се изпълнява само този път, а не целият клас JUnit.
  • Сценарий 2 :Докато бяхте управлявали цял клас преди това, Run-> Run би повторил целия файл на класа.

Сега, когато знаем Run-> Run стартира теста, който сте изпълнили последен, това ни води до a въпрос ако можете да промените предпочитанието на опцията Run-> Run?

Отговорът на въпроса е Да, предпочитанието на опцията Run-> Run може да бъде променено. Към Run-> Run е прикрепена определена конфигурация.

Ето как можете да направите това:

да се) Настройката за изпълнение на Eclipse по подразбиране е по подразбиране стартирайте избрания ресурс или активен редактор, ако е стартиращ .

И така, какво означава настройката по подразбиране - ‘Стартиране на избрания ресурс или активен редактор, ако може да се стартира’?

Отговорът на това е, че няма да изпълни приложението, което сте стартирали последно, а ще последва повторното изпълнение на последното стартирано приложение за активният редактор .

б) Тогава как да промените предпочитанието по подразбиране?

Отговорът на това е, че можете да промените предпочитанието по подразбиране в Eclipse, за да стартирате последното стартирано приложение независимо от активния редактор ти имаш.

По-долу е описано как променяте предпочитанието на опцията „Изпълнение“, като използвате „Изпълнение -> Изпълнение“:

  • Отидете до Windows => Предпочитания => Изпълнение / отстраняване на грешки => Стартиране
  • ‘Launch Operation’ има радио бутон по подразбиране - ' Стартирайте стартираното преди това приложение “ избрана при втората опция „ Стартирайте избрания ресурс или активен редактор. Ако не може да се стартира : ’.
  • Може да се наложи да промените това предпочитание на първия радио бутон, т.е. ' Винаги стартирайте стартираното преди това приложение “.

2. Изпълнете последния изпълнен тест JUnit чрез опцията Меню

# 3) Стартирайте с помощта на клавишни комбинации

Можете да изберете файла на класа от изгледа на скрипта или изгледа на Package Explorer и да използвате клавишите за бърз достъп по-долу, за да изпълните JUnit тестовете:

  1. Натиснете клавишите ALT + SHIFT + X, T за да изпълни файла на класа JUnit.
  2. Алтернатива на това би била пресата ALT + R, след това CTRL + F11 за изпълнение на файл с клас JUnit. ALT + R, след това CTRL + F11 е пряк път за опция от менюто Run -> Run

# 4) Изпълнете само един метод за тестване в клас

Понякога може да искате да изпълните един метод за тестване на JUnit.

В случай че във файла на класа JUnit има повече от един метод:

  1. Можете да изберете или да поставите курсора върху името на метода в изгледа на скрипта.
  2. Използвайте или клавишните комбинации, споменати по-горе, или опциите, предоставени по-горе, за да изпълните само метода, който току-що сте избрали.

Забележка: ALT + SHIFT + X, T може да изпълнява избрани методи, както се очаква. Ако обаче искате да стартирате конкретен метод в клас JUnit, той трябва да бъде тестов случай, анотиран с @Test, иначе показва грешка при инициализация.

С други думи, ако изберете методи под @Before или @After (всяка анотация, различна от @Test), тогава изпълнението на конкретния метод ще доведе до грешка.

# 5) Стартирайте JUnit тестове от командния ред

Подобно на това, че стартирате всякакви файлове от клас Java чрез командния ред, можете също да компилирате и стартирате файлове от клас JUnit чрез командния ред.

Тук ще разгледаме подтемите по-долу, за да разберем как можем да стартираме тестове JUnit чрез командния ред:

  1. Как да компилирам JUnit тест в командния ред?
  2. Как да стартирам JUnit тест в командния ред?
  3. Допълнителна информация за изпълнението на командния ред.
    • Как да коригирам неразпозната грешка в командата за команда javac?
    • Предимства на провеждането на тестове с помощта на командния ред.

# 5.1) Как да компилирам тест JUnit в командния ред?

Предварителното условие за компилиране и стартиране на файл с клас JUnit чрез командния ред е:

  1. Първо добавете съответните JUnit Jar файлове в пътя на класа.
  2. Задайте променливите на средата, както беше споменато в Настройка на JUnit урок.
  3. След това компилирайте файл с клас JUnit.
  4. Синтаксисът за компилиране на файл с клас JUnit чрез командния ред е:
javac -cp junit-4.0.0.jar;. JUnitProgram.java

Тук javac е компилаторът на Java, който използва опцията -cp.

Командата javac -cp търси следните параметри:

  1. JUnit jar файлът е последван от точка и запетая.
  2. Пътят на директорията, в която съществува изходният файл.
  3. Името на файла на класа

Какво означава точката (.) В горния синтаксис?

Споменахме точка на мястото на целия път на директорията.

Точката предполага, че:

  1. Пътът на класа вече включва текущата директория за изходните файлове на Java.
  2. JVM (Java Virtual Machine) автоматично приема, че текущата директория е мястото, където се поставят изходните файлове.
  3. След това JVM търси споменатото име на JUnit файл там. Името на файла е последният параметър, даден в командата за компилиране.

Можете да проверите параметрите, които влизат в -cp, чрез следните стъпки:

  1. Отворете командния ред.
  2. Въведете javac и натиснете ENTER.
  3. Показват се всички подходящи опции, включително -cp. Ще откриете, че -cp върви като параметър, където пътят е пътят към файловете на класа, който JVM търси.

Екранна снимка по-долу:

компилирайте JUnit тест в командния ред

Как да компилирам няколко файла наведнъж?

Няколко тестови файла JUnit могат да бъдат компилирани наведнъж чрез разделяне на имената на файловете с интервали.

По-долу е даден пример за това къде компилирате java файлове JUnitProgram и demoTest:

javac -cp junit-4.0.0.jar;. JUnitProgram.java demoTest.java

# 5.2) Как да стартирам JUnit тест от командния ред?

Подобно на javac се използва и Java компилаторът java -cp се използва за стартиране на файловете на класа Java, включително класовете JUnit.

По-долу е синтаксисът, който можете да следвате:

java -cp junit-4.0.0.jar;. JUnitProgram demoTest

Тази команда изпълнява както файловете JUnitProgram.java, така и demoTest.java един след друг.

# 5.3) Допълнителна информация за „изпълнение на командния ред“.

как да видите .bin файлове

Ето малко допълнителна информация за как да коригирам грешка с командата javac и защо да използвате опцията за изпълнение на командния ред

# 5.3.1) Как да поправя неразпознатата грешка в командата за команда javac?

Повечето от нас биха се сблъскали с този проблем, докато се опитват да изпълнят javac команда чрез командния ред. Това се случи и на мен; затова си помислихме да го напишем тук.

да се) Влязохме в командата javac и натиснат Въведете в командния ред.

б) Съобщението за грешка - javac не се разпознава като вътрешна или външна команда, работеща програма или партиден файл показа се по-долу:

Съобщение за грешка

Тук започва вашата компилация на файловете от класа на Java от командния ред. Следователно грешката наистина предизвиква безпокойство и не може да бъде игнорирана.

За да отстраните проблема, следвайте стъпките по-долу и Ето го!!! виждате, че грешката е изчезнала:

  • Нека демонстрираме този процес, използвайки основен Java файл. Първата стъпка, която можете да направите, е да създадете основен Java клас E.g. : „Калкулатор.java“
  • Ще намерим Calculate.java от Windows Explorer и ще копираме пътя.

Calculate.java от Windows Explorer

  • Променете директорията в командния ред на пътя, който сте копирали (пътя на изходния файл). Използвайте cd, за да промените директорията.

3. Променете директорията в командния ред на пътя, който сте копирали

  • Сега задайте PATH в папката jdk bin с помощта на командата.

SET PATH = и натиснете ENTER.

  • Тук пътят на jdk е C: Program Files Java jdk1.8.0_181 bin. Следователно, ние сме задали пътя съответно. Резултантното не показва нищо при натискане на ENTER след командата.

Резултантът не показва нищо при натискане на ENTER

  • Сега проверете дали JVM разпознава командата javac като въведете командата javac и натиснете ENTER.
    1. Ако той разпознае командата, тогава набор от валидни опции за javac се показва като резултат.
    2. В противен случай грешката ще се появи отново.

Дадено по-долу е екранна снимка, показваща, че успешно се отървахме от грешката.

команда javac

Нека не се опитваме да избягваме съществен въпрос тук:

Защо JVM разпозна командата javac, след като зададе пътя към папката jdk bin?

Сигурни сме, че и вие ще имате този въпрос в ума си. Даден по-долу е отговорът.

  • Папката jdk bin съдържа всички библиотеки за команда javac. Следователно, ето защо, когато зададете пътя съответно, JVM вече е в състояние да разпознае командата javac без проблем.
  • Вижте папка javac под jdk кошчето на изображението по-долу.

javac папка под jdk кошчето

  • След това можете да стартирате командата ‘Java compile and run’ с помощта на командния ред. Освен това не забравяйте също така да настроите променливата CLASSPATH по подходящ начин. Променливата JAVA_HOME и JUNIT_HOME за Java файлове и JUnit файлове, съответно.

# 5.3.2) Предимство на провежданите тестове с помощта на командния ред:

Нека да обсъдим бързо предимството пред изпълнението на Java / JUnit тестови случаи чрез командния ред.

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

Ако попитате дали има специално предимство да имате ноу-хау за изпълнението на тестовете JUnit чрез командния ред, тогава бихме казали „Със сигурност, да“.

Причината за „Да“ е дадена по-долу:

  1. Всички тези серии от стъпки, които последвахме по-горе; може да се добави в бележник и да се преобразува в партиден файл.
  2. Сега, когато стартирате този партиден файл с двойно щракване, той може да задейства компилирането и изпълнението на множество JUnit тестови файлове, посочени в партидния файл.

Каква е ползата от това, че пакетният файл прави компилацията и изпълнението на Java файловете?

  1. Файлът за партида / буркан може да действа като удобна за потребителя помощна програма, която може да позволи на всеки, който не знае за вътрешната логика на кода, и да изпълни много тестови случаи много лесно.
  2. Това може да елиминира нуждата от специализиран разработчик или QA, който да изпълнява тези задачи за изпълнение на тестове. Задачата за изпълнение може да бъде делегирана на всеки ресурс, без да се притеснявате за ограниченията на уменията.

В следващата алтернативна опция ще видим друг изгоден и похвален начин за изпълнение на нашите JUnit тестови случаи.

# 6) Стартирайте Test Suite, използвайки Testrunner Class

В сценарии в реално време изпълнението на един тестов случай е най-малко предпочитаната опция.

  • Имаме случаи, при които трябва да стартираме група свързани / несвързани тестови случаи.
  • Например може да се наложи да създадем и изпълним регресионни тестови комплекти или димни тестови комплекти.

Сега ще научим за изпълнението на различни анотации, използвани за създаване на тестови пакети и изпълнение на пакета.

Цялостният процес на изпълнение на тестовия пакет с помощта на Test Runner е съгласно работния процес по-долу:

  1. Създайте JUnit клас 1, JUnit клас 2,…. JUnit клас n.
  2. Създайте файл на класа на Test Suite, групирайки тестовите случаи.
  3. Създайте файл на клас Testrunner, за да извикате създадения тестов пакет.
  4. Изпълнете класа Testrunner.

Структурата на програмите, чрез които ще демонстрираме създаването на тестов пакет и изпълнението на файла на бегача, е показана на изображението по-долу:

тестов пакет

Тук ще разгледаме подтемите:

  1. Създаване на JUnit класове
  2. Създаване на тестови пакети
  3. Създаване на Testrunner файл и изпълнение на тестовите пакети с него.
  4. Допълнителна информация за работата на @RunWith анотация.

# 6.1) Създаване на JUnit класове

Нека започнем със създаването на два прости файла с класа на JUnit:

  1. JUnitTestCase1.java - Включва кода за проверка на очакваната числена стойност - променливата Стойност1 съответства на действителна стойност на променливата Стойност2.
  2. JUnitTestCase2.java - Включва кода за проверка дали очакваната променлива на низа strValue и действителната променлива на низа strАктуално мачове.

Това са основно два тестови случая, които ще се опитаме да влезем в логическо групиране, наречено test suite, и да го накараме да се изпълнява един след друг.

Код за JUnitTestCase1.java

package demo.tests; import static org.junit.Assert.*; import java.util.*; import java.lang.String; import static org.testng.Assert.assertTrue; import org.junit.Before; import org.junit.Test; import junit.framework.Assert; public class JUnitTestCase1 { public int Value1=6000; @Test public void junitMethod1(){ int Value2=9000; Assert.assertEquals(Value1, Value2); } }

Код за JUnitTestCase2.java

package demo.tests; import static org.junit.Assert.*; import java.util.*; import java.lang.String; import static org.testng.Assert.assertTrue; import org.junit.Before; import org.junit.Test; import junit.framework.Assert; public class JUnitTestCase2 { public String stringValue='JUnit'; @Test public void junitMethod2(){ String strActual='Junit1'; Assert.assertSame(stringValue, strActual); } }

# 6.2) Създаване на тестов пакет:

Този и следващият раздел играят видна роля в целия процес на създаване и стартиране на тестов пакет. В този раздел ще се опитаме да разберем как да групирате множество тестови класове JUnit и да ги свържете в тестов пакет .

Съгласно структурното изображение по-горе, нека създадем тестов пакет, групиращ заедно JUnitTestCase1.java и JUnitTestCase2.java и назовем пакета като JUnitTestSuite.java

Двете пояснения, които ни помагат да постигнем създаването на тестов пакет, са:

  1. @RunWith и
  2. @SuiteClasses

Пакети, необходими за поясненията:

  1. Ще трябва да импортирате пакета org.junit.runner.RunWith; за включване на @RunWith анотация.
  2. Ще ви е необходим пакетът org.junit.runners.Suite.SuiteClasses, за да работи @SuiteClasses.
  3. Освен това ще трябва да импортирате пакета org.junit.runners.Suite за предаване на параметър Suite.class в анотацията @RunWith.

Нека да разгледаме кода за по-добро разбиране !!

Код за JUnitTestSuite.java

package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; @RunWith(Suite.class) @SuiteClasses({JUnitTestCase1.class, JUnitTestCase2.class }) public class JUnitTestSuite { @BeforeClass public static void printMe() { System.out.println('JUnitTestSuite is the test suite grouping testcase 1 and testcase 2'); } }

Разбиране на кода за JUnitTestSuite.java:

  1. @RunWith помага на JVM да разбере какъв клас бегачи трябва да изпълнява E.g. Апартамент.клас или Краставица.клас
  2. Тук параметърът на @RunWith е Suite.class . Помага на JVM да разпознае, че текущият файл, в който се използва @RunWith (Suite.class), играе роля в Test Suite.
  3. Имената на тестовите класове JUnit, които трябва да бъдат обвързани заедно в пакет, трябва да се предават като масив от низове под формата на параметри за @SuiteClasses, разделени със запетая.
  4. Това позволява на JVM да знае кои са всички тестови случаи, които трябва да бъдат групирани под пакета.
  5. Името на пакета ще бъде името на файла на класа JUnit, което е отбелязано с @RunWith и @SuiteClasses, което в този случай е JUnitTestSuite.

# 6.3) Създайте файл Test Runner и стартирайте JUnit Test suite с помощта на Test Runner

Последната стъпка ще ни помогне да стартираме тестовия пакет, който току-що създадохме в горния раздел, използвайки Testrunner файл.

  1. Сега ще създадем Java файл с име SuiteRunnerFile.
  2. Този SuiteRunnerFile.java не е клас JUnit, а обикновен Java файл с основния метод в него.

Нека да разгледаме кода и след това да се опитаме да го разберем.

Код за SuiteRunnerFile.java

package demo.tests; import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.notification.Failure; public class SuiteRunnerFile { public static void main(String args()) { Result result=JUnitCore.runClasses(JUnitTestSuite.class); for (Failure failure : result.getFailures()) { System.out.println(failure.toString()); } } }

Пакети, необходими за анотацията

  1. Трябва да импортирате пакета org.junit.runner.JunitCore, за да включите JUnitCore клас в кода.
  2. Трябва да импортирате пакета org.junit.runner.notification.Failure и org.junit.runner. Резултат, за да се включат съответно клас Failure и Result.

Разбиране на кода за SuiteRunnerFile.java

  1. За да се създаде файл за изпълнение за изпълнение на тестовия пакет, JUnitCore клас играе значителна роля.
  2. The runClasses () метод на JUnitCore class приема името на класа на тестовия пакет като входен параметър, следователно имаме изявлението JUnitCore. runClasses (JUnitTestSuite. клас ).
  3. Типът на връщане на този израз е Резултат обект на клас, който съхранява полученото състояние на успех и състояние на неуспех на всеки файл от тестовия случай; след изпълнение. Ето защо имаме резултат като Резултат обект на клас в кода.
  4. След това отпечатваме неуспехите на тестовите случаи, ако има такива. Подобно на метода getFailures (), вие също можете да получите броя на неуспехите и броя на изпълненията, използвайки съответно метода getFailureCount () и getRunCount ().
  5. Сега SuiteRunnerFile е готов за изпълнение,
    1. Изберете файла от Package Explorer и
    2. Щракнете с десния бутон и изберете Run As -> Java, програмата се изпълнява.

По-долу е дадена екранната снимка на прозореца на конзолата.

Конзолен прозорец

Обяснение на резултатите в конзолата:

Конзолата по-горе показва, че:

  1. Файлът на класа JUnitTestSuite е изпълнен чрез SuiteRunnerFile.
  2. Методът printMe () под анотация @BeforeClass се изпълнява първо и
  3. Тогава тестовите случаи в тестовия пакет се изпълняват един след друг. Ето как тестовият пакет може да бъде създаден и стартиран като пакет.

# 6.4) Допълнителна информация - Как работи @RunWith?

  • @RunWith е JUnit API, който по същество приема само един елемент като входен параметър, който е име на файл на клас на бегач.
  • JUnit framework извиква посочения клас като тестово изпълнение.

Долният фрагмент от RunWith.java ще ви помогне да разберете:

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Inherited public @interface RunWith { Class value(); }

Разбиране на горния код на интерфейса RunWith:

  1. Посоченото стойност елементът трябва да бъде производен клас на Бегач клас . Тук е използвана концепцията за отражение.
  2. Много добър пример за такъв клас на бегач вече е реализиран в нашия код, т.е. @RunWith (Suite.class), където група от тестови случаи е свързана заедно, за да направи тестов пакет.
  3. По същия начин, друг добър пример за използване на клас Runner с @RunWith може да бъде @RunWith (Cucumber.class), който е рамка за управление на бизнеса (BDD) за автоматизация на тестове, използвайки Selenium в Java. Това помага на рамката да изпълнява тестови случаи, базирани на Краставица.

Забележка:

  • Анотациите и параметрите, използвани за създаване и стартиране на тестовия пакет JUnit в този урок, са специфични за JUnit 4.
  • Има малко по-различен начин за това как да създадете JUnit Test Suite и да изпълните изпълняващия файл в JUnit 5.

Скоро ще имаме фокусирано разбиране на всички аспекти на JUnit 4 срещу JUnit 5 в нашите предстоящи уроци.

# 7) Стартирайте JUnit Test Cases с помощта на Maven

Можете също така да имате проект на Maven, състоящ се от тестове JUnit, и да стартирате тестовете през Maven, които ще бъдат разгледани в отделен урок.

Заключение

  1. Научихме всички различни опции за провеждане на тестовете JUnit - единични тестове, както и множество тестове, групирани заедно в тестови пакети.
  2. Получихме допълнителни знания за това как да актуализираме предпочитанието за опцията Изпълнение, как да коригираме грешката на javac и как може да ни помогне изпълнението на командния ред.
  3. Освен това научихме и как работи анотацията @RunWith.

Следователно има още какво да следвате в предстоящите уроци. ‘Stand By’ дотогава !!!

=> Посетете тук, за да научите JUnit от нулата.

Препоръчително четене

^