package org.limewire.ui.swing.tictactoe;
 
import junit.framework.Test;
 
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.lib.legacy.ClassImposteriser;
import org.limewire.util.BaseTestCase;
 
/**
 * Tests the various ways a Tic Tac Toe game could be won, along with
 * testing that draws and game not decided is returned.
 * <p>
 * <ol>
 * <li>Extend from <code>BaseTestCase</code>.
 * <li>Add a <code>suite</code> method which builds the test suite using.
 * <li>Precede each method you want to be called by the suite with 'test'.
 * <li>Use asserts.
 * <li>Use mocks when appropriate.
 * <p>
 * Additionally, this test class has two methods to show how to use mocks
 * in test cases. In reality, mocks aren't necessary for this case because
 * creating a <code>TicTacToeBoard</code> instance can be done using an initial 
 * constructor. However, mocks are included for demonstration.
 */
public class TicTacToeBoardTest extends BaseTestCase {
 
    public TicTacToeBoardTest(String name) {
        super(name);
    }
 
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
 
    public static Test suite() {
        return buildTestSuite(TicTacToeBoardTest.class);
    }
    /**
     * @throws Exception if any error occurs.
     */
    public void testXAcross() throws Exception  {
        TicTacToeBoard x1 = new TicTacToeBoard('x', 'x', 'x', 
                'o', 'o', 'x', 
                'o', 'o', 'e');
 
        assertEquals(x1.result(), TicTacToeWinner.ACROSS_1);
 
        TicTacToeBoard x2 = new TicTacToeBoard('o', 'x', 'x', 
                'x', 'x', 'x', 
                'o', 'o', 'e');
 
        assertEquals(x2.result(), TicTacToeWinner.ACROSS_2);
 
        TicTacToeBoard x3 = new TicTacToeBoard('o', 'x', 'o', 
                'o', 'o', 'x', 
                'x', 'x', 'x');
        assertEquals(x3.result(), TicTacToeWinner.ACROSS_3);
 
    }
 
    public void testOAcross() throws Exception  {
        TicTacToeBoard o1 = new TicTacToeBoard('o', 'o', 'o', 
                'o', 'x', 'x', 
                'x', 'o', 'e');
 
        assertEquals(o1.result(), TicTacToeWinner.ACROSS_1);
 
        TicTacToeBoard o2 = new TicTacToeBoard('o', 'x', 'x', 
                'o', 'o', 'o', 
                'x', 'o', 'e');
 
        assertEquals(o2.result(), TicTacToeWinner.ACROSS_2);
 
        TicTacToeBoard o3 = new TicTacToeBoard('o', 'x', 'o', 
                'x', 'o', 'x', 
                'o', 'o', 'o');
        assertEquals(o3.result(), TicTacToeWinner.ACROSS_3);
 
    }
    public void testXDown() throws Exception  {
        TicTacToeBoard x1 = new TicTacToeBoard('x', 'x', 'o', 
                'x', 'o', 'x', 
                'x', 'o', 'e');
 
        assertEquals(x1.result(), TicTacToeWinner.DOWN_1);
 
        TicTacToeBoard x2 = new TicTacToeBoard('o', 'x', 'o', 
                'o', 'x', 'o', 
                'x', 'x', 'e');
 
        assertEquals(x2.result(), TicTacToeWinner.DOWN_2);
 
        TicTacToeBoard x3 = new TicTacToeBoard('o', 'x', 'x', 
                'x', 'o', 'x', 
                'o', 'o', 'x');
        assertEquals(x3.result(), TicTacToeWinner.DOWN_3);
 
    }
 
    public void testODown() throws Exception  {
        TicTacToeBoard o1 = new TicTacToeBoard('o', 'x', 'o', 
                'o', 'x', 'x', 
                'o', 'o', 'e');
 
        assertEquals(o1.result(), TicTacToeWinner.DOWN_1);
 
        TicTacToeBoard o2 = new TicTacToeBoard('o', 'o', 'x', 
                'x', 'o', 'o', 
                'x', 'o', 'e');
 
        assertEquals(o2.result(), TicTacToeWinner.DOWN_2);
 
        TicTacToeBoard o3 = new TicTacToeBoard('x', 'x', 'o', 
                'x', 'o', 'o', 
                'o', 'x', 'o');
        assertEquals(o3.result(), TicTacToeWinner.DOWN_3);
 
    }
 
