Zend Framework University

And I believe Lars Tesmer has done the latter, where he blogs on testing PHPUnit itself and the lessons learned in that process.

Thank you Lars for sharing your lessons.

In this fourth part we should focus on playing the game. Let’s go over the steps again:

• each player chooses a symbol
• for each turn (max 9 turns)
• a player places his symbol on the grid
• if 3 symbols appear in a single row (horizontal, vertical or diagonal)
• player is a winner

So this is a simple and a straightforward rule we can turn into code. But let’s look at the tests we’ve written in part 1 to see if they’re still valid.

    public function testGameCanBePlayed()    {        $playerX = $this->_ttt->getPlayers()->seek(0)->current();        $playerO = $this->_ttt->getPlayers()->seek(1)->current();

        $this->assertFalse($this->_ttt->play(0, 0, $playerX));        $this->assertFalse($this->_ttt->play(0, 1, $playerX));        $this->assertTrue($this->_ttt->play(0, 2, $playerX));

        $this->_ttt->setGrid(new Grid());

        $this->assertFalse($this->_ttt->play(0, 0, $playerX));        $this->assertFalse($this->_ttt->play(1, 0, $playerX));        $this->assertTrue($this->_ttt->play(2, 0, $playerX));

        $this->_ttt->setGrid(new Grid());

        $this->assertFalse($this->_ttt->play(0, 0, $playerX));        $this->assertFalse($this->_ttt->play(1, 1, $playerX));        $this->assertTrue($this->_ttt->play(2, 2, $playerX));

        $this->_ttt->setGrid(new Grid());

        $this->assertFalse($this->_ttt->play(0, 2, $playerX));        $this->assertFalse($this->_ttt->play(1, 1, $playerX));        $this->assertTrue($this->_ttt->play(2, 0, $playerX));    }

As you see, we only tested the functionality to see if we can have a winner when 3 identical symbols appear in a single row horizontal, vertical or diagonal. We can make a couple of comments on this test:

• this test is named wrong as it doesn’t test the gameplay functionality
• this test should be branched out into different tests for each row
• this test doesn’t test turn-by-turn game play

In other words, we need to clean this up and come up with better tests! Let’s focus on tearing this test into 3 separate tests, testing just a single direction. Again, we can use a dataProvider method for this.

    public function rowColProvider()    {        return array (            array (array (array (0,0), array (0,1), array (0,2))),            array (array (array (0,0), array (1,0), array (2,0))),            array (array (array (0,0), array (1,1), array (2,2))),            array (array (array (0,2), array (1,1), array (2,0))),        );    }    /**     * @dataProvider rowColProvider     */    public function testGameplayCanDetectWinner($rowCols)    {        $player = $this->_ttt->getPlayers()->seek(0)->current();        $this->assertFalse($this->_ttt->play($rowCols[0][0], $rowCols[0][1], $player));        $this->assertFalse($this->_ttt->play($rowCols[1][0], $rowCols[1][1], $player));        $this->assertTrue($this->_ttt->play($rowCols[2][0], $rowCols[2][1], $player));    }

Now we know that with each turn, the return value will indicate if we have a winner (TRUE) or not (FALSE). But we still need to see if we can have the same result when playing with two players. As you see with the last line, the third entry gives us a positive result.

But we still don’t have a gameplay going! We need to have two players enter the arena and each player playing turn by turn. So how do we approach this? Well, the easiest way for now is to create a test that does just that. The benefit here is we can decide which player is going to win the game.

    public function testGameCanBePlayed()    {        $playerX = $this->_ttt->getPlayers()->seek(0)->current();        $playerO = $this->_ttt->getPlayers()->seek(1)->current();        $this->assertFalse($this->_ttt->play(0, 0, $playerX));        $this->assertFalse($this->_ttt->play(0, 1, $playerO));        $this->assertFalse($this->_ttt->play(1, 1, $playerX));        $this->assertFalse($this->_ttt->play(2, 2, $playerO));        $this->assertFalse($this->_ttt->play(1, 0, $playerX));        $this->assertFalse($this->_ttt->play(2, 0, $playerO));        $this->assertTrue($this->_ttt->play(1, 2, $playerX));    }

Visual this result looks like the following grid:

 X | O |    X | X | X  O |   | O 

But most importantly our tests are still green, giving us that wonderful feeling of achievement.

