StrucFlagsTest::testRtro() - Code Metrics - itafroma/zork-php - Measure and Improve Code Quality continuously with Scrutinizer

StrucFlagsTest::testRtro() A
last analyzed 2016-05-08 20:15 UTC

↳ Parent: StrucFlagsTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	1

Metric	Value
cc	1
eloc	4
nc	1
nop	2
dl	0
loc	7
rs	9.4285
c	1
b	1
f	1

<?php

/**
 * @file
 * Tests for struc bit field testing functions.
 */

namespace Itafroma\Zork\Tests;

use Itafroma\Zork\Struc\Adv;
use Itafroma\Zork\Struc\Object;
use Itafroma\Zork\Struc\Room;
use Itafroma\Zork\Struc\Syntax;
use \PHPUnit_Framework_TestCase;
use function Itafroma\Zork\atrz;
use function Itafroma\Zork\atro;
use function Itafroma\Zork\atrnn;
use function Itafroma\Zork\gtrnn;
use function Itafroma\Zork\rtrc;
use function Itafroma\Zork\rtrnn;
use function Itafroma\Zork\rtro;
use function Itafroma\Zork\rtrz;
use function Itafroma\Zork\strnn;
use function Itafroma\Zork\trnn;
use function Itafroma\Zork\trc;
use function Itafroma\Zork\tro;
use function Itafroma\Zork\trz;

class StrucFlagsTest extends PHPUnit_Framework_TestCase
{
    /**
     * Tests Itafroma\Zork\trnn().
     *
     * @covers ::Itafroma\Zork\trnn
     * @dataProvider objectFlagsProvider
     */
    public function testTrnn($obj, $bit)
    {
        $obj->oflags = $bit;

        $this->assertTrue(trnn($obj, $bit));
    }

    /**
     * Tests Itafroam\Zork\rtrnn().
     *
     * @covers ::Itafroma\Zork\rtrnn
     * @dataProvider roomFlagsProvider
     */
    public function testRtrnn($rm, $bit)
    {
        $rm->rbits = $bit;

        $this->assertTrue(rtrnn($rm, $bit));
    }

    /**
     * Tests Itafroam\Zork\gtrnn().
     *
     * @covers ::Itafroma\Zork\gtrnn
     * @dataProvider roomFlagsProvider
     */
    public function testGtrnn($rm, $bit)
    {
        $rm->rglobal = $bit;

        $this->assertTrue(gtrnn($rm, $bit));
    }

    /**
     * Tests Itafroma\Zork\rtrz().
     *
     * @covers ::Itafroma\Zork\rtrz
     * @dataProvider roomFlagsProvider
     */
    public function testRtrz($rm, $bit)
    {
        $rm->rbits = $bit;
        $return = rtrz($rm, $bit);

        $this->assertEquals($rm->rbits, $return);
        $this->assertEquals($rm->rbits, 0);
    }

    /**
     * Tests Itafroma\Zork\trc().
     *
     * @covers ::Itafroma\Zork\trc
     * @dataProvider objectFlagsProvider
     */
    public function testTrc($obj, $bit)
    {
        $obj->oflags = $bit;
        $return = trc($obj, $bit);

        $this->assertEquals($obj->oflags, $return);
        $this->assertEquals($obj->oflags, 0);
    }

    /**
     * Tests Itafroma\Zork\trz().
     *
     * @covers ::Itafroma\Zork\trz
     * @dataProvider objectFlagsProvider
     */
    public function testTrz($obj, $bit)
    {
        $obj->oflags = $bit;
        $return = trz($obj, $bit);

        $this->assertEquals($obj->oflags, $return);
        $this->assertEquals($obj->oflags, 0);
    }

    /**
     * Tests Itafroma\Zork\tro().
     *
     * @covers ::Itafroma\Zork\tro
     * @dataProvider objectFlagsProvider
     */
    public function testTro($obj, $bit)
    {
        $return = tro($obj, $bit);

        $this->assertEquals($obj->oflags, $return);
        $this->assertEquals($obj->oflags, $bit);
    }

    /**
     * Tests Itafroma\Zork\rtro().
     *
     * @covers ::Itafroma\Zork\rtro
     * @dataProvider roomFlagsProvider
     */
    public function testRtro($rm, $bit)
    {
        $return = rtro($rm, $bit);

        $this->assertEquals($rm->rbits, $return);
        $this->assertEquals($rm->rbits, $bit);
    }

    /**
     * Tests Itafroma\Zork\rtrc().
     *
     * @covers ::Itafroma\Zork\rtrc
     * @dataProvider roomFlagsProvider
     */
    public function testRtrc($rm, $bit)
    {
        $rm->rbits = $bit;
        $return = rtrc($rm, $bit);

        $this->assertEquals($rm->rbits, $return);
        $this->assertEquals($rm->rbits, 0);
    }

