VariableTest::testGetTypeName() - Code Metrics - Inspection of "Add some tests and support more types for logic op..." - ovr/phpsa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#115)

by Enrico

created 2016-09-10 22:58 UTC

VariableTest::testGetTypeName() B

↳ Parent: VariableTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	21
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	32
rs	8.8571

<?php

namespace Tests\PHPSA;

use PHPSA\CompiledExpression;
use PHPSA\Variable;

class VariableTest extends TestCase
{
    public function testSimpleInstanceWithDefaultValue()
    {
        $variable = new Variable('test', 1, CompiledExpression::INTEGER);

        static::assertSame(CompiledExpression::INTEGER, $variable->getType());
        static::assertSame('test', $variable->getName());
        static::assertSame(1, $variable->getValue());
        static::assertSame(0, $variable->getGets());

        /**
         * it's one via default value is present
         */
        static::assertSame(1, $variable->getSets());
    }

    public function testIsNumericMethodIntSuccess()
    {
        $variable = new Variable('a', 1, CompiledExpression::INTEGER);
        static::assertTrue($variable->isNumeric());
    }

    public function testIsNumericMethodDoubleSuccess()
    {
        $variable = new Variable('a', 1, CompiledExpression::DOUBLE);
        static::assertTrue($variable->isNumeric());
    }

    public function testIsNumericMethodFalseOnBoolean()
    {
        $variable = new Variable('a', 1, CompiledExpression::BOOLEAN);
        static::assertFalse($variable->isNumeric());
    }

    public function testIncValue()
    {
        $variable = new Variable('a', 1, CompiledExpression::INTEGER);
        static::assertSame(1, $variable->getValue());

        $variable->inc();
        static::assertSame(2, $variable->getValue());

        $variable->inc();
        static::assertSame(3, $variable->getValue());

        $variable->inc();
        $variable->inc();
        static::assertSame(5, $variable->getValue());
    }

    public function testDecValue()
    {
        $variable = new Variable('a', 1, CompiledExpression::INTEGER);
        static::assertSame(1, $variable->getValue());

        $variable->dec();
        static::assertSame(0, $variable->getValue());

        $variable->dec();
        static::assertSame(-1, $variable->getValue());

        $variable->dec();
        $variable->dec();
        static::assertSame(-3, $variable->getValue());
    }

    public function testIncUse()
    {
        $variable = new Variable('a', null, CompiledExpression::UNKNOWN);
        static::assertSame(0, $variable->getGets());
        static::assertSame(0, $variable->getSets());

        $variable->incUse();
        static::assertSame(1, $variable->getGets());
        static::assertSame(1, $variable->getSets());

        $variable->incUse();
        static::assertSame(2, $variable->getGets());
        static::assertSame(2, $variable->getSets());

        $variable->incUse();
        $variable->incUse();
        static::assertSame(4, $variable->getGets());
        static::assertSame(4, $variable->getSets());
    }

    public function testIncSets()
    {
        $variable = new Variable('a', null, CompiledExpression::UNKNOWN);
        static::assertSame(0, $variable->getSets());

        $variable->incSets();
        static::assertSame(1, $variable->getSets());

        $variable->incSets();
        static::assertSame(2, $variable->getSets());

        $variable->incSets();
        $variable->incSets();
        static::assertSame(4, $variable->getSets());
    }

    public function testIncGets()
    {
        $variable = new Variable('a', null, CompiledExpression::UNKNOWN);
        static::assertSame(0, $variable->getGets());

        $variable->incGets();
        static::assertSame(1, $variable->getGets());

        $variable->incGets();
        static::assertSame(2, $variable->getGets());

        $variable->incGets();
        $variable->incGets();
        static::assertSame(4, $variable->getGets());
    }

    public function testModifyType()
    {
        $variable = new Variable('a', 1, CompiledExpression::INTEGER);
        static::assertSame(CompiledExpression::INTEGER, $variable->getType());

        $newType = CompiledExpression::BOOLEAN;
        $variable->modifyType($newType);
        static::assertSame($newType, $variable->getType());
    }

    public function testIsUnusedTrue()
    {
        $variable = new Variable('a', 1, CompiledExpression::INTEGER);
        static::assertTrue($variable->isUnused());

        $variable = new Variable('a', null, CompiledExpression::UNKNOWN);
        $variable->incSets();
        static::assertTrue($variable->isUnused());
    }

    public function testIsUnusedFalse()
    {
        $variable = new Variable('a', null, CompiledExpression::UNKNOWN);
        static::assertFalse($variable->isUnused());
    }

