TestOfDecorator

Complexity

Total Complexity

44

Size/Duplication

Total Lines	344
Duplicated Lines	0 %

Importance

Changes

0

44 Methods

Rating	Name	Duplication	Size	Complexity
A	testSize()	0	5	1
A	testNextSecond()	0	5	1
A	testBuild()	0	6	1
A	testNextMonth()	0	5	1
A	testThisHour()	0	5	1
A	testAdjust()	0	5	1
A	tearDown()	0	3	1
A	testThisMinute()	0	5	1
A	testThisDay()	0	5	1
A	testPrevHour()	0	5	1
A	testNextMinute()	0	5	1
A	testToArray()	0	7	1
A	testNextHour()	0	5	1
A	testThisWeek()	0	7	1
A	testGetEngine()	0	4	1
A	testSetFirst()	0	6	1
A	testPrevYear()	0	5	1
A	testNextYear()	0	5	1
A	testSetTimestamp()	0	5	1
A	__construct()	0	3	1
A	testThisSecond()	0	5	1
A	setUp()	0	24	1
A	testPrevWeek()	0	7	1
A	testSetLast()	0	6	1
A	testIsValid()	0	5	1
A	testSetSelected()	0	5	1
A	testPrevMinute()	0	5	1
A	testIsFirst()	0	6	1
A	testNextDay()	0	5	1
A	testGetValidator()	0	5	1
A	testPrevMonth()	0	5	1
A	testFetchAll()	0	5	1
A	testIsLast()	0	6	1
A	testSetEmpty()	0	6	1
A	testPrevSecond()	0	5	1
A	testFetch()	0	5	1
A	testIsEmpty()	0	6	1
A	testThisYear()	0	5	1
A	testNextWeek()	0	7	1
A	testReturnValue()	0	6	1
A	testIsSelected()	0	5	1
A	testPrevDay()	0	5	1
A	testGetTimestamp()	0	4	1
A	testThisMonth()	0	5	1

<?php

require_once __DIR__ . '/simple_include.php';
require_once __DIR__ . '/calendar_include.php';

Mock::generate('Calendar_Engine_Interface', 'Mock_Calendar_Engine');

The type Mock was not found. Maybe you did not declare it correctly or list all dependencies?

Mock::generate('Calendar_Second', 'Mock_Calendar_Second');
Mock::generate('Calendar_Week', 'Mock_Calendar_Week');
Mock::generate('Calendar_Day', 'Mock_Calendar_Day');

/**
 * Class TestOfDecorator.
 */
class TestOfDecorator extends UnitTestCase

The type UnitTestCase was not found. Maybe you did not declare it correctly or list all dependencies?