    /**
     * Tests Itafroma\Zork\atrnn().
     *
     * @covers ::Itafroma\Zork\atrnn
     * @dataProvider advFlagsProvider()
     */
    public function testAtrnn($adv, $bit)
    {
        $adv->aflags = $bit;

        $this->assertTrue(atrnn($adv, $bit));
    }

    /**
     * Tests Itafroma\Zork\atrz().
     *
     * @covers ::Itafroma\Zork\atrz
     * @dataProvider advFlagsProvider
     */
    public function testAtrz($adv, $bit)
    {
        $adv->aflags = $bit;
        $return = atrz($adv, $bit);

        $this->assertEquals($adv->aflags, $return);
        $this->assertEquals($adv->aflags, 0);
    }

    /**
     * Tests Itafroma\Zork\atro().
     *
     * @covers ::Itafroma\Zork\atro
     * @dataProvider advFlagsProvider
     */
    public function testAtro($adv, $bit)
    {
        $return = atro($adv, $bit);

        $this->assertEquals($adv->aflags, $return);
        $this->assertEquals($adv->aflags, $bit);
    }

    /**
     * Tests Itafroma\Zork\strnn().
     *
     * @covers ::Itafroma\Zork\strnn
     * @dataProvider syntaxFlagsProvider()
     */
    public function testStrnn($syntax, $bit)
    {
        $syntax->sflags = $bit;

        $this->assertTrue(strnn($syntax, $bit));
    }


    /**
     * Provides objects (items) and a test flag.
     */
    public function objectFlagsProvider()
    {
        return [
            [new Object(), 1 << 2],
        ];
    }

    /**
     * Provides rooms and a test flag.
     */
    public function roomFlagsProvider()
    {
        return [
            [new Room(), 1 << 2],
        ];
    }

    /**
     * Provides adventurers and a test flag.
     */
    public function advFlagsProvider()
    {
        return [
            [new Adv(), 1 << 2],
        ];
    }

    /**
     * Provides syntaxes and a test flag.
     */
    public function syntaxFlagsProvider()
    {
        return [
            [new Syntax(), 1 << 2],
        ];
    }
}


