NastasiaSaby / php7-way

 * Class DivideItTest

 * @package PhpSchool\Php7WayTest\Exercise

 */

class DivideItTest extends PHPUnit_Framework_TestCase

{

    public function testDivideItExercice()

    {

        $e = new DivideIt();

        $this->assertEquals('Divide it', $e->getName());

        $this->assertEquals('Divide a number by another', $e->getDescription());

        $this->assertEquals(ExerciseType::CLI, $e->getType());

        $this->assertEquals([4, 3], $e->getArgs());

        $this->assertInstanceOf(SolutionInterface::class, $e->getSolution());

        $this->assertFileExists(realpath($e->getProblem()));

        $this->assertNull($e->tearDown());

    }

    public function testFunctionRequirements()

    {

        $e = new DivideIt();

        $this->assertEquals(['intdiv'], $e->getRequiredFunctions());

        $this->assertEquals([], $e->getBannedFunctions());

    }

    public function testConfigure()

    {

        $dispatcher = $this->getMockBuilder(ExerciseDispatcher::class)

            ->disableOriginalConstructor()

            ->getMock();

        $dispatcher

            ->expects($this->once())

            ->method('requireCheck')

            ->with(FunctionRequirementsCheck::class);

        $e = new DivideIt();

        $e->configure($dispatcher);

    }

}

 * Class NewGenerationTransferTest

 * @package PhpSchool\Php7WayTest\Exercise

 */

class NewGenerationTransferTest extends PHPUnit_Framework_TestCase

{

    public function testNewGenerationTransferExercise()

    {

        $e = new NewGenerationTransfer();

        $this->assertEquals('The new generation transfers its power', $e->getName());

        $this->assertEquals('Use generators delegating some parts of the algorithm', $e->getDescription());

        $this->assertEquals(ExerciseType::CLI, $e->getType());

        $this->assertEquals(["firstArgument", "secondArgument", "thirdArgument"], $e->getArgs());

        $this->assertInstanceOf(SolutionInterface::class, $e->getSolution());

        $this->assertFileExists(realpath($e->getProblem()));

        $this->assertNull($e->tearDown());

    }

    public function testFunctionRequirements()

    {

        $e = new NewGenerationTransfer();

        $this->assertEquals(['strtoupper'], $e->getRequiredFunctions());

        $this->assertEquals([], $e->getBannedFunctions());

    }

    public function testConfigure()

    {

        $dispatcher = $this->getMockBuilder(ExerciseDispatcher::class)

            ->disableOriginalConstructor()

            ->getMock();

        $dispatcher

            ->expects($this->once())

            ->method('requireCheck')

            ->with(FunctionRequirementsCheck::class);

        $e = new NewGenerationTransfer();

        $e->configure($dispatcher);

    }

}

 * Class NewGenerationTest

 * @package PhpSchool\Php7WayTest\Exercise

 */

class NewGenerationTest extends PHPUnit_Framework_TestCase

{

    public function testNewGenerationExercise()

    {

        $e = new NewGeneration();

        $this->assertEquals('A new generation is coming', $e->getName());

        $this->assertEquals('Develop a generator and use it', $e->getDescription());

        $this->assertEquals(ExerciseType::CLI, $e->getType());

        $this->assertEquals(["firstArgument", "secondArgument", "thirdArgument"], $e->getArgs());

        $this->assertInstanceOf(SolutionInterface::class, $e->getSolution());

        $this->assertFileExists(realpath($e->getProblem()));

        $this->assertNull($e->tearDown());

    }

    public function testFunctionRequirements()

    {

        $e = new NewGeneration();

        $this->assertEquals(['strtoupper'], $e->getRequiredFunctions());

        $this->assertEquals([], $e->getBannedFunctions());

    }

    public function testConfigure()

    {

        $dispatcher = $this->getMockBuilder(ExerciseDispatcher::class)

            ->disableOriginalConstructor()

            ->getMock();

        $dispatcher

            ->expects($this->once())

            ->method('requireCheck')

            ->with(FunctionRequirementsCheck::class);

        $e = new NewGeneration();

        $e->configure($dispatcher);

    }

}

 * Class TypeYourOutputTest

 * @package PhpSchool\Php7WayTest\Exercise

 */

class TypeYourOutputTest extends PHPUnit_Framework_TestCase

{

    public function testTypeYourOutputExercise()

    {

        $e = new TypeYourOutput();

        $this->assertEquals('Type your output!', $e->getName());

        $this->assertEquals('Use types to validate the output of a function', $e->getDescription());

        $this->assertEquals(ExerciseType::CLI, $e->getType());

        $this->assertEquals([1, 2], $e->getArgs());

        $this->assertInstanceOf(SolutionInterface::class, $e->getSolution());

        $this->assertFileExists(realpath($e->getProblem()));

        $this->assertNull($e->tearDown());

    }

    public function testFunctionRequirements()

    {

        $e = new TypeYourOutput();

        $this->assertEquals(['noStrictFunction', 'strictFunction'], $e->getRequiredFunctions());

        $this->assertEquals([], $e->getBannedFunctions());

    }

    public function testConfigure()

    {

        $dispatcher = $this->getMockBuilder(ExerciseDispatcher::class)

            ->disableOriginalConstructor()

            ->getMock();

        $dispatcher

            ->expects($this->once())

            ->method('requireCheck')

            ->with(FunctionRequirementsCheck::class);

        $e = new TypeYourOutput();

        $e->configure($dispatcher);

    }

}

 * Class TypeYourArgumentsTest

 * @package PhpSchool\Php7WayTest\Exercise

 */

class TypeYourArgumentsTest extends PHPUnit_Framework_TestCase

{

    public function testTypeYourArgumentsExercise()

    {

        $e = new TypeYourArguments();

        $this->assertEquals('Type your arguments!', $e->getName());

        $this->assertEquals('Use scalar types with arguments', $e->getDescription());

        $this->assertEquals(ExerciseType::CLI, $e->getType());

        $this->assertEquals([], $e->getArgs());

        $this->assertInstanceOf(SolutionInterface::class, $e->getSolution());

        $this->assertFileExists(realpath($e->getProblem()));

        $this->assertNull($e->tearDown());

    }

    public function testFunctionRequirements()

    {

        $e = new TypeYourArguments();

        $this->assertEquals(['noStrictFunction', 'strictFunction'], $e->getRequiredFunctions());

        $this->assertEquals([], $e->getBannedFunctions());

    }

    public function testConfigure()

    {

        $dispatcher = $this->getMockBuilder(ExerciseDispatcher::class)

            ->disableOriginalConstructor()

            ->getMock();

        $dispatcher

            ->expects($this->once())

            ->method('requireCheck')

            ->with(FunctionRequirementsCheck::class);

        $e = new TypeYourArguments();

        $e->configure($dispatcher);

    }

}