Let’s finish up our tests so we can see no one can play any further after we’ve got a winner. PHPUnit provides a nice anotation we can use for this: depends. So now we can test that the game is stopped, depending on our test “testGameCanBePlayed”.
For this to work, we need to return our game (in this case $this->_ttt). Just add the following line at the bottom of the test class “testGameCanBePlayed”.

    public function testGameCanBePlayed()    {        $playerX = $this->_ttt->getPlayers()->seek(0)->current();        $playerO = $this->_ttt->getPlayers()->seek(1)->current();        $this->assertFalse($this->_ttt->play(0, 0, $playerX));        $this->assertFalse($this->_ttt->play(0, 1, $playerO));        $this->assertFalse($this->_ttt->play(1, 1, $playerX));        $this->assertFalse($this->_ttt->play(2, 2, $playerO));        $this->assertFalse($this->_ttt->play(1, 0, $playerX));        $this->assertFalse($this->_ttt->play(2, 0, $playerO));        $this->assertTrue($this->_ttt->play(1, 2, $playerX));        return $this->_ttt;    }

And the next step is simple:

    /**     * @depends testGameCanBePlayed     * @expectedException RuntimeException     */    public function testGameStopsAfterWinning($game)    {        $playerO = $game->getPlayers()->seek(1)->current();        $game->play(2,1, $playerO);    }

In order for this test to succeed we need to add a couple of things to our game:

• a status property that will tell us if there’s a winner
• a setter method to flip the flag once a winner is detected
• a checking method to verify a winner is not yet detected
• modify our play method so it throws a RuntimeException when we try to play when a winner exists.

<?php...

class Tictactoe{    ...

    /**     * Status indicator to say there's a winner or not     *      * @var bool     */    protected $_winner = false;

    ...

    /**     * Sets a flag to indicate this game has a winner     *      * @param bool $flag     * @return Tictactoe     */    public function setWinner($flag = true)    {        $this->_winner = $flag;        return $this;    }    /**     * Checks if the game has a winner     *      * @return bool     */    public function hasWinner()    {        return $this->_winner;    }    /**     * Plays the game and returns TRUE if a player has become a winner, FALSE     * if the player is not (yet) a winner.     *      * @param int $row     * @param int $column     * @param Player $player     * @return bool     * @throws RuntimeException     */    public function play($row, $column, Player $player)    {        if ($this->hasWinner()) {            throw new RuntimeException('Game already has a winner');        }        $this->getGrid()->setSymbol($row, $column, $player->getSymbol());        return $this->isWinner($player);    }    /**     * Returns TRUE if a player has become a winner, FALSE if not.     *      * @param Player $player     * @return bool     */    public function isWinner(Player $player)    {        if ($this->getGrid()->inRow($player->getSymbol())) {            $this->setWinner();            return true;        }        if ($this->getGrid()->inColumn($player->getSymbol())) {            $this->setWinner();            return true;        }        if ($this->getGrid()->inDiagonal($player->getSymbol())) {            $this->setWinner();            return true;        }        return false;    }}

That’s it. We covered the main purpose of the game and we did it semi test driven. We can start playing a cute little game of Tictactoe and covered a couple important features of PHPUnit. I also showed that it’s not a bad thing if you modify parts of your tests to achieve new or other specifications.