1			<?php
2
3			/**
4			* @file
5			* Tests for struc bit field testing functions.
6			*/
7
8			namespace Itafroma\Zork\Tests;
9
10			use Itafroma\Zork\Struc\Adv;
11			use Itafroma\Zork\Struc\Object;
12			use Itafroma\Zork\Struc\Room;
13			use Itafroma\Zork\Struc\Syntax;
14			use \PHPUnit_Framework_TestCase;
15			use function Itafroma\Zork\atrz;
16			use function Itafroma\Zork\atro;
17			use function Itafroma\Zork\atrnn;
18			use function Itafroma\Zork\gtrnn;
19			use function Itafroma\Zork\rtrc;
20			use function Itafroma\Zork\rtrnn;
21			use function Itafroma\Zork\rtro;
22			use function Itafroma\Zork\rtrz;
23			use function Itafroma\Zork\strnn;
24			use function Itafroma\Zork\trnn;
25			use function Itafroma\Zork\trc;
26			use function Itafroma\Zork\tro;
27			use function Itafroma\Zork\trz;
28
29			class StrucFlagsTest extends PHPUnit_Framework_TestCase
30			{
31			/**
32			* Tests Itafroma\Zork\trnn().
33			*
34			* @covers ::Itafroma\Zork\trnn
35			* @dataProvider objectFlagsProvider
36			*/
37			public function testTrnn($obj, $bit)
38			{
39			$obj->oflags = $bit;
40
41			$this->assertTrue(trnn($obj, $bit));
42			}
43
44			/**
45			* Tests Itafroam\Zork\rtrnn().
46			*
47			* @covers ::Itafroma\Zork\rtrnn
48			* @dataProvider roomFlagsProvider
49			*/
50			public function testRtrnn($rm, $bit)
51			{
52			$rm->rbits = $bit;
53
54			$this->assertTrue(rtrnn($rm, $bit));
55			}
56
57			/**
58			* Tests Itafroam\Zork\gtrnn().
59			*
60			* @covers ::Itafroma\Zork\gtrnn
61			* @dataProvider roomFlagsProvider
62			*/
63			public function testGtrnn($rm, $bit)
64			{
65			$rm->rglobal = $bit;
66
67			$this->assertTrue(gtrnn($rm, $bit));
68			}
69
70			/**
71			* Tests Itafroma\Zork\rtrz().
72			*
73			* @covers ::Itafroma\Zork\rtrz
74			* @dataProvider roomFlagsProvider
75			*/
76			public function testRtrz($rm, $bit)
77			{
78			$rm->rbits = $bit;
79			$return = rtrz($rm, $bit);
80
81			$this->assertEquals($rm->rbits, $return);
82			$this->assertEquals($rm->rbits, 0);
83			}
84
85			/**
86			* Tests Itafroma\Zork\trc().
87			*
88			* @covers ::Itafroma\Zork\trc
89			* @dataProvider objectFlagsProvider
90			*/
91			public function testTrc($obj, $bit)
92			{
93			$obj->oflags = $bit;
94			$return = trc($obj, $bit);
95
96			$this->assertEquals($obj->oflags, $return);
97			$this->assertEquals($obj->oflags, 0);
98			}
99
100			/**
101			* Tests Itafroma\Zork\trz().
102			*
103			* @covers ::Itafroma\Zork\trz
104			* @dataProvider objectFlagsProvider
105			*/
106			public function testTrz($obj, $bit)
107			{
108			$obj->oflags = $bit;
109			$return = trz($obj, $bit);
110
111			$this->assertEquals($obj->oflags, $return);
112			$this->assertEquals($obj->oflags, 0);
113			}
114
115			/**
116			* Tests Itafroma\Zork\tro().
117			*
118			* @covers ::Itafroma\Zork\tro
119			* @dataProvider objectFlagsProvider
120			*/
121			public function testTro($obj, $bit)
122			{
123			$return = tro($obj, $bit);
124
125			$this->assertEquals($obj->oflags, $return);
126			$this->assertEquals($obj->oflags, $bit);
127			}
128
129			/**
130			* Tests Itafroma\Zork\rtro().
131			*
132			* @covers ::Itafroma\Zork\rtro
133			* @dataProvider roomFlagsProvider
134			*/
135			public function testRtro($rm, $bit)
136			{
137			$return = rtro($rm, $bit);
138
139			$this->assertEquals($rm->rbits, $return);
140			$this->assertEquals($rm->rbits, $bit);
141			}
142
143			/**
144			* Tests Itafroma\Zork\rtrc().
145			*
146			* @covers ::Itafroma\Zork\rtrc
147			* @dataProvider roomFlagsProvider
148			*/
149			public function testRtrc($rm, $bit)
150			{
151			$rm->rbits = $bit;
152			$return = rtrc($rm, $bit);
153
154			$this->assertEquals($rm->rbits, $return);
155			$this->assertEquals($rm->rbits, 0);
156			}
157
158			/**
159			* Tests Itafroma\Zork\atrnn().
160			*
161			* @covers ::Itafroma\Zork\atrnn
162			* @dataProvider advFlagsProvider()
163			*/
164			public function testAtrnn($adv, $bit)
165			{
166			$adv->aflags = $bit;
167
168			$this->assertTrue(atrnn($adv, $bit));
169			}
170
171			/**
172			* Tests Itafroma\Zork\atrz().
173			*
174			* @covers ::Itafroma\Zork\atrz
175			* @dataProvider advFlagsProvider
176			*/
177			public function testAtrz($adv, $bit)
178			{
179			$adv->aflags = $bit;
180			$return = atrz($adv, $bit);
181
182			$this->assertEquals($adv->aflags, $return);
183			$this->assertEquals($adv->aflags, 0);
184			}
185
186			/**
187			* Tests Itafroma\Zork\atro().
188			*
189			* @covers ::Itafroma\Zork\atro
190			* @dataProvider advFlagsProvider
191			*/
192			public function testAtro($adv, $bit)
193			{
194			$return = atro($adv, $bit);
195
196			$this->assertEquals($adv->aflags, $return);
197			$this->assertEquals($adv->aflags, $bit);
198			}
199
200			/**
201			* Tests Itafroma\Zork\strnn().
202			*
203			* @covers ::Itafroma\Zork\strnn
204			* @dataProvider syntaxFlagsProvider()
205			*/
206			public function testStrnn($syntax, $bit)
207			{
208			$syntax->sflags = $bit;
209
210			$this->assertTrue(strnn($syntax, $bit));
211			}
212
213
214			/**
215			* Provides objects (items) and a test flag.
216			*/
217			public function objectFlagsProvider()
218			{
219			return [
220			[new Object(), 1 << 2],
221			];
222			}
223
224			/**
225			* Provides rooms and a test flag.
226			*/
227			public function roomFlagsProvider()
228			{
229			return [
230			[new Room(), 1 << 2],
231			];
232			}
233
234			/**
235			* Provides adventurers and a test flag.
236			*/
237			public function advFlagsProvider()
238			{
239			return [
240			[new Adv(), 1 << 2],
241			];
242			}
243
244			/**
245			* Provides syntaxes and a test flag.
246			*/
247			public function syntaxFlagsProvider()
248			{
249			return [
250			[new Syntax(), 1 << 2],
251			];
252			}
253			}
254

itafroma / zork-php

StrucFlagsTest::testRtro() A last analyzed 2016-05-08 20:15 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

StrucFlagsTest::testRtro() A
last analyzed 2016-05-08 20:15 UTC