TestCase
********

.[perex]
As afirmações podem seguir uma a uma em testes simples. Mas às vezes é útil incluir as afirmações para testar a classe e estruturá-las desta forma.

A classe deve ser descendente de `Tester\TestCase` e nós falamos sobre isso simplesmente como sobre **testcase***.

```php
use Tester\Assert;

class RectangleTest extends Tester\TestCase
{
	public function testOne()
	{
		Assert::same(/* ... */);
	}

	public function testTwo()
	{
		Assert::match(/* ... */);
	}
}

# Run testing methods
(new RectangleTest)->run();
```

Podemos enriquecer um testcase pelos métodos `setUp()` e `tearDown()`. Eles são chamados antes/depois de cada método de teste:

```php
use Tester\Assert;

class NextTest extends Tester\TestCase
{
	public function setUp()
	{
		# Preparation
	}

	public function tearDown()
	{
		# Clean-up
	}

	public function testOne()
	{
		Assert::same(/* ... */);
	}

	public function testTwo()
	{
		Assert::match(/* ... */);
	}
}

# Run testing methods
(new NextTest)->run();

/*


Method Calls Order
------------------
setUp()
testOne()
tearDown()

setUp()
testTwo()
tearDown()
*/
```

Se o erro ocorrer em uma fase `setUp()` ou `tearDown()`, o teste falhará. Se ocorrer erro no método de teste, o método `tearDown()` é chamado de qualquer forma, mas com erros suprimidos nele.

Recomendamos que você escreva a anotação [@testCase |test-annotations#@testCase] no início do teste, então o executor do teste de linha de comando executará os métodos individuais do teste em processos separados e em paralelo em várias linhas. Isto pode acelerar significativamente todo o processo de teste.

/--php
<?php
/** @testCase */
\--


Anotação de métodos .[#toc-annotation-of-methods]
=================================================

Há algumas anotações disponíveis para nos ajudar com os métodos de teste. Nós as escrevemos para o método de teste.


@throws .[filter]
-----------------
É o mesmo uso de `Assert::exception()` dentro de um método de teste. Mas a notação é mais legível:

```php
/**
 * @throws RuntimeException
 */
public function testOne()
{
	// ...
}


/**
 * @throws LogicException Ordem de argumento errada
 */
public function testTwo()
{
	// ...
}
```


@dataProvider .[filter]
-----------------------
Esta anotação serve quando queremos executar o método de teste várias vezes, mas com argumentos diferentes. (Não confundir com a anotação do mesmo nome para [arquivos |test-annotations#dataProvider]).

Como argumento, escrevemos o nome do método que retorna parâmetros para o método de teste. O método deve retornar um array ou Traversable. Exemplo simples:

```php
public function getLoopArgs()
{
	return [
		[1, 2, 3],
		[4, 5, 6],
		[7, 8, 9],
	];
}


/**
 * @dataProvider getLoopArgs
 */
public function testLoop($a, $b, $c)
{
	// ...
}
```

A outra anotação **@dataProvider** aceita um caminho para o arquivo INI (relativamente ao arquivo de teste) como um argumento. O método é chamado tantas vezes quanto o número de seções contidas no arquivo INI. Arquivo `loop-args.ini`:

```ini
[one]
a=1
b=2
c=3

[two]
a=4
b=5
c=6

[three]
a=7
b=8
c=9
```

e o método que utiliza o arquivo INI:

```php
/**
 * @dataProvider loop-args.ini
 */
public function testLoop($a, $b, $c)
{
	// ...
}
```

Da mesma forma, podemos passar para um script PHP ao invés de INI. Ele deve retornar array ou Traversable. Arquivo `loop-args.php`:

```php
return [
	['a' => 1, 'b' => 2, 'c' => 3],
	['a' => 4, 'b' => 5, 'c' => 6],
	['a' => 7, 'b' => 8, 'c' => 9],
];
```