The full game source code can be found on my github account (https://github.com/DragonBe/tictactoe), and as you go over the log, you can follow along with these series as well. When playing with the source code, you might think about testing edge cases: playing 9 rounds and no winner, try to place a symbol off the grid, place twice a symbol on the grid of a single player (cheating), and so on.

Another thing could be that you turn this little game into an online game. What are the things you need to concider in that situation. Are our tests still valid or do we need to modify our architecture and our tests to support that kind of game playing?

Since it’s on GitHub, you can fork it and send me a pull request once you have an edge case figured out.

Our tests tell us we have four classes:

• Tictactoe: the main class that is responsible for the game and how it should be played
• Grid: is the class that’s responsible for setting up the playing grid
• Players: a collection class containing both player objects
• Player: the class defining a single player

Our first test concerns all about the grid we’re going to use. Here’s the test again:

    public function testGameGridIsSetAtStart()    {        $grid = $this->_ttt->getGrid();        $this->assertInstanceOf('Grid', $grid);        $this->assertEquals(3, count($grid->getRows()));        foreach ($grid->getRows() as $row) {            $this->assertInternalType('array', $row);            $this->assertEquals(3, count($row));            $this->assertNull($row[0]);            $this->assertNull($row[1]);            $this->assertNull($row[2]);        }    }   

What can we learn from this test?

• Grid is part of our main TicTacToe class
• has a method that fetches rows of type array
• and each row has columns as an array

We can also make the following assumptions:

• Grid class will instantiate a grid with 3 rows and 3 columns
• When calling “getRows()” we retrieve an array of 3 columns
• Each field in the grid will have a null value as a default
• A Player must have a way to set his “symbol” on a specific position on the grid
• Must have a way to verify if a given symbol exists in either a horizontal, a vertical or a diagonal row

With this information we can start writing our Grid class

<?php/** * TicTacToe *  * A simple game that's played with two players, each taking a turn by marking * a field in a grid of 3 x 3 with either an X or an O (one symbol per player). * Winner is the one who has 3 identical symbols in a single horizontal, * vertical or diagonal row. *  * @package Tictactoe * @license "Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)" * @link http://creativecommons.org/licenses/by-sa/3.0/ *//** * Grid *  * This Grid class is responsible to set up and maintain the playing field *  * @package Tictactoe * @category Tictactoe * */class Grid{    /**     * Constant to define the number of rows     * @var int     */    const ROWS = 3;    /**     * Constant to define the number of colomns     * @var int     */    const COLS = 3;    /**     * Container for all rows and columns     *      * @var array     */    protected $_rows = array ();    /**     * Constructor for this Grid class that will set up our grid with 3 rows     * and 3 columns while setting the value of each field to NULL     */    public function __construct()    {        for ($i = 0; $i < self::ROWS; $i++) {            $columns = array ();            for ($j = 0; $j < self::COLS; $j++) {                $columns[$j] = null;            }            $this->addRow($columns);        }    }    /**     * Adds a row to the grid, requiring an array of 3 fields representing     * the columns     *      * @param array $row     * @return Grid     */    public function addRow(array $row)    {        $this->_rows[] = $row;        return $this;    }    /**     * Retrieves all rows from this grid, including an array for the columns     * for each row     *      * @return array     */    public function getRows()    {        return $this->_rows;    }    /**     * Sets the symbol for each field     *      * @param int $row The position of the field in the row     * @param int $column The position of the field in the column     * @param string $symbol     */    public function setSymbol($row, $column, $symbol)    {        $this->_rows[$row][$column] = $symbol;        return $this;    }    /**     * Retrieves the current symbol from a given cordinate on the grid     *      * @param int $row The postion of the field in the row     * @param int $column The position of the field in the column     * @return string     */    public function getSymbol($row, $column)    {        return $this->_rows[$row][$column];    }    /**     * Validation method to verify if a given symbol is found 3 times in a     * single row. If we have 3 matches, it will return TRUE. In all other     * cases it will return FALSE.     *      * @param string $symbol     * @return boolean     */    public function inRow($symbol)    {        foreach ($this->getRows() as $row) {            $match = 0;            foreach ($row as $column) {                if ($symbol === $column) {                    $match++;                }            }            if (self::ROWS === $match) {                return true;            }        }        return false;    }    /**     * Validation method to verify if a given symbol is found 3 times in a     * single column. If we have 3 matches, it will return TRUE. In all other     * cases it will return FALSE.     *      * @param string $symbol     * @return boolean     */    public function inColumn($symbol)    {        for ($i = 0; $i < self::COLS; $i++) {            $match = 0;            for ($j = 0; $j < self::ROWS; $j++) {                if ($symbol === $this->_rows[$j][$i]) {                    $match++;                }            }            if (self::COLS === $match) {                return true;            }        }        return false;    }    /**     * Validation method to verify if a given symbol is found 3 times in a     * single diagonal row. If we have 3 matches, it will return TRUE. In all      * other cases it will return FALSE.     *      * @param string $symbol     * @return boolean     */    public function inDiagonal($symbol)    {        $match1 = $match2 = 0;        for ($i = 0; $i < self::ROWS; $i++) {            if ($symbol === $this->_rows[$i][$i]) {                $match1++;            }            if ($symbol === $this->_rows[$i][self::COLS - 1 - $i]) {                $match2++;            }        }        if (self::ROWS === $match1 || self::ROWS === $match2) {            return true;        }        return false;    }}    

Now we have a grid class, but we cannot test it properly as we use a Tictactoe class to validate everything. No problem, we can modify our tests as well to better serve our needs. Actually, we already have defined our test criteria. Let’s list them again:

• Grid is part of our main TicTacToe class (is not really relevant for our Grid functionality)
• has a method that fetches rows of type array
• and each row has columns as an array
• Grid class will instantiate a grid with 3 rows and 3 columns
• When calling “getRows()” we retrieve an array of 3 rows with each 3 columns
• Each field in the grid will have a null value as a default
• A Player must have a way to set his “symbol” on a specific position on the grid
• Must have a way to verify if a given symbol exists in either a horizontal, a vertical or a diagonal row

The first four criterea we already addressed in our general Tictactoe test case. To separate responsibilities, we can move our test case from our main TictactoeTest class into a GridTest class.

<?phpclass GridTest extends PHPUnit_Framework_TestCase{    const TEST_SYMBOL = 'X';

    protected $_grid;

    protected function setUp()    {        $this->_grid = new Grid();        parent::setUp();    }    protected function tearDown()    {        parent::tearDown();        $this->_grid = null;    }    public function testGameGridIsSetAtStart()    {        $this->assertEquals(Grid::ROWS, count($this->_grid->getRows()));        foreach ($this->_grid->getRows() as $row) {            $this->assertInternalType('array', $row);            $this->assertEquals(Grid::COLS, count($row));            foreach ($row as $column) {                $this->assertNull($column);            }        }    }}

So now we have exactly the same as before, except we created a separate TestCase specifically designed for Grid related tests. This allows us to follow up on issues people might report later on (things we haven’t thought of or just don’t know yet), as we can write now a specific test for our Grid.

But we’re not there yet, we still have 2 more things to verify: positioning of a symbol and verifying we have a 3 identical symbols in any of the three rows, columns or diagonal rows.

Let’s look at our test verifying the positioning of a symbol:

    public function testGridCanPositionASymbol()    {        $this->_grid->setSymbol(0, 0, self::TEST_SYMBOL);        $this->assertNotNull($this->_grid->getSymbol(0,0));        $this->assertEquals(self::TEST_SYMBOL, $this->_grid->getSymbol(0,0));    }

But as you see, this is not really working for us. We can only ferify just one position on the grid and if we want to test more positions, our test method would grow exponentionally. Say hello to the “dataProvider”

    public function cordinateProvider()    {        return array (            array (0,0), array (0,1), array (0,2), array (1,0), array (1,1),            array (1,2), array (2,0), array (2,1), array (2,2),        );    }    /**     * @dataProvider cordinateProvider     */    public function testGridCanPositionASymbol($row, $column)    {        $this->_grid->setSymbol($row, $column, self::TEST_SYMBOL);        $this->assertNotNull($this->_grid->getSymbol($row, $column));        $this->assertEquals(self::TEST_SYMBOL, $this->_grid->getSymbol($row, $column));    }

The @dataProvider tag in your codeblock comment tells PHPUnit to use the method specified by this tag as a “provider” of data. Each row in this data provider method (as it returns an array of arrays) will be a provisioner for your test class, and for each row, your test will be executed from a clean state, so you don’t have any corruption due to bad resetting of your objects.

Hey, now we can also use this to verify if we have 3 identical symbols in a horizontal, vertical or diagonal row! Let’s work that out as well.

    protected function _setDataOnGrid($data)    {        foreach ($data as $field) {            list ($row, $column) = $field;            $this->_grid->setSymbol($row, $column, self::TEST_SYMBOL);        }    }    public function horizontalRowProvider()    {        return array (            array (array (array (0,0), array (0,1), array (0,2))),            array (array (array (1,0), array (1,1), array (1,2))),            array (array (array (2,0), array (2,1), array (2,2))),        );    }    /**     * @dataProvider horizontalRowProvider     */    public function testGridHasThreeSymbolsInARow($data)    {        $this->_setDataOnGrid($data);        $this->assertTrue($this->_grid->inRow(self::TEST_SYMBOL));    }    public function VerticalRowProvider()    {        return array (            array (array (array (0,0), array (1,0), array (2,0))),            array (array (array (0,1), array (1,1), array (2,1))),            array (array (array (0,2), array (1,2), array (2,2))),        );    }    /**     * @dataProvider VerticalRowProvider     */    public function testGridHasThreeSymbolsInAColumn($data)    {        $this->_setDataOnGrid($data);        $this->assertTrue($this->_grid->inColumn(self::TEST_SYMBOL));    }    public function DiagonalRowProvider()    {        return array (            array (array (array (0,0), array (1,1), array (2,2))),            array (array (array (0,2), array (1,1), array (2,0))),        );    }    /**     * @dataProvider DiagonalRowProvider     */    public function testGridHasThreeSymbolsInADiagonal($data)    {        $this->_setDataOnGrid($data);        $this->assertTrue($this->_grid->inDiagonal(self::TEST_SYMBOL));    }

Oh, Wow! We now have a complete Grid test case that isolates all Grid related tasks and responsibilities.

<?phpclass GridTest extends PHPUnit_Framework_TestCase{    const TEST_SYMBOL = 'X';

    protected $_grid;

    protected function setUp()    {        $this->_grid = new Grid();        parent::setUp();    }    protected function tearDown()    {        parent::tearDown();        $this->_grid = null;    }    public function testGameGridIsSetAtStart()    {        $this->assertEquals(Grid::ROWS, count($this->_grid->getRows()));        foreach ($this->_grid->getRows() as $row) {            $this->assertInternalType('array', $row);            $this->assertEquals(Grid::COLS, count($row));            foreach ($row as $column) {                $this->assertNull($column);            }        }    }    public function cordinateProvider()    {        return array (            array (0,0), array (0,1), array (0,2), array (1,0), array (1,1),            array (1,2), array (2,0), array (2,1), array (2,2),        );    }    /**     * @dataProvider cordinateProvider     */    public function testGridCanPositionASymbol($row, $column)    {        $this->_grid->setSymbol($row, $column, self::TEST_SYMBOL);        $this->assertNotNull($this->_grid->getSymbol($row, $column));        $this->assertEquals(self::TEST_SYMBOL, $this->_grid->getSymbol($row, $column));    }    protected function _setDataOnGrid($data)    {        foreach ($data as $field) {            list ($row, $column) = $field;            $this->_grid->setSymbol($row, $column, self::TEST_SYMBOL);        }    }    public function horizontalRowProvider()    {        return array (            array (array (array (0,0), array (0,1), array (0,2))),            array (array (array (1,0), array (1,1), array (1,2))),            array (array (array (2,0), array (2,1), array (2,2))),        );    }    /**     * @dataProvider horizontalRowProvider     */    public function testGridHasThreeSymbolsInARow($data)    {        $this->_setDataOnGrid($data);        $this->assertTrue($this->_grid->inRow(self::TEST_SYMBOL));    }    public function VerticalRowProvider()    {        return array (            array (array (array (0,0), array (1,0), array (2,0))),            array (array (array (0,1), array (1,1), array (2,1))),            array (array (array (0,2), array (1,2), array (2,2))),        );    }    /**     * @dataProvider VerticalRowProvider     */    public function testGridHasThreeSymbolsInAColumn($data)    {        $this->_setDataOnGrid($data);        $this->assertTrue($this->_grid->inColumn(self::TEST_SYMBOL));    }    public function DiagonalRowProvider()    {        return array (            array (array (array (0,0), array (1,1), array (2,2))),            array (array (array (0,2), array (1,1), array (2,0))),        );    }    /**     * @dataProvider DiagonalRowProvider     */    public function testGridHasThreeSymbolsInADiagonal($data)    {        $this->_setDataOnGrid($data);        $this->assertTrue($this->_grid->inDiagonal(self::TEST_SYMBOL));    }}

Running this test along with our initial TictactoeTest should result in a warm, fuzzy, green feeling when you see this screen:

Next time, let’s look at our Players as the need also some respect, right.

[editorial] As I cannot summarize the whole usage of phpunit in one blogpost, this will be a sequence of several articles that will pick up a specific task you want to cover with phpunit.

Installation

Well, first of all you need to have PHPUnit installed on your system. The easiest way to accomplish this is to use the PEAR installer.

user@server: $ pear channel-discover pear.phpunit.de

user@server: $ pear channel-discover components.ez.no

user@server: $ pear channel-discover pear.symfony-project.com

Once you’ve got the right channels, you can install the framework:

user@server: $ pear install phpunit/PHPUnit

Configuration

You can use three methods to configure the way PHPUnit executes tests on your project:

• a configuration file
• command line parameters
• a combination of both

Using a configuration file called “phpunit.xml” is by far the easiest way to run your unit tests in a consistent and organized way. It’s a simple XML configuration file and the following works for me most of the times.

NOTE: I use phpunit with a configuration file that matches my project settings, so you might need to modify these settings if you’re using a framework or have a different source code layout.

<phpunit bootstrap=”./TestHelper.php” colors=”true”>

    <testsuite name=”Unit test suite”>

        <directory>./</directory>

    </testsuite>

    <filter>

        <whitelist>

            <directory suffix=”.php”>../src/</directory>

        </whitelist>

    </filter>

</phpunit>

This simple configuration file has 3 major parts:

1. The phpunit configuration tag

This tag starts the complete configuration, but also includes a bootstrap file (for bootstrapping your application like Zend Framework’s bootstrapper class) and enables colors to show green, yellow and red colored bars to indicate the status of your tests. Since I’m a fan of a warm, fuzzy feeling whenever I see green, I enable this by default.

2. Testsuite section

The testsuite is a wrapper that bundles all your tests into a single suite, so you can call it immediately at execution. You can provide it with a name and a directory.

This section is very useful if you have multiple sections in your projects that you want to separate, as you can define the test suites based on their paths on the filesystem.

3. Filtering

Filtering allows you to quickly define what needs to be tested and what needs to be excluded. In my case I need just to investigate my Zend Framework application path and my custom library path. I also want to exclude all my templates as they don’t contain any logic.

You can add also a section for logging where you can define code coverage reports (requires XDebug), a testdox progress report and other kinds of reports provided by PHPUnit. But since I will transfer these tasks to another tool, I’m not going to discuss it here.

I also use a bootstrap file for phpunit called TestHelper.php that allows me to “bootstrap” my test suite. This bootstrap file sets my defined constants, include paths, timezone and error reporting levels.

This is a very minimalistic bootstrapper:

<?php

// file: tests/TestHelper.php

// set our app paths and environments

define(‘BASE_PATH’, realpath(dirname(__FILE__) . ‘/../’));

define(‘APPLICATION_PATH’, BASE_PATH . ‘/src’);

define(‘TEST_PATH’, BASE_PATH . ‘/tests’);

define(‘APPLICATION_ENV’, ‘testing’);

// Include path

set_include_path(

    ‘.’

    . PATH_SEPARATOR . BASE_PATH . ‘/src’

    . PATH_SEPARATOR . get_include_path()

);

// Set the default timezone !!!

date_default_timezone_set(‘Europe/Brussels’);

// We wanna catch all errors en strict warnings

error_reporting(E_ALL|E_STRICT);

So how do you start?

Testing is really simple but for most people the complexity of having code testing other code and just report back if it’s working or not is a bit confusing for people that haven’t written any tests before.

For the most part, in my professional career I get a lot of excuses like “no time”, “no budget” or “no interest”. If it’s truly such a big problem to cope with something as simple as writing a test, a career change might be in order. And I mean it. I believe that if you’re serious about your job, you have to take a little responsibility in it. And writing tests is not that hard.

Let’s begin with a classic example: a tic-tac-toe game. This is a simple pen-and-paper game for two players (O and X) that uses a grid of 3 by 3. The purpose of the game is to have a row, a column or a diagonal row filled with only O’s or X’s. More information can be found at http://en.wikipedia.org/wiki/Tic-tac-toe.

source: http://en.wikipedia.org/wiki/File:Tic-tac-toe-game-1.png

So how do you start with this kind of a game? Very simple: define the objects, the rules and the goal of this game in a list that makes sense to you. I like to define it as follows:

• objects:
  • symbol X for user 1
  • symbol Y for user 2
  • play grid of 3 rows by 3 columns
• rules:
  • write your symbol once for each turn within the grid
• goal:
  • prevent opponent to win
  • win by having 3 symbols on a single row, a single column or a single diagonal row

Since I have tendency to write my tests before I write the code, as it allows me to think about what I expect I should get from class methods. Another benefit is that you write smaller classes with methods that just do what needs to be done.