測試一副撲克牌

Question

試圖學習如何在Java中進行測試，並認爲我現在已經很久了，因爲感覺就像我的試驗和錯誤越多，我越理解。我無法弄清楚如何通過填充模擬卡來測試甲板？我希望能夠在甲板上洗牌之前測試第一張牌中的第一張牌是真正的兩張牌，或者可以比較一下爲測試製作的全部牌，但現在它完全靜止不動。任何人有任何提示，以良好的方式測試甲板卡？

Card.java

package model; 

public class Card { 

    public enum Value { 
     Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Knight, Queen, King, Ace 
    } 

    public enum Suite { 
     Hearts, Spades, Diamonds, Clubs 
    } 

    private Value value; 
    private Suite suite; 

    public Card(Value value, Suite suite) { 
     if(value == null || suite == null){ 
      throw new IllegalArgumentException("Argument can't be null"); 
     } 

     this.value = value; 
     this.suite = suite; 
    } 

    public Object getValue() { 
     return this.value; 
    } 

    public Object getSuite() { 
     return this.suite; 
    } 

    public String toString(){ 
     return value + " of " + suite; 
    } 
} 

Deck.java

package model; 
import java.util.ArrayList; 

public class Deck { 

    private ArrayList<Card> cards = new ArrayList<Card>(); 
    private CardFactory CF = new CardFactory(); 

    public Deck(){ 
     init(); 
    } 

    public void init() {   
     for (int i=0; i<13; i++){  
      for (int j=0; j<4; j++){ 
       //card = cardFactory.createCard(Card.Value.values()[i], Card.Suite.values()[j]); 
       this.cards.add(CF.createCard(Card.Value.values()[i], Card.Suite.values()[j]));   
      } 
     } 
    } 

    public Card getCard() {  
     return cards.remove(0); 
    } 

    public int cardsLeft() {   
     return cards.size();   
    } 

    public Card getLastCard() { 
     return cards.remove(cards.size()-1); 
    } 
} 

CardFactory.java

package model; 

public class CardFactory { 

    public Card createCard(Card.Value value, Card.Suite suite){ 
     return new Card(value, suite); 
    } 

} 

DeckTest.java

package model; 

import static org.mockito.Mockito.verify; 
import static org.mockito.MockitoAnnotations.initMocks; 

import java.util.ArrayList; 

import org.junit.Before; 
import org.junit.Test; 
import org.mockito.InjectMocks; 
import org.mockito.Mock; 
import org.mockito.Mockito; 

public class DeckTest { 

    @Mock private ArrayList<Card> cards; 
    @Mock private Card card; 
    @Mock private CardFactory CF; 

    @InjectMocks private Deck sut; 

    @Before 
    public void setUp() throws Exception { 
     initMocks(this); 
    } 

    @Test 
    public void DeckContains52Cards() {      
     sut.init();  
     verify(cards, Mockito.times(52)).add(Mockito.any()); 
    } 

    @Test 
    public void getCardIsCalled() {  
     sut.getCard(); 
     verify(cards).remove(0);   
    } 

    @Test 
    public void cardsLeftIsCalled() {  
     sut.cardsLeft();   
     verify(cards).size();  
    } 

    @Test 
    public void getLastCardIsCalled() {  
     sut.getLastCard(); 
     verify(cards).size();  
    } 
} 

Answer 1

你得到它錯了。

首先你分離依賴關係。該CardFactory需要自由地生產它需要的牌：

public interface (or abstract class) CardFactory { 
    public List<Card> getCards(); 
} 

和

public class PokerCardFactory implements CardFactory { 
    public List<Card> getCards() { 
    ArrayList<Card> result = new ArrayList<>(); 
    for (int i=0; i<13; i++){  
     for (int j=0; j<4; j++){ 
     result.add(this.createCard(Card.Value.values()[i], Card.Suite.values()[j]));   
     } 
    } 
    return result; 
    } 

    private Card createCard(Value value, Suite suite) { 
    ... 
    } 
} 

那麼你注入的依賴關係（例如在構造函數），並用它來生成卡。

你想測試Deck而不是PokerCardFactory，所以你注入一個簡單的CardFactory來簡化測試。 mockito，讓你創建這樣一個工廠寫作方式少代碼。

@Mock private CardFactory cardFactory 
@Test 
public void numberOfCards { 
    ArrayList<Card> cards = new ArrayList(); 
    cards.add(new Card(Value.Two, Suite.Hearts)); 
    cards.add(new Card(Value.Three, Suite.Aces)); 
    when(cardFactory.getCards()).thenReturn(cards); // Now we have a CardFactory that will produce a deck with just two cards. 
    Deck deck = new Deck(cardFactory); // Dependency injection. 
    assertEquals("The number of cards does not match", 2, deck.getNumberOfCards()); // You have tested `getNumberOfCards`. 
} 

Answer 2

好吧，如果你想測試，你的甲板上的第一張牌是二的心，你的測試應該是這個樣子：

Deck deck = new Deck(); 

Card firstCard = deck.getCard(); 

assertCard(firstCard, Value.Two, Suite.Hearts) // orwhatever 

沒有需求嘲笑呢，呵呵？ ;）

但這基本上是錯誤的，因爲首先，第二張卡片可能是空間的王牌，第二，你不想測試'getCard'，你想驗證，甲板電話CardFactory按正確順序排列。無論如何你已經使用過驗證，所以不需要解釋。 但我不喜歡這個測試，因爲我本身沒有看到任何價值。只要洗牌工作，它是52張卡片，沒有重複卡片，這個測試已經過時了，但我猜，這對於學習目的來說仍然有好處。

因爲我不能評論，@ SJuan76的回答：這個測試不測試任何東西。我可以切換卡片，我可以刪除第一個條目並將第二個條目添加到它的位置，或者我甚至可以將兩個null添加到新創建的列表中，並且測試仍然通過。它在重構之後唯一應該測試的就是驗證，因爲這是唯一的事情，並且從測試的角度來看，cardFactory.getCards被調用。