DAY 31

🔖 오늘 읽은 범위 : 15. JUnit 들여다보기(324~334p)

🤓 책에서 기억하고 싶은 내용

JUnit 프레임워크

• 테스트 프레임워크로 가장 유명한 JUnit의 실제 내부 코드를 가져와 평가해보자

package junit.framework;
public class ComparisonCompactor {
    private static final String ELLIPSIS = "...";
    private static final String DELTA_END = "]";
    private static final String DELTA_START = "[";
    private int fContextLength;
    private String fExpected;
    private String fActual;
    private int fPrefix;
    private int fSuffix;
    public ComparisonCompactor(int contextLength, String expected, String actual) {
        fContextLength = contextLength;
        fExpected = expected;
        fActual = actual;
    }
    public String compact(String message) {
        if (fExpected == null || fActual == null || areStringsEqual()) return Assert.format(message, fExpected, fActual);
        findCommonPrefix();
        findCommonSuffix();
        String expected = compactString(fExpected);
        String actual = compactString(fActual);
        return Assert.format(message, expected, actual);
    }
    private String compactString(String source) {
        String result = DELTA_START +
            source.substring(fPrefix, source.length()– fSuffix + 1) + DELTA_END;
        if (fPrefix > 0)
            result = computeCommonPrefix() + result;
        if (fSuffix > 0)
            result = result + computeCommonSuffix();
        return result;
    }
    private void findCommonPrefix() {
        fPrefix = 0;
        int end = Math.min(fExpected.length(), fActual.length());
        for (; fPrefix < end; fPrefix++) {
            if (fExpected.charAt(fPrefix) != fActual.charAt(fPrefix))
                break;
        }
    }
    private void findCommonSuffix() {
        int expectedSuffix = fExpected.length() - 1;
        int actualSuffix = fActual.length() - 1;
        for (; actualSuffix >= fPrefix && expectedSuffix >= fPrefix; actualSuffix--, expectedSuffix--) {
            if (fExpected.charAt(expectedSuffix) != fActual.charAt(actualSuffix)) break;
        }
        fSuffix = fExpected.length() - expectedSuffix;
    }
    private String computeCommonPrefix() {
        return (fPrefix > fContextLength ? ELLIPSIS : "") + fExpected.substring(Math.max(0, fPrefix - fContextLength),
            fPrefix);
        private String computeCommonSuffix() {
            int end = Math.min(fExpected.length() - fSuffix + 1 + fContextLength,
                fExpected.length());
            return fExpected.substring(fExpected.length() - fSuffix + 1, end) +
                (fExpected.length() - fSuffix + 1 < fExpected.length()– fContextLength ? ELLIPSIS : "");
        }
        private boolean areStringsEqual() {
            return fExpected.equals(fActual);
        }
    }
}

• 보이스카우트 규칙에 따라 처음 왔을때 보다 더 깨끗하게 해놓고 떠나야 한다

1. 멤버 변수 앞에 붙인 접두어 f → 모두 제거

   • 오늘날 환경에서는 변수이름에 범위를 명시할 필요가 없다

2. compact 함수 시작부에 캡슐화 되지않은 조건문

   • 의도를 명확히 표현하려면 조건문을 캡슐화 → 메서드로 분리

   public String compact(String message) {
       if (shouldNotCompact())
           return Assert.format(message, expected, actual);
       findCommonPrefix();
       findCommonSuffix();
       String expected = compactString(this.expected);
       String actual = compactString(this.actual);
       return Assert.format(message, expected, actual);
   }
   private boolean shouldNotCompact() {
       return expected == null || actual == null || areStringsEqual();
   }

3. compact 함수에서 사용하는 this.expected, this.actual

   • 함수에 이미 expected 라는 local var 있는데 fExpected에서 f 빼면서 중복 문제 발생
   • 함수에서 멤버 변수와 이름이 똑같은 변수를 사용하지 말라 → 서로 다른의미임

     String compactExpected = compactString(expected); 
     String compactActual = compactString(actual);

4. 부정문은 긍정문보다 이해하기 약간 더 어렵다

   • 첫 if 문을 긍정으로 만들어 조건문을 반전

   public String compact(String message) {
       if (canBeCompacted()) {
           findCommonPrefix();
           findCommonSuffix();
           String compactExpected = compactString(expected);
           String compactActual = compactString(actual);
           return Assert.format(message, compactExpected, compactActual);
       } else {
           return Assert.format(message, expected, actual);
       }
   }
   private boolean canBeCompacted() {
       return expected != null && actual != null && !areStringsEqual();
   }

5. 함수 이름이 이상하다

   • compact 라는이름? canBeCompated 가 false 이면 압축하지 않으므로 오류 점검이라는 부가 단계가 숨겨진다
   • 또한 함수는 단순히 압축된 문자열이 아닌 형식이 갖춰진 문자열을 반환
   • formatCompactedComparison 이라는 이름이 적합

6. if 문 안에서는 예상 문자열과 실제 문자열을 진짜로 압축

   • 해당 부분을 빼내 compactExpectedAndActual 이라는 메서드로 분리, 압축만 수행
   • 형식 맞추는 작업은 formatCompactedComparison에 맡김

   ...
   private String compactExpected;
   private String compactActual;
   ...
   public String formatCompactedComparison(String message) {
       if (canBeCompacted()) {
           compactExpectedAndActual();
           return Assert.format(message, compactExpected, compactActual);
       } else {
           return Assert.format(message, expected, actual);
       }
   }
   private void compactExpectedAndActual() {
       findCommonPrefix();
       findCommonSuffix();
       compactExpected = compactString(expected);
       compactActual = compactString(actual);
   }

   • compactExpected와 compactActual이 멤버 변수로 승격했다
     • 멤버변수로 반환하는 형식을 맞추기위해 findCommonPrefix,Suffix로 리턴값을 만들어준다

   private void compactExpectedAndActual() {
       prefixIndex = findCommonPrefix();
       suffixIndex = findCommonSuffix();
       compactExpected = compactString(expected);
       compactActual = compactString(actual);
   }
   
   private int findCommonPrefix() {
       int prefixIndex = 0;
       int end = Math.min(expected.length(), actual.length());
       for (; prefixIndex < end; prefixIndex++) {
           if (expected.charAt(prefixIndex) != actual.charAt(prefixIndex)) break;
       }
       return prefixIndex;
   }
   
   private int findCommonSuffix() {
       int expectedSuffix = expected.length() - 1;
       int actualSuffix = actual.length() - 1;
       for (; actualSuffix >= prefixIndex && expectedSuffix >= prefixIndex; actualSuffix--, expectedSuffix--) {
           if (expected.charAt(expectedSuffix) != actual.charAt(actualSuffix))
               break;
       }
       return expected.length() - expectedSuffix;
   }
   

🤔 떠오르는 생각

🔎 질문

📝 소감 3줄 요약

• 의도를 명확히 표현하려면 조건문을 캡슐화 → 메서드로 분리
• 부정문은 긍정문보다 이해하기 약간 더 어렵다
• 함수명이 내용을 모두 기술하지 못하면 이름을 바꾸고 그래도 부족하면 역할 분리