Junit 노트

첫 번째 유닛 테스트
IDE는 Eclipse를 기반으로 하고 Java8 테스트 클래스를 기반으로 일반적으로 클래스 이름에 Test를 추가합니다.수행 장치 테스트: Package Explorer▶right-click▶Run As ▶ JUnit Test는 Fails와 Errors의 차이점에 주목합니다.

@FunctionalInterface
public interface Scoreable {
   int getScore();
}

import java.util.*;
public class ScoreCollection {
   private List<Scoreable> scores = new ArrayList<>();
   
   public void add(Scoreable scoreable) {
      scores.add(scoreable);
   }
   
   public int arithmeticMean() {
      int total = scores.stream().mapToInt(Scoreable::getScore).sum();
      return total / scores.size();
   }
}

테스트 코드:

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.*;
public class ScoreCollectionTest {
    @Before
    public void setUp() throws Exception {
    }
    @After
    public void tearDown() throws Exception {
    }
    @Test
    public void answersArithmeticMeanOfTwoNumbers() { 
        
        // Arrange
        ScoreCollection collection = new ScoreCollection(); 
        collection.add(() -> 5); 
        collection.add(() -> 7); 
        
        // Act
        int actualResult = collection.arithmeticMean(); 
        
        // Assert 
        assertThat(actualResult, equalTo(6)); 
    }
    @Test
    public void testArithmeticMean() {
        fail("Not yet implemented");
    }
}

실제 사례
면접 설문 조사 시스템

public class Answer {
   private int i;
   private Question question;
   public Answer(Question question, int i) {
      this.question = question;
      this.i = i;
   }
   public Answer(Question characteristic, String matchingValue) {
      this.question = characteristic;
      this.i = characteristic.indexOf(matchingValue);
   }
   
   public String getQuestionText() {
      return question.getText();
   }
   @Override
   public String toString() {
      return String.format("%s %s", question.getText(), question.getAnswerChoice(i));
   }
   public boolean match(int expected) {
      return question.match(expected, i);
   }
   public boolean match(Answer otherAnswer) {
      return question.match(i, otherAnswer.i);
   }
   public Question getCharacteristic() {
      return question;
   }
}

public enum Bool {
   False(0),
   True(1);
   public static final int FALSE = 0;
   public static final int TRUE = 1;
   private int value;
   private Bool(int value) { this.value = value; }
   public int getValue() { return value; }
}

public class BooleanQuestion extends Question {
   public BooleanQuestion(int id, String text) {
      super(id, text, new String[] { "No", "Yes" });
   }
   @Override
   public boolean match(int expected, int actual) {
      return expected == actual;
   }
}

import java.util.*;
public class Criteria implements Iterable<Criterion> {
   private List<Criterion> criteria = new ArrayList<>();
   public void add(Criterion criterion) {
      criteria.add(criterion);
   }
   @Override
   public Iterator<Criterion> iterator() {
      return criteria.iterator();
   }
   
   public int arithmeticMean() {
      return 0;
   }
   public double geometricMean(int[] numbers) {
      int totalProduct = Arrays.stream(numbers).reduce(1, (product, number) -> product * number);
      return Math.pow(totalProduct, 1.0 / numbers.length);
   }
}

public class Criterion implements Scoreable {
   private Weight weight;
   private Answer answer;
   private int score;
   public Criterion(Answer answer, Weight weight) {
      this.answer = answer;
      this.weight = weight;
   }
   
   public Answer getAnswer() { return answer; }
   public Weight getWeight() { return weight; }
   
   public void setScore(int score) { this.score = score; }
   public int getScore() { return score; }
}

public class PercentileQuestion extends Question {
   public PercentileQuestion(int id, String text, String[] answerChoices) {
      super(id, text, answerChoices);
   }
   @Override
   public boolean match(int expected, int actual) {
      return expected <= actual;
   }
}

import java.util.*;
import java.util.stream.*;
public class Person {
   private List<Question> characteristics = new ArrayList<>();
   public void add(Question characteristic) {
      characteristics.add(characteristic);
   }
   public List<Question> getCharacteristics() {
      return characteristics;
   }
   public List<Question> withCharacteristic(String questionPattern) {
      return characteristics.stream().filter(c -> c.getText().endsWith(questionPattern)).collect(Collectors.toList());
   }
}
/*
// your answer
// their answer
// how important is it to you
me very organized
you very organized
very important
me no
you no
irrelevant 0
little 1
10
50
mandatory 250
how much did other person satisfy?
      
      multiply scores
      take nth root
      
      .98 * .94 take sqrt (2 questions)
      
      (geometric mean)
*/

import java.util.*;
public class Profile { 
   private Map<String,Answer> answers = new HashMap<>();
   private int score;
   private String name;
   public Profile(String name) {
      this.name = name;
   }
   
   public String getName() {
      return name;
   }
   public void add(Answer answer) { 
      answers.put(answer.getQuestionText(), answer);
   }
   
