JUnit :: 또는 JavaRush 유효성 검사기를 사랑하는 방법
개체 만들기
따라서 무언가를 테스트하려면 먼저 테스트 개체가 필요합니다. 우리 앞에는 과제가 있습니다.- 사용자에 대한 정보를 저장할 객체가 필요합니다.
- ID - 새 사용자가 추가된 순서대로 계산되어야 합니다.
- 사용자 이름.
- 그의 나이.
- 성별 남성 여성)
-
사용자 목록에 대한 저장소를 제공해야 합니다.
-
수업은 할 수 있어야합니다.
- 모든 사용자의 목록을 생성합니다.
- 성별(남성/여성)별로 사용자 목록을 생성합니다.
- 일반 목록의 사용자 수를 반환하고, 사용자의 성별을 기준으로 그 수를 계산합니다.
- 사용자 연령별로 총액을 계산하고 성별도 고려합니다.
- 전체 및 성별의 평균 연령을 계산합니다.
User필드를 포함할 Java 클래스를 생성해 보겠습니다.
private int id;
private String name;
private int age;
private Sex sex;allUsers. 그렇다면 괜찮을 것 같습니다.Map<Integer, User>
private static Map<Integer, User> allUsers;Id 또한 어떻게든 사용자에게 시퀀스 번호를 할당해야 합니다. 새 사용자를 생성할 때 사용자에게 시퀀스 번호를 할당하는 정적 카운터 필드를 만들어 보겠습니다 .
private static int countId = 0;id보겠습니다 name. heterae에는 복잡한 것이 없습니다. IDEA 에 도움을 요청하면 결코 거절하지 않을 것이며 생성자를 조금 까다롭게 만들 것입니다. 디자이너는 그럴 수 있을 것이다. 필드를 초기화하고 에 그러한 개체가 있는지 확인한 다음 그러한 개체가 없으면 카운터를 늘려 모든 사용자 목록에 추가합니다. 또한 아직 초기화되지 않은 경우 필드를 초기화합니다. 동일한 객체를 검색하는 편의를 위해 메서드를 다시 정의 하고 , 다시 사랑하는 IDEA 에 도움을 요청 하고 필드별로 비교할 것 입니다 . 또한 해당 객체가 목록에 있는지 확인하는 전용 메서드를 만들어 보겠습니다 .agesexallUserscountId++allUsers equals()hashCode()nameagesexhasUser()
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(name, user.name) &&
sex == user.sex;
}
@Override
public int hashCode() {
return Objects.hash(name, age, sex);
}public User(String name, int age, Sex sex) {
if (allUsers == null){
allUsers = new HashMap<>();
}
this.name = name;
this.age = age;
this.sex = sex;
if (!hasUser()){
countId++;
this.id = countId;
allUsers.put(id, this);
}
}private boolean hasUser(){
for (User user : allUsers.values()){
if (user.equals(this) && user.hashCode() == this.hashCode()){
return true;
}
}
return false;
}toString()
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}- 모든 사용자의 목록을 생성합니다.
- 성별(남성/여성)별로 사용자 목록을 생성합니다.
-
일반 목록의 사용자 수를 반환하고, 사용자의 성별을 기준으로 그 수를 계산합니다.
public static int getHowManyUsers(){ return allUsers.size(); } public static int getHowManyUsers(Sex sex){ return getAllUsers(sex).size(); } -
사용자 연령별로 총액을 계산하고 성별도 고려합니다. 이 작업을 위한 메서드를 만들어 보겠습니다.
public static int getAllAgeUsers(){ int countAge = 0; for (User user : allUsers.values()){ countAge += user.age; } return countAge; } public static int getAllAgeUsers(Sex sex){ int countAge = 0; for (User user : getAllUsers(sex)){ countAge += user.age; } return countAge; } -
전체 및 성별의 평균 연령을 계산합니다.
public static int getAverageAgeOfAllUsers(){ return getAllAgeUsers() / getHowManyUsers(); } public static int getAverageAgeOfAllUsers(Sex sex){ return getAllAgeUsers(sex) / getHowManyUsers(sex); }훌륭합니다. 필요한 개체와 해당 동작을 설명했습니다. 이제 JUnit 으로 넘어갈 수 있지만 먼저 main 에서 수행할 경우 간단한 테스트가 어떤 모습일지 보여드리겠습니다 .
public static void main(String[] args) { new User("Eugene", 35, Sex.MALE); new User("Marina", 34, Sex.FEMALE); new User("Alina", 7, Sex.FEMALE); System.out.println("All users:"); User.getAllUsers().forEach(System.out::println); System.out.println("All users: MALE"); User.getAllUsers(Sex.MALE).forEach(System.out::println); System.out.println("All users: FEMALE"); User.getAllUsers(Sex.FEMALE).forEach(System.out::println); System.out.println("================================================"); System.out.println(" all users: " + User.getHowManyUsers()); System.out.println(" all MALE users: " + User.getHowManyUsers(Sex.MALE)); System.out.println("all FEMALE users: " + User.getHowManyUsers(Sex.FEMALE)); System.out.println("================================================"); System.out.println(" total age of all users: " + User.getAllAgeUsers()); System.out.println(" total age of all MALE users: " + User.getAllAgeUsers(Sex.MALE)); System.out.println("total age of all FEMALE users: " + User.getAllAgeUsers(Sex.FEMALE)); System.out.println("================================================"); System.out.println(" average age of all users: " + User.getAverageAgeOfAllUsers()); System.out.println(" average age of all MALE users: " + User.getAverageAgeOfAllUsers(Sex.MALE)); System.out.println("average age of all FEMALE users: " + User.getAverageAgeOfAllUsers(Sex.FEMALE)); System.out.println("================================================"); }콘솔에 대한 출력은 다음과 같을 것이며, 정상적으로 작동하는지 비교해 보겠습니다. 물론 우리는 모든 것을 제공할 수 있는지 확신할 수 없더라도 더 깊이 들어가 비교 논리를 작성하고 계산 결과를 확인할 수 있습니다.
//output Все пользователи: User{id=1, name='Eugene', age=35, sex=MALE} User{id=2, name='Marina', age=34, sex=FEMALE} User{id=3, name='Alina', age=7, sex=FEMALE} Все пользователи: MALE User{id=1, name='Eugene', age=35, sex=MALE} Все пользователи: FEMALE User{id=2, name='Marina', age=34, sex=FEMALE} User{id=3, name='Alina', age=7, sex=FEMALE} ================================================ всех пользователей: 3 всех пользователей MALE: 1 всех пользователей FEMALE: 2 ================================================ общий возраст всех пользователей: 76 общий возраст всех пользователей MALE: 35 общий возраст всех пользователей FEMALE: 41 ================================================ средний возраст всех пользователей: 25 средний возраст всех пользователей MALE: 35 средний возраст всех пользователей FEMALE: 20 ================================================ Process finished with exit code 0우리는 이 결과에 만족하지 않습니다. 주요 테스트에는 JUnit이 필요합니다 .
a 점 과 bgetAllUsers() 점은 전달된 매개변수에 따라 all의 목록을 반환하는 메서드 와 목록을 반환하는 User오버로드된 메서드를 통해 잘 처리될 수 있습니다 .getAllUsers(Sex sex)Sex
public static List<User> getAllUsers(){
return new ArrayList<>(allUsers.values());
}
public static List<User> getAllUsers(Sex sex){
List<User> listAllUsers = new ArrayList<>();
for (User user : allUsers.values()){
if (user.sex == sex){
listAllUsers.add(user);
}
}
return listAllUsers;
}
JUnit을 프로젝트에 연결하는 방법
문제는 프로젝트에 연결하는 방법입니다. 아시는 분들을 위해 Maven 옵션을 선택하지 않겠습니다 . 이는 완전히 다른 이야기이기 때문입니다. ;) 프로젝트 구조 열기 Ctrl + Alt + Shift + S -> 라이브러리 -> + (새 프로젝트 라이브러리) 클릭 -> Maven에서 선택하면
해당 창이 표시됩니다. 검색 창에 "junit:junit:4.12"를 입력합니다. , 찾을 때까지 기다리십시오 -> OK! -> 알았어! 
이 결과를 얻어야 합니다. 
OK를 클릭하세요. 프로젝트에 JUnit이 추가된 것을 축하합니다. 계속 진행합시다. 이제 Java 클래스에 대한 테스트를 생성해야 합니다. 클래스 이름에 커서를 놓고 User -> Alt + Enter를 누르고 -> 테스트 생성을 선택합니다. JUnit4 라이브러리를 선택해야 하는 창이 표시되어야 합니다 -> 테스트할 메소드 선택 -> 확인 
아이디어 자체가 클래스를 생성합니다 UserTest. 이 클래스에서 테스트로 코드를 다룰 것입니다. 시작하자:
첫 번째 @Test
첫 번째 @Test 메서드를 만들어 보겠습니다getAllUsers(). 이 메서드는 모든 사용자를 반환해야 합니다. 테스트는 다음과 같습니다.
@Test
public void getAllUsers() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
actual.add(user2);
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}expected 우리에게 반환될 사용자를 배치할 목록을 생성합니다. -> Assert.assertEquals(actual, Expect) 메소드가 가정되는 사용자를 배치할 getAllUsers()목록을 생성합니다. 사용될 것이며 검사된 최신 목록을 여기에 전달합니다. 이 메서드는 제공된 목록의 개체를 테스트하고 테스트 결과를 반환합니다. 이 메서드는 상속이 있는 경우 부모 필드를 통과하는 경우에도 개체의 모든 필드를 비교합니다. 첫 번째 테스트를 실행해 보겠습니다. 테스트가 성공적으로 완료되었습니다. 이제 테스트를 실패하게 만들어 보겠습니다. 이를 위해 테스트 목록 중 하나를 변경해야 하며 목록에 한 명의 사용자를 추가하는 것을 주석 처리하여 이를 수행합니다 . actual getAllUsers()
actual
@Test
public void getAllUsers() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
//actual.add(user2);
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}
이제 테스트가 실패한 이유를 조금 살펴볼 수 있습니다. 여기서는 현재 목록보다 검사된 목록에 더 많은 사용자가 있음을 알 수 있습니다. 이것이 실패의 이유입니다. 메인에서 확인해볼까요? JUnit : main = 1 : 0. 완전히 다른 개체가 포함된 경우 테스트가 어떻게 보이는지 살펴보겠습니다. 다음과 같이 해보겠습니다.
@Test
public void getAllUsers() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
List<User> actual = new ArrayList<>();
actual.add(new User("User1", 1, Sex.MALE));
actual.add(new User("User2", 2, Sex.FEMALE));
actual.add(new User("User3", 3, Sex.MALE));
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}
여기에서 비교 목록에 다른 사용자가 있다는 것을 즉시 확인할 수 있습니다. 또한 <차이를 보려면 클릭>을 클릭하면 우리가 가지고 있는 데이터를 자세히 볼 수 있는 창이 나타납니다. 문제. IDEA는 차이점이 있는 모든 분야를 강조합니다. 
main이런 일이 일어날 수 있나요? - 아니요. JUnit : main = 2 : 0 자, 다음으로 넘어가겠습니다. 아직 테스트로 다루어야 할 메소드가 많이 있습니다. 하지만 잠깐만요. 메소드가 우리에게 getAllUsers()돌아올 지 확인하는 것도 나쁘지 않을 것입니다. 검증자가 포착한 JavaRushnull 작업 으로 우리가 하는 일). 해보자, 코펙 3개면 된다...
@Test
public void getAllUsers_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers();
Assert.assertNotNull(expected);
}null. ;) 이제 이 테스트를 실행하고 그것이 우리에게 무엇을 보여주는지 살펴보겠습니다. 그러면 오류가 표시됩니다. 어떻게???? 여기서 어떻게 테스트 오류가 발생할 수 있습니까?))) 
그리고 여기에서 테스트로 코드를 덮은 첫 번째 결실을 얻을 수 있습니다. 기억하시는 것처럼 allUsers 생성자에서 필드를 초기화했습니다. 즉, 메서드를 호출할 때 getAllUsers()아직 초기화되지 않은 개체를 참조하게 됩니다. 이를 편집하고 생성자에서 초기화를 제거하고 필드를 선언할 때 수행해 보겠습니다.
private static Map<Integer, User> allUsers = new HashMap<>();
public User(String name, int age, Sex sex) {
this.name = name;
this.age = age;
this.sex = sex;
if (!hasUser()) {
countId++;
this.id = countId;
allUsers.put(id, this);
}
}
메인에서 NPE를 잡는 것이 쉽지 않을 것이라고 생각합니다. 카운트가 JUnit: main = 3: 0이라는 점에 동의하실 것이라고 생각합니다. 그런 다음 모든 메서드를 테스트로 다루고 어떻게 보일지 알려 드리겠습니다. ... 이제 테스트 클래스는 다음과 같습니다.
package user;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.*;
public class UserTest {
@Test
public void getAllUsers() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
actual.add(user2);
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers();
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_MALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
List<User> expected = User.getAllUsers(Sex.MALE);
List<User> actual = new ArrayList<>();
actual.add(user);
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_MALE_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers(Sex.MALE);
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_FEMALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
List<User> expected = User.getAllUsers(Sex.FEMALE);
List<User> actual = new ArrayList<>();
actual.add(user1);
actual.add(user2);
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_FEMALE_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers(Sex.FEMALE);
Assert.assertNotNull(expected);
}
@Test
public void getHowManyUsers() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
int expected = User.getHowManyUsers();
int actual = 3;
Assert.assertEquals(expected, actual);
}
@Test
public void getHowManyUsers_MALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
int expected = User.getHowManyUsers(Sex.MALE);
int actual = 1;
Assert.assertEquals(expected, actual);
}
@Test
public void getHowManyUsers_FEMALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
int expected = User.getHowManyUsers(Sex.FEMALE);
int actual = 2;
Assert.assertEquals(expected, actual);
}
@Test
public void getAllAgeUsers() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
int expected = User.getAllAgeUsers();
int actual = 35 + 34 + 7;
Assert.assertEquals(expected, actual);
}
@Test
public void getAllAgeUsers_MALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
int expected = User.getAllAgeUsers(Sex.MALE);
int actual = 35;
Assert.assertEquals(expected, actual);
}
@Test
public void getAllAgeUsers_FEMALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
int expected = User.getAllAgeUsers(Sex.FEMALE);
int actual = 34 + 7;
Assert.assertEquals(expected, actual);
}
}@Before- 주석은 @Before테스트된 각 메소드 전에 메소드가 실행될 것임을 나타냅니다 @Test. 이제 주석이 포함된 테스트 클래스는 다음과 같습니다 @Before.
package user;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.*;
public class UserTest {
private User user;
private User user1;
private User user2;
@Before
public void setUp() throws Exception {
user = new User("Eugene", 35, Sex.MALE);
user1 = new User("Marina", 34, Sex.FEMALE);
user2 = new User("Alina", 7, Sex.FEMALE);
}
@Test
public void getAllUsers() {
List<User> expected = User.getAllUsers();
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
actual.add(user2);
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_NO_NULL() {
List<User> expected = User.getAllUsers();
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_MALE() {
List<User> expected = User.getAllUsers(Sex.MALE);
List<User> actual = new ArrayList<>();
actual.add(user);
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_MALE_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers(Sex.MALE);
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_FEMALE() {
List<User> expected = User.getAllUsers(Sex.FEMALE);
List<User> actual = new ArrayList<>();
actual.add(user1);
actual.add(user2);
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_FEMALE_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers(Sex.FEMALE);
Assert.assertNotNull(expected);
}
@Test
public void getHowManyUsers() {
int expected = User.getHowManyUsers();
int actual = 3;
Assert.assertEquals(expected, actual);
}
@Test
public void getHowManyUsers_MALE() {
int expected = User.getHowManyUsers(Sex.MALE);
int actual = 1;
Assert.assertEquals(expected, actual);
}
@Test
public void getHowManyUsers_FEMALE() {
int expected = User.getHowManyUsers(Sex.FEMALE);
int actual = 2;
Assert.assertEquals(expected, actual);
}
@Test
public void getAllAgeUsers() {
int expected = User.getAllAgeUsers();
int actual = 35 + 34 + 7;
Assert.assertEquals(expected, actual);
}
@Test
public void getAllAgeUsers_MALE() {
int expected = User.getAllAgeUsers(Sex.MALE);
int actual = 35;
Assert.assertEquals(expected, actual);
}
@Test
public void getAllAgeUsers_FEMALE() {
int expected = User.getAllAgeUsers(Sex.FEMALE);
int actual = 34 + 7;
Assert.assertEquals(expected, actual);
}
}@Test – определяет что метод method() является тестовым.
@Before – указывает на то, что метод будет выполнятся перед каждым тестируемым методом @Test.
@After – указывает на то что метод будет выполнятся после каждого тестируемого метода @Test
@BeforeClass – указывает на то, что метод будет выполнятся в начале всех тестов,
а точней в момент запуска тестов(перед всеми тестами @Test).
@AfterClass – указывает на то, что метод будет выполнятся после всех тестов.
@Ignore – говорит, что метод будет проигнорирован в момент проведения тестирования.
(expected = Exception.class) – указывает на то, что в данном тестовом методе
вы преднамеренно ожидаете Exception.
(timeout = 100) – указывает, что тестируемый метод не должен занимать больше чем 100 миллисекунд.Assert:
fail(String) – указывает на то что бы тестовый метод завалился при этом выводя текстовое сообщение.
assertTrue([message], boolean condition) – проверяет, что логическое condition истинно.
assertsEquals([String message], expected, actual) – проверяет, что два значения совпадают.
Примечание: для массивов проверяются ссылки, а не содержание массивов.
assertNull([message], object) – проверяет, что an object является пустым null.
assertNotNull([message], object) – проверяет, что an object не является пустым null.
assertSame([String], expected, actual) – проверяет, что обе переменные относятся к одному an objectу.
assertNotSame([String], expected, actual) – проверяет, что обе переменные относятся к разным an objectм.<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
GO TO FULL VERSION