    public function testReferenceToChange()
    {
        /**
         * $a = 1;
         * $b = &$a;
         */
        $parentVariable = new Variable('a', 1, CompiledExpression::INTEGER);
        $variable = new Variable('b', $parentVariable->getValue(), $parentVariable->getType());

        static::assertFalse($variable->isReferenced());
        $variable->setReferencedTo($parentVariable);
        static::assertTrue($variable->isReferenced());
        static::assertSame($parentVariable, $variable->getReferencedTo());

        /**
         * $b = 55.00
         */
        $variable->modify(CompiledExpression::DOUBLE, 55.00);

        static::assertSame($variable->getValue(), $parentVariable->getValue());
        static::assertSame($variable->getType(), $parentVariable->getType());
    }

    public function testGetTypeName()
    {
        $int = new Variable('a', 1, CompiledExpression::INTEGER);
        parent::assertSame("integer", $int->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $double = new Variable('b', 1, CompiledExpression::DOUBLE);
        parent::assertSame("double", $double->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $number = new Variable('c', 1, CompiledExpression::NUMBER);
        parent::assertSame("number", $number->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $arr = new Variable('d', [1,2], CompiledExpression::ARR);
        parent::assertSame("array", $arr->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $object = new Variable('e', 1, CompiledExpression::OBJECT);
        parent::assertSame("object", $object->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $resource = new Variable('f', 1, CompiledExpression::RESOURCE);
        parent::assertSame("resource", $resource->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $callable = new Variable('g', 1, CompiledExpression::CALLABLE_TYPE);
        parent::assertSame("callable", $callable->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $boolean = new Variable('h', 1, CompiledExpression::BOOLEAN);
        parent::assertSame("boolean", $boolean->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $null = new Variable('i', 1, CompiledExpression::NULL);
        parent::assertSame("null", $null->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $unknown = new Variable('j', 1, CompiledExpression::UNKNOWN);
        parent::assertSame("unknown", $unknown->getTypeName());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
    }
}


1			<?php
2
3			namespace Tests\PHPSA;
4
5			use PHPSA\CompiledExpression;
6			use PHPSA\Variable;
7
8			class VariableTest extends TestCase
9			{
10			public function testSimpleInstanceWithDefaultValue()
11			{
12			$variable = new Variable('test', 1, CompiledExpression::INTEGER);
13
14			static::assertSame(CompiledExpression::INTEGER, $variable->getType());
15			static::assertSame('test', $variable->getName());
16			static::assertSame(1, $variable->getValue());
17			static::assertSame(0, $variable->getGets());
18
19			/**
20			* it's one via default value is present
21			*/
22			static::assertSame(1, $variable->getSets());
23			}
24
25			public function testIsNumericMethodIntSuccess()
26			{
27			$variable = new Variable('a', 1, CompiledExpression::INTEGER);
28			static::assertTrue($variable->isNumeric());
29			}
30
31			public function testIsNumericMethodDoubleSuccess()
32			{
33			$variable = new Variable('a', 1, CompiledExpression::DOUBLE);
34			static::assertTrue($variable->isNumeric());
35			}
36
37			public function testIsNumericMethodFalseOnBoolean()
38			{
39			$variable = new Variable('a', 1, CompiledExpression::BOOLEAN);
40			static::assertFalse($variable->isNumeric());
41			}
42
43			public function testIncValue()
44			{
45			$variable = new Variable('a', 1, CompiledExpression::INTEGER);
46			static::assertSame(1, $variable->getValue());
47
48			$variable->inc();
49			static::assertSame(2, $variable->getValue());
50
51			$variable->inc();
52			static::assertSame(3, $variable->getValue());
53
54			$variable->inc();
55			$variable->inc();
56			static::assertSame(5, $variable->getValue());
57			}
58
59			public function testDecValue()
60			{
61			$variable = new Variable('a', 1, CompiledExpression::INTEGER);
62			static::assertSame(1, $variable->getValue());
63
64			$variable->dec();
65			static::assertSame(0, $variable->getValue());
66
67			$variable->dec();
68			static::assertSame(-1, $variable->getValue());
69
70			$variable->dec();
71			$variable->dec();
72			static::assertSame(-3, $variable->getValue());
73			}
74
75			public function testIncUse()
76			{
77			$variable = new Variable('a', null, CompiledExpression::UNKNOWN);
78			static::assertSame(0, $variable->getGets());
79			static::assertSame(0, $variable->getSets());
80
81			$variable->incUse();
82			static::assertSame(1, $variable->getGets());
83			static::assertSame(1, $variable->getSets());
84
85			$variable->incUse();
86			static::assertSame(2, $variable->getGets());
87			static::assertSame(2, $variable->getSets());
88
89			$variable->incUse();
90			$variable->incUse();
91			static::assertSame(4, $variable->getGets());
92			static::assertSame(4, $variable->getSets());
93			}
94
95			public function testIncSets()
96			{
97			$variable = new Variable('a', null, CompiledExpression::UNKNOWN);
98			static::assertSame(0, $variable->getSets());
99
100			$variable->incSets();
101			static::assertSame(1, $variable->getSets());
102
103			$variable->incSets();
104			static::assertSame(2, $variable->getSets());
105
106			$variable->incSets();
107			$variable->incSets();
108			static::assertSame(4, $variable->getSets());
109			}
110
111			public function testIncGets()
112			{
113			$variable = new Variable('a', null, CompiledExpression::UNKNOWN);
114			static::assertSame(0, $variable->getGets());
115
116			$variable->incGets();
117			static::assertSame(1, $variable->getGets());
118
119			$variable->incGets();
120			static::assertSame(2, $variable->getGets());
121
122			$variable->incGets();
123			$variable->incGets();
124			static::assertSame(4, $variable->getGets());
125			}
126
127			public function testModifyType()
128			{
129			$variable = new Variable('a', 1, CompiledExpression::INTEGER);
130			static::assertSame(CompiledExpression::INTEGER, $variable->getType());
131
132			$newType = CompiledExpression::BOOLEAN;
133			$variable->modifyType($newType);
134			static::assertSame($newType, $variable->getType());
135			}
136
137			public function testIsUnusedTrue()
138			{
139			$variable = new Variable('a', 1, CompiledExpression::INTEGER);
140			static::assertTrue($variable->isUnused());
141
142			$variable = new Variable('a', null, CompiledExpression::UNKNOWN);
143			$variable->incSets();
144			static::assertTrue($variable->isUnused());
145			}
146
147			public function testIsUnusedFalse()
148			{
149			$variable = new Variable('a', null, CompiledExpression::UNKNOWN);
150			static::assertFalse($variable->isUnused());
151			}
152
153			public function testReferenceToChange()
154			{
155			/**
156			* $a = 1;
157			* $b = &$a;
158			*/
159			$parentVariable = new Variable('a', 1, CompiledExpression::INTEGER);
160			$variable = new Variable('b', $parentVariable->getValue(), $parentVariable->getType());
161
162			static::assertFalse($variable->isReferenced());
163			$variable->setReferencedTo($parentVariable);
164			static::assertTrue($variable->isReferenced());
165			static::assertSame($parentVariable, $variable->getReferencedTo());
166
167			/**
168			* $b = 55.00
169			*/
170			$variable->modify(CompiledExpression::DOUBLE, 55.00);
171
172			static::assertSame($variable->getValue(), $parentVariable->getValue());
173			static::assertSame($variable->getType(), $parentVariable->getType());
174			}
175
176			public function testGetTypeName()
177			{
178			$int = new Variable('a', 1, CompiledExpression::INTEGER);
179			parent::assertSame("integer", $int->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
180
181			$double = new Variable('b', 1, CompiledExpression::DOUBLE);
182			parent::assertSame("double", $double->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
183
184			$number = new Variable('c', 1, CompiledExpression::NUMBER);
185			parent::assertSame("number", $number->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
186
187			$arr = new Variable('d', [1,2], CompiledExpression::ARR);
188			parent::assertSame("array", $arr->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
189
190			$object = new Variable('e', 1, CompiledExpression::OBJECT);
191			parent::assertSame("object", $object->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
192
193			$resource = new Variable('f', 1, CompiledExpression::RESOURCE);
194			parent::assertSame("resource", $resource->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
195
196			$callable = new Variable('g', 1, CompiledExpression::CALLABLE_TYPE);
197			parent::assertSame("callable", $callable->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
198
199			$boolean = new Variable('h', 1, CompiledExpression::BOOLEAN);
200			parent::assertSame("boolean", $boolean->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
201
202			$null = new Variable('i', 1, CompiledExpression::NULL);
203			parent::assertSame("null", $null->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
204
205			$unknown = new Variable('j', 1, CompiledExpression::UNKNOWN);
206			parent::assertSame("unknown", $unknown->getTypeName());
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-10 23:08 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`assertSame()` instead of `testGetTypeName()`). Are you sure this is correct? If so, you might want to change this to `$this->assertSame()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
207			}
208			}
209

ovr / phpsa

Pull Request — master (#115)

VariableTest::testGetTypeName() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like