Eclipse의 TestNG로 단위 테스트 작성

Question

클래스 MobileStorage은 레트로 휴대 전화의 수신함을 구현 한 것입니다. 이에 따라받은 편지함은 메시지 당 최대 160 자까지 미리 정의 된 최대 용량의 메시지를 보유하도록 지정됩니다. 다음 조작을 지원하고 테스트해야됩니다

1. saveMessage : 다음 자유 위치에서받은 편지함에 새 문자 메시지를 저장합니다. 메시지 텍스트가 160자를 초과하는 경우 메시지가 분할되어 여러 저장 위치에 저장됩니다.
2. deleteMessage :받은 편지함에서 가장 오래된 (처음) 모바일 메시지를 제거합니다.
3. listMessages : 현재 저장된 모든 메시지의 읽을 수있는 표현을 인쇄합니다. 여러 부분에 저장된 메시지는 표현을 위해 함께 결합됩니다.

첨부 된이 코드에 대한 단위 테스트가 필요합니다. 일반적으로 TestNG 및 단위 테스트에 대해 잘 알고 있지는 않지만 할 수있는 테스트의 몇 가지 예를 들어 도와 주시겠습니까?

mobile_storage \ SRC \ 주 \ 자바 \ MobileMessage.java - https://pastebin.com/RxNcgnSi

/** 
* Represents a mobile text message. 
*/ 
public class MobileMessage { 
    //stores the content of this messages 
    private final String text; 

    //in case of multi-part-messages, stores the preceding message 
    //is null in case of single message 
    private MobileMessage predecessor; 

    public MobileMessage(String text, MobileMessage predecessor) { 
     this.text = text; 
     this.predecessor = predecessor; 
    } 

    public String getText() { 
     return text; 
    } 

    public MobileMessage getPredecessor() { 
     return predecessor; 
    } 

    public void setPredecessor(MobileMessage predecessor) { 
     this.predecessor = predecessor; 
    } 
} 

mobile_storage \ SRC \ 주 \ 자바 \ MobileStorage.java - https://pastebin.com/wuqKgvFD

import org.apache.commons.lang.StringUtils; 

import java.util.Arrays; 
import java.util.Objects; 
import java.util.stream.IntStream; 

/** 
* Represents the message inbox of a mobile phone. 
* Each storage position in the inbox can store a message with 160 characters at most. 
* Messages are stored with increasing order (oldest first). 
*/ 
public class MobileStorage { 

    final static int MAX_MESSAGE_LENGTH = 160; 

    private MobileMessage[] inbox; 
    private int occupied = 0; 

    /** 
    * Creates a message inbox that can store {@code storageSize} mobile messages. 
    * @throws IllegalArgumentException in case the passed {@code storageSize} is zero or less 
    */ 
    public MobileStorage(int storageSize) { 
     if(storageSize < 1) { 
      throw new IllegalArgumentException("Storage size must be greater than 0"); 
     } 

     this.inbox = new MobileMessage[storageSize]; 
    } 

    /** 
    * Stores a new text message to the inbox. 
    * In case the message text is longer than {@code MAX_MESSAGE_LENGTH}, the message is splitted and stored on multiple storage positions. 
    * @param message a non-empty message text 
    * @throws IllegalArgumentException in case the given message is empty 
    * @throws RuntimeException in case the available storage is too small for storing the complete message text 
    */ 
    public void saveMessage(String message) { 
     if(StringUtils.isBlank(message)) { 
      throw new IllegalArgumentException("Message cannot be null or empty"); 
     } 

     int requiredStorage = (int) Math.ceil((double) message.length()/MAX_MESSAGE_LENGTH); 

     if(requiredStorage > inbox.length || (inbox.length - occupied) <= requiredStorage) { 
      throw new RuntimeException("Storage Overflow"); 
     } 

     MobileMessage predecessor = null; 
     for(int i = 0; i < requiredStorage; i++) { 
      int from = i * MAX_MESSAGE_LENGTH; 
      int to = Math.min((i+1) * MAX_MESSAGE_LENGTH, message.length()); 

      String messagePart = message.substring(from, to); 
      MobileMessage mobileMessage = new MobileMessage(messagePart, predecessor); 
      inbox[occupied] = mobileMessage; 
      occupied++; 
      predecessor = mobileMessage; 
     } 
    } 

    /** 
    * Returns the number of currently stored mobile messages. 
    */ 
    public int getOccupied() { 
     return occupied; 
    } 

    /** 
    * Removes the oldest (first) mobile message from the inbox. 
    * 
    * @return the deleted message 
    * @throws RuntimeException in case there are currently no messages stored 
    */ 
    public String deleteMessage() { 
     if(occupied == 0) { 
      throw new RuntimeException("There are no messages in the inbox"); 
     } 

     MobileMessage first = inbox[0]; 

     IntStream.range(1, occupied).forEach(index -> inbox[index-1] = inbox[index]); 
     inbox[occupied] = null; 
     inbox[0].setPredecessor(null); 
     occupied--; 

     return first.getText(); 
    } 

    /** 
    * Returns a readable representation of all currently stored messages. 
    * Messages that were stored in multiple parts are joined together for representation. 
    * returns an empty String in case there are currently no messages stored 
    */ 
    public String listMessages() { 
     return Arrays.stream(inbox) 
       .filter(Objects::nonNull) 
       .collect(StringBuilder::new, MobileStorage::foldMessage, StringBuilder::append) 
       .toString(); 
    } 

    private static void foldMessage(StringBuilder builder, MobileMessage message) { 
     if (message.getPredecessor() == null && builder.length() != 0) { 
      builder.append('\n'); 
     } 
     builder.append(message.getText()); 
    } 
} 

Answer 1

당신 것 testNG를 설정해야합니다. testNG로 테스트하는 방법은 Eclipse와 maven (의존성 관리)입니다. 일단 당신이 가지고 있다면, test.javasrc 폴더의 eclipse의 maven-Java project 폴더에있는 클래스들을 가져올 수 있습니다.

코드를 조정하고 testNG에 필요한 클래스를 가져와야 할 수 있습니다. Here은 testNG의 공식 문서이며 here은 assert 클래스입니다.

일부 테스트 사례를 포함 시키려고했습니다. 문제는이

 import yourPackage.MobileStorage; 
     import yourPackage. MobileMessage; 

     public class test{ 

     @BeforeTest 
     public void prepareInstance(){ 

      MobileStorage mobStg = new MobileStorage(); 
      MobileMessage mobMsg = new MobileMessage(); 
     } 

     //test simple msg 
     @Test 
     public void testSave(){ 

      mobStg.saveMessage("hello") 
      assert.assertEquals("hello", mobMsg.getText()) 
     } 

     //test msg with more chars 
     @Test 
     public void testMsgMoreChar(){ 
      mobStg.saveMessage("messageWithMoreThan160Char") 

      //access messagepart here somehow, i am not sure of that 
       assert.assertEquals(mobMsg.getText(), mobStg.messagePart); 

      //access message here somehow. This will test listMessages() and concatenation of msgs 
      assert.assertEquals(mobStg.message, mobStg.listMessages()) 
     } 

//test deletion of msg 
@Test  
public void testDelete(){ 
      mobStg.deleteMessage(); 
       assert.assertEquals(null, mobMsg.getPredecessor()) 
     } 



    }