   public boolean matches(Criteria criteria) { 
      score = 0;
      
      boolean kill = false;
      boolean anyMatches = false; 
      for (Criterion criterion: criteria) {   
         Answer answer = answers.get(
               criterion.getAnswer().getQuestionText()); 
         boolean match = 
               criterion.getWeight() == Weight.DontCare || 
               answer.match(criterion.getAnswer());
         if (!match && criterion.getWeight() == Weight.MustMatch) {  
            kill = true;
         }
         if (match) {         
            score += criterion.getWeight().getValue();
         }
         anyMatches |= match;  
      }
      if (kill)       
         return false;
      return anyMatches; 
   }
   public int score() {
      return score;
   }
}

public abstract class Question {
   private String text;
   private String[] answerChoices;
   private int id;
   public Question(int id, String text, String[] answerChoices) {
      this.id = id;
      this.text = text;
      this.answerChoices = answerChoices;
   }
   
   public String getText() {
      return text;
   }
   
   public String getAnswerChoice(int i) {
      return answerChoices[i];
   }
   public boolean match(Answer answer) {
      return false;
   }
   abstract public boolean match(int expected, int actual);
   public int indexOf(String matchingAnswerChoice) {
      for (int i = 0; i < answerChoices.length; i++)
         if (answerChoices[i].equals(matchingAnswerChoice))
            return i;
      return -1;
   }
}

public enum Weight {
   MustMatch(Integer.MAX_VALUE),
   VeryImportant(5000),
   Important(1000),
   WouldPrefer(100),
   DontCare(0);
   
   private int value;
   Weight(int value) { this.value = value; }
   public int getValue() { return value; }
}

다른 파일은 앞과 유사합니다.
단원 테스트는 지점과 데이터 변화에 잠재적으로 영향을 미치는 코드를 주목한다.순환,if문장과 복잡한 조건문에 주목한다.값이 null 또는 0이면?데이터 값이 어떻게 영향을 미치는지 조건 판단.
예를 들어 위의 Profile 클래스에 주목해야 할 사항은 다음과 같습니다.
for(Criterion criterion: criteria)는 Criteria에 객체가 없고 여러 객체가 있는 경우를 고려해야 합니다.Answer answer = answers.get(criterion.getAnswer().getQuestionText()); null로 돌아갑니다.criterion.getanswer()가 null 또는 criterion을 반환합니다.getAnswer().getQuestionText().30줄 match가true/false로 돌아갑니다.비슷한 것은 34, 37, 42, 44줄이다.
두 브랜치의 테스트 인스턴스는 다음과 같습니다.

import org.junit.*;
import static org.junit.Assert.*;
public class ProfileTest {
   private Profile profile;
   private BooleanQuestion question;
   private Criteria criteria;
   
   @Before
   public void create() {
      profile = new Profile("Bull Hockey, Inc.");
      question = new BooleanQuestion(1, "Got bonuses?");
      criteria = new Criteria();
   }
   @Test
   public void matchAnswersFalseWhenMustMatchCriteriaNotMet() {
      profile.add(new Answer(question, Bool.FALSE));      
      criteria.add(
            new Criterion(new Answer(question, Bool.TRUE), Weight.MustMatch));
      boolean matches = profile.matches(criteria);
      
      assertFalse(matches);
   }
   
   @Test
   public void matchAnswersTrueForAnyDontCareCriteria() {
      profile.add(new Answer(question, Bool.FALSE));      
      criteria.add(
            new Criterion(new Answer(question, Bool.TRUE), Weight.DontCare));
      boolean matches = profile.matches(criteria);
      
      assertTrue(matches);
   }
}

단언
단언에는 JUnit과 Hamcrest가 있는데 전자의 단언은 다음과 같다.
문장
묘사
assertTrue([message,] boolean condition)
부울 조건이 진짜인지 확인하세요.
assertFalse([message,] boolean condition)
부울 조건이 가짜라는 것을 확인하다
assertEquals([message,] expected, actual)
확인 반환은 기대와 같고, 그룹 등은 내용이 아닌 주소입니다.
assertEquals([message,] expected, actual, tolerance)
플로트나 더블 같은 것을 테스트합니다.tolerance가 허용하는 오차입니다.
assertNull([message,] object)
객체가 null입니다.
assertNotNull([message,] object)
객체가 null이 아닙니다.
assertSame([message,] expected, actual)
변수는 같은 대상을 가리킨다.
assertNotSame([message,] expected, actual)
변수는 다른 객체를 가리킨다
Hamcrest의 단언:assertThat.import static org를 가져옵니다.hamcrest.CoreMatchers.*;
조직 테스트 AAA(arrange,act,and assert)에는 After가 있을 수 있습니다.테스트 행위와 방법: 방법이 아니라 행위에 주목하고 테스트는 가능한 한 업무에 기반을 두어야 한다.테스트 코드와 제품 코드가 분리되다.사적인 내용도 최대한 테스트해야 한다.단일 테스트 방법의 테스트 내용은 가능한 한 단일해야 한다.문서화 테스트하기;이름은 목적을 볼 수 있어야 한다.예를 들어doingSomeOperationGeneratesSomeResult,someResultOccursUnderSomeCondition,givenSomeContextWhenDoingSomeBehaviorThenSomeResultOccurs 등•Improveany local-variable names.Introduce meaningful constants.• Prefer Hamcrest assertions.• Split larger tests into smaller, more-focused tests.• Move test clutter to helper methods and  @Before methods.클래스 기반 BeforeClass and AfterClass @Ignore는 용례를 무시할 수 있습니다.