    public void testXDiagonal() throws Exception  {
        //negative slope
        TicTacToeBoard x1 = new TicTacToeBoard('x', 'x', 'o', 
                'o', 'x', 'x', 
                'o', 'o', 'x');
 
        assertEquals(x1.result(), TicTacToeWinner.DIAG_1);
 
        //positive slope
        TicTacToeBoard x2 = new TicTacToeBoard('o', 'x', 'x', 
                'o', 'x', 'o', 
                'x', 'o', 'e');
 
        assertEquals(x2.result(), TicTacToeWinner.DIAG_2);
 
    }
 
    public void testODiagonal() throws Exception  {
        //negative slope
        TicTacToeBoard o1 = new TicTacToeBoard('o', 'x', 'o', 
                'x', 'o', 'x', 
                'x', 'o', 'o');
 
        assertEquals(o1.result(), TicTacToeWinner.DIAG_1);
 
        //positive slope
        TicTacToeBoard o2 = new TicTacToeBoard('x', 'x', 'o', 
                'x', 'o', 'o', 
                'o', 'x', 'e');
 
        assertEquals(o2.result(), TicTacToeWinner.DIAG_2);
 
    }
 
    public void testDraw() throws Exception  {
        TicTacToeBoard draw = new TicTacToeBoard('o', 'x', 'o', 
                'x', 'o', 'x', 
                'x', 'o', 'x');
 
        assertEquals(draw.result(), TicTacToeWinner.DRAW);
 
    }
 
    public void testNoWinnerYet() throws Exception  {
 
        TicTacToeBoard noOneYet = new TicTacToeBoard('o', 'x', 'o', 
                'x', 'o', 'x', 
                'x', 'o', 'e');
 
        assertEquals(noOneYet.result(), TicTacToeWinner.NO_ONE_YET);
 
 
        //negative slope
        TicTacToeBoard x1 = new TicTacToeBoard('x', 'x', 'o', 
                'o', 'x', 'x', 
                'o', 'o', 'x');
 
        assertNotEquals(x1.result(), TicTacToeWinner.NO_ONE_YET);
 
    }
 
    /**
     * You can mock the <code>TicTacToeBoard</code> in order to test whether
     * validating for a win is done correctly.
     * <p>
     * This mock sets up a board which has o winning through across 2.
     * <p>
     */
    public void testWithMocksAcross() throws Exception  {
 
        final TicTacToeBoard test = new TicTacToeBoard();
        Mockery context = new Mockery();
        context = new Mockery() {
            {
                setImposteriser(ClassImposteriser.INSTANCE);
            }
        };
 
        final TicTacToeBoard board = context.mock(TicTacToeBoard.class);
        context.checking(new Expectations() {
            {
                char [] mockBoard = {'e', 'e', 'x',
                        'o', 'o', 'o',
                        'x', 'x', 'o'
                };
 
                allowing(board);
                will(returnValue(mockBoard));
 
            }
        });
 
        assertEquals(test.result(board), TicTacToeWinner.ACROSS_2);
    }
 
    /**
     * Tests having a board without a winner and empty cells (marked as 'e')
     * returns as no one won yet (and not as a draw).
     */
    public void testWithMocksNotYet() throws Exception  {
        final TicTacToeBoard test = new TicTacToeBoard();
 
        Mockery contextNotYet = new Mockery();
        contextNotYet = new Mockery() {
            {
                setImposteriser(ClassImposteriser.INSTANCE);
            }
        };
 
        final TicTacToeBoard board2 = contextNotYet.mock(TicTacToeBoard.class);
 
        contextNotYet.checking(new Expectations() {
            {
                char [] mockBoard2 = {'e', 'e', 'x',
                        'o', 'o', 'x',
                        'o', 'x', 'o'
                };
 
                allowing(board2);
                will(returnValue(mockBoard2));
 
            }
        });
 
 
        assertEquals(test.result(board2), TicTacToeWinner.NO_ONE_YET);
 
    }
 
}

Category: Code Sample