{
    public $mockengine;
    public $mockcal;
    public $decorator;

    /**
     * TestOfDecorator constructor.
     */
    public function __construct()
    {
        parent::__construct('Test of Calendar_Decorator');
    }

    protected function setUp()
    {
        $this->mockengine = new Mock_Calendar_Engine($this);

The type Mock_Calendar_Engine was not found. Maybe you did not declare it correctly or list all dependencies?

        $this->mockcal    = new Mock_Calendar_Second($this);

The type Mock_Calendar_Second was not found. Maybe you did not declare it correctly or list all dependencies?

        $this->mockcal->setReturnValue('prevYear', 2002);
        $this->mockcal->setReturnValue('thisYear', 2003);
        $this->mockcal->setReturnValue('nextYear', 2004);
        $this->mockcal->setReturnValue('prevMonth', 9);
        $this->mockcal->setReturnValue('thisMonth', 10);
        $this->mockcal->setReturnValue('nextMonth', 11);
        $this->mockcal->setReturnValue('prevDay', 14);
        $this->mockcal->setReturnValue('thisDay', 15);
        $this->mockcal->setReturnValue('nextDay', 16);
        $this->mockcal->setReturnValue('prevHour', 12);
        $this->mockcal->setReturnValue('thisHour', 13);
        $this->mockcal->setReturnValue('nextHour', 14);
        $this->mockcal->setReturnValue('prevMinute', 29);
        $this->mockcal->setReturnValue('thisMinute', 30);
        $this->mockcal->setReturnValue('nextMinute', 31);
        $this->mockcal->setReturnValue('prevSecond', 44);
        $this->mockcal->setReturnValue('thisSecond', 45);
        $this->mockcal->setReturnValue('nextSecond', 46);
        $this->mockcal->setReturnValue('getEngine', $this->mockengine);
        $this->mockcal->setReturnValue('getTimestamp', 12345);
    }

    protected function tearDown()
    {
        unset($this->engine, $this->mockcal);
    }

    public function testPrevYear()
    {
        $this->mockcal->expectOnce('prevYear', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(2002, $Decorator->prevYear());
    }

    public function testThisYear()
    {
        $this->mockcal->expectOnce('thisYear', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(2003, $Decorator->thisYear());
    }

    public function testNextYear()
    {
        $this->mockcal->expectOnce('nextYear', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(2004, $Decorator->nextYear());
    }

    public function testPrevMonth()
    {
        $this->mockcal->expectOnce('prevMonth', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(9, $Decorator->prevMonth());
    }

    public function testThisMonth()
    {
        $this->mockcal->expectOnce('thisMonth', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(10, $Decorator->thisMonth());
    }

    public function testNextMonth()
    {
        $this->mockcal->expectOnce('nextMonth', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(11, $Decorator->nextMonth());
    }

    public function testPrevWeek()
    {
        $mockweek = new Mock_Calendar_Week($this);

The type Mock_Calendar_Week was not found. Maybe you did not declare it correctly or list all dependencies?

        $mockweek->setReturnValue('prevWeek', 1);
        $mockweek->expectOnce('prevWeek', ['n_in_month']);
        $Decorator = new Calendar_Decorator($mockweek);
        $this->assertEqual(1, $Decorator->prevWeek());
    }

    public function testThisWeek()
    {
        $mockweek = new Mock_Calendar_Week($this);
        $mockweek->setReturnValue('thisWeek', 2);
        $mockweek->expectOnce('thisWeek', ['n_in_month']);
        $Decorator = new Calendar_Decorator($mockweek);
        $this->assertEqual(2, $Decorator->thisWeek());
    }

    public function testNextWeek()
    {
        $mockweek = new Mock_Calendar_Week($this);
        $mockweek->setReturnValue('nextWeek', 3);
        $mockweek->expectOnce('nextWeek', ['n_in_month']);
        $Decorator = new Calendar_Decorator($mockweek);
        $this->assertEqual(3, $Decorator->nextWeek());
    }

    public function testPrevDay()
    {
        $this->mockcal->expectOnce('prevDay', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(14, $Decorator->prevDay());
    }

    public function testThisDay()
    {
        $this->mockcal->expectOnce('thisDay', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(15, $Decorator->thisDay());
    }

    public function testNextDay()
    {
        $this->mockcal->expectOnce('nextDay', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(16, $Decorator->nextDay());
    }

    public function testPrevHour()
    {
        $this->mockcal->expectOnce('prevHour', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(12, $Decorator->prevHour());
    }

    public function testThisHour()
    {
        $this->mockcal->expectOnce('thisHour', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(13, $Decorator->thisHour());
    }

    public function testNextHour()
    {
        $this->mockcal->expectOnce('nextHour', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(14, $Decorator->nextHour());
    }

    public function testPrevMinute()
    {
        $this->mockcal->expectOnce('prevMinute', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(29, $Decorator->prevMinute());
    }

    public function testThisMinute()
    {
        $this->mockcal->expectOnce('thisMinute', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(30, $Decorator->thisMinute());
    }

    public function testNextMinute()
    {
        $this->mockcal->expectOnce('nextMinute', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(31, $Decorator->nextMinute());
    }

    public function testPrevSecond()
    {
        $this->mockcal->expectOnce('prevSecond', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(44, $Decorator->prevSecond());
    }

    public function testThisSecond()
    {
        $this->mockcal->expectOnce('thisSecond', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(45, $Decorator->thisSecond());
    }

    public function testNextSecond()
    {
        $this->mockcal->expectOnce('nextSecond', ['int']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(46, $Decorator->nextSecond());
    }

    public function testGetEngine()
    {
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertIsA($Decorator->getEngine(), 'Mock_Calendar_Engine');
    }

    public function testSetTimestamp()
    {
        $this->mockcal->expectOnce('setTimestamp', ['12345']);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->setTimestamp('12345');
    }

    public function testGetTimestamp()
    {
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual(12345, $Decorator->getTimestamp());
    }

    public function testSetSelected()
    {
        $this->mockcal->expectOnce('setSelected', [true]);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->setSelected();
    }

    public function testIsSelected()
    {
        $this->mockcal->setReturnValue('isSelected', true);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertTrue($Decorator->isSelected());
    }

    public function testAdjust()
    {
        $this->mockcal->expectOnce('adjust', []);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->adjust();
    }

    public function testToArray()
    {
        $this->mockcal->expectOnce('toArray', [12345]);
        $testArray = ['foo' => 'bar'];
        $this->mockcal->setReturnValue('toArray', $testArray);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual($testArray, $Decorator->toArray(12345));
    }

    public function testReturnValue()
    {
        $this->mockcal->expectOnce('returnValue', ['a', 'b', 'c', 'd']);
        $this->mockcal->setReturnValue('returnValue', 'foo');
        $Decorator = new Calendar_Decorator($this->mockcal);
        $this->assertEqual('foo', $Decorator->returnValue('a', 'b', 'c', 'd'));

'd' of type string is incompatible with the type integer expected by parameter $default of Calendar_Decorator::returnValue().

    }

    public function testSetFirst()
    {
        $mockday = new Mock_Calendar_Day($this);

The type Mock_Calendar_Day was not found. Maybe you did not declare it correctly or list all dependencies?

        $mockday->expectOnce('setFirst', [true]);
        $Decorator = new Calendar_Decorator($mockday);
        $Decorator->setFirst();
    }

    public function testSetLast()
    {
        $mockday = new Mock_Calendar_Day($this);
        $mockday->expectOnce('setLast', [true]);
        $Decorator = new Calendar_Decorator($mockday);
        $Decorator->setLast();
    }

    public function testIsFirst()
    {
        $mockday = new Mock_Calendar_Day($this);
        $mockday->setReturnValue('isFirst', true);
        $Decorator = new Calendar_Decorator($mockday);
        $this->assertTrue($Decorator->isFirst());
    }

    public function testIsLast()
    {
        $mockday = new Mock_Calendar_Day($this);
        $mockday->setReturnValue('isLast', true);
        $Decorator = new Calendar_Decorator($mockday);
        $this->assertTrue($Decorator->isLast());
    }

    public function testSetEmpty()
    {
        $mockday = new Mock_Calendar_Day($this);
        $mockday->expectOnce('setEmpty', [true]);
        $Decorator = new Calendar_Decorator($mockday);
        $Decorator->setEmpty();
    }

    public function testIsEmpty()
    {
        $mockday = new Mock_Calendar_Day($this);
        $mockday->setReturnValue('isEmpty', true);
        $Decorator = new Calendar_Decorator($mockday);
        $this->assertTrue($Decorator->isEmpty());
    }

    public function testBuild()
    {
        $testArray = ['foo' => 'bar'];
        $this->mockcal->expectOnce('build', [$testArray]);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->build($testArray);
    }

    public function testFetch()
    {
        $this->mockcal->expectOnce('fetch', []);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->fetch();
    }

    public function testFetchAll()
    {
        $this->mockcal->expectOnce('fetchAll', []);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->fetchAll();
    }

    public function testSize()
    {
        $this->mockcal->expectOnce('size', []);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->size();
    }

    public function testIsValid()
    {
        $this->mockcal->expectOnce('isValid', []);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->isValid();
    }

    public function testGetValidator()
    {
        $this->mockcal->expectOnce('getValidator', []);
        $Decorator = new Calendar_Decorator($this->mockcal);
        $Decorator->getValidator();
    }
}