UnusedLocalVariableTest::testRuleDoesNotApplyToUnusedLocalVariableInMethod() - Code Metrics - SomeBlackMagic/phpmd - Measure and Improve Code Quality continuously with Scrutinizer

testRuleDoesNotApplyToUnusedLocalVariableInMethod() A
last analyzed 2019-11-06 10:20 UTC

↳ Parent: UnusedLocalVariableTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
dl	0
loc	7
rs	10
c	0
b	0
f	0

<?php
/**
 * This file is part of PHP Mess Detector.
 *
 * Copyright (c) Manuel Pichler <[email protected]>.
 * All rights reserved.
 *
 * Licensed under BSD License
 * For full copyright and license information, please see the LICENSE file.
 * Redistributions of files must retain the above copyright notice.
 *
 * @author Manuel Pichler <[email protected]>
 * @copyright Manuel Pichler. All rights reserved.
 * @license https://opensource.org/licenses/bsd-license.php BSD License
 * @link http://phpmd.org/
 */

namespace PHPMD\Rule;

use PHPMD\AbstractTest;

/**
 * Test case for the unused local variable rule.
 *
 * @covers \PHPMD\Rule\UnusedLocalVariable
 * @covers \PHPMD\Rule\AbstractLocalVariable
 */
class UnusedLocalVariableTest extends AbstractTest
{
    /**
     * testRuleAppliesToUnusedLocalVariable
     *
     * @return void
     */
    public function testRuleAppliesToUnusedLocalVariable()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getMethod());
    }

    /**
     * testInnerFunctionParametersDoNotHideUnusedVariables
     *
     * @return void
     */
    public function testInnerFunctionParametersDoNotHideUnusedVariables()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getFunction());
    }

    /**
     * testRuleAppliesToLocalVariableWithSameNameAsStaticProperty
     *
     * <code>
     * class Foo
     *     protected $baz = 42;
     *     function bar() {
     *         $baz = 23;
     *         return self::$baz;
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleAppliesToLocalVariableWithSameNameAsStaticProperty()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleAppliesToLocalVariableWithSameNameAsStaticArrayProperty
     *
     * <code>
     * class Foo
     *     protected $baz = array(array(1=>42));
     *     function bar() {
     *         $baz = 23;
     *         return self::$baz[0][1];
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleAppliesToLocalVariableWithSameNameAsStaticArrayProperty()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesApplyToCompoundVariableInString
     *
     * <code>
     * class Foo
     *     function bar() {
     *         $baz = 23;
     *         return "${baz}_wibble";
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesApplyToCompoundVariableInString()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToLocalVariableUsedInCompoundVariable
     *
     * <code>
     * class Foo {
     *     protected static $bar = 42;
     *     public function baz()
     *     {
     *         $name = 'bar';
     *         return self::${$name};
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesNotApplyToLocalVariableUsedInCompoundVariable()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToThisVariable
     *
     * @return void
     */
    public function testRuleDoesNotApplyToThisVariable()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToStaticProperty
     *
     * @return void
     */
    public function testRuleDoesNotApplyToStaticProperty()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToStaticArrayProperty
     *
     * @return void
     */
    public function testRuleDoesNotApplyToStaticArrayProperty()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToMethodArgument
     *
     * <code>
     * class Foo {
     *     function bar() {
     *         $baz = 42;
     *         $this->foo($baz);
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesNotApplyToMethodArgument()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToStaticObjectProperty
     *
     * @return void
     */
    public function testRuleDoesNotApplyToStaticObjectProperty()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToDynamicProperty
     *
     * @return void
     */
    public function testRuleDoesNotApplyToDynamicProperty()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToUnusedParameters
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedParameters()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToArgcSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToArgcSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToArgvSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToArgvSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToGlobalsSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToGlobalsSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToCookieSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToCookieSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToEnvSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToEnvSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToFilesSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToFilesSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToGetSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToGetSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToPostSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToPostSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToRequestSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToRequestSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToSessionSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToSessionSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToServerSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToServerSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToHttpRawPostDataSuperGlobal
     *
     * @return void
     */
    public function testRuleDoesNotApplyToHttpRawPostDataSuperGlobal()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToUnusedLocalVariableInFunction
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedLocalVariableInFunction()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getFunction());
    }

    /**
     * testRuleDoesNotApplyToUnusedLocalVariableInMethod
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedLocalVariableInMethod()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToLocalVariableUsedAsArrayIndex
     *
     * <code>
     * class Foo {
     *     public function bar() {
     *         foreach ($baz as $key) {
     *             self::$values[$key] = 42;
     *         }
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesNotApplyToLocalVariableUsedAsArrayIndex()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleAppliesToUnusedForeachKeyWhenNotIgnored
     *
     * @return void
     */
    public function testRuleAppliesToUnusedForeachKeyWhenNotIgnored()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleAppliesToUnusedForeachValueWhenNotIgnored
     *
     * @return void
     */
    public function testRuleAppliesToUnusedForeachValueWhenNotIgnored()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToUnusedForeachKeyWhenIgnored
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedForeachKeyWhenIgnored()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'true');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToUnusedForeachKeyWhenWhitelisted
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedForeachKeyWhenWhitelisted()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->addProperty('exceptions', '_');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotAppliesToWhitelistedUnusedLocaleVariable
     *
     * @return void
     */
    public function testRuleDoesNotAppliesToWhitelistedUnusedLocaleVariable()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->addProperty('exceptions', '_');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleStillAppliesWhenSomeUnusedLocaleAreWhitelisted
     *
     * @return void
     */
    public function testRuleStillAppliesWhenSomeUnusedLocaleAreWhitelisted()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->addProperty('exceptions', '_');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToUnusedForeachValueWhenIgnored
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedForeachValueWhenIgnored()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'true');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToLocalVariableUsedAsStringIndex
     *
     * <code>
     * class Foo {
     *     public function bar() {
     *         foreach ($baz as $key) {
     *             self::$string{$key} = 'a';
     *         }
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesNotApplyToLocalVariableUsedAsStringIndex()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToCatchStatement
     *
     * <code>
     * class Foo {
     *     public function bar() {
     *         try {
     *         } catch (Exception $e) {
     *         }
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesNotApplyToCatchStatement()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToCompactFunction
     *
     * <code>
     * class Foo {
     *     public function bar() {
     *         $key = 'ok';
     *         return compact('key');
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesNotApplyToCompactFunction()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * @return void
     * @since 2.0.0
     */
    public function testCompactFunctionRuleWorksCaseInsensitive()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToNamespacedCompactFunction
     *
     * <code>
     * namespace Baz;
     *
     * class Foo {
     *     public function bar() {
     *         $key = 'ok';
     *         return compact('key');
     *     }
     * }
     * </code>
     *
     * @return void
     */
    public function testRuleDoesNotApplyToNamespacedCompactFunction()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * @return void
     * @since 2.0.1
     */
    public function testNamespacedCompactFunctionRuleWorksCaseInsensitive()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(0));
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleNotAppliesToPredefinedVariables.php
     *
     * @return void
     */
    public function testRuleNotAppliesToPredefinedVariables()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportMock(1));
        $rule->apply($this->getMethod());
    }
}


1			<?php
2			/**
3			* This file is part of PHP Mess Detector.
4			*
5			* Copyright (c) Manuel Pichler <[email protected]>.
6			* All rights reserved.
7			*
8			* Licensed under BSD License
9			* For full copyright and license information, please see the LICENSE file.
10			* Redistributions of files must retain the above copyright notice.
11			*
12			* @author Manuel Pichler <[email protected]>
13			* @copyright Manuel Pichler. All rights reserved.
14			* @license https://opensource.org/licenses/bsd-license.php BSD License
15			* @link http://phpmd.org/
16			*/
17
18			namespace PHPMD\Rule;
19
20			use PHPMD\AbstractTest;
21
22			/**
23			* Test case for the unused local variable rule.
24			*
25			* @covers \PHPMD\Rule\UnusedLocalVariable
26			* @covers \PHPMD\Rule\AbstractLocalVariable
27			*/
28			class UnusedLocalVariableTest extends AbstractTest
29			{
30			/**
31			* testRuleAppliesToUnusedLocalVariable
32			*
33			* @return void
34			*/
35			public function testRuleAppliesToUnusedLocalVariable()
36			{
37			$rule = new UnusedLocalVariable();
38			$rule->addProperty('allow-unused-foreach-variables', 'false');
39			$rule->setReport($this->getReportMock(1));
40			$rule->apply($this->getMethod());
41			}
42
43			/**
44			* testInnerFunctionParametersDoNotHideUnusedVariables
45			*
46			* @return void
47			*/
48			public function testInnerFunctionParametersDoNotHideUnusedVariables()
49			{
50			$rule = new UnusedLocalVariable();
51			$rule->addProperty('allow-unused-foreach-variables', 'false');
52			$rule->setReport($this->getReportMock(1));
53			$rule->apply($this->getFunction());
54			}
55
56			/**
57			* testRuleAppliesToLocalVariableWithSameNameAsStaticProperty
58			*
59			* <code>
60			* class Foo
61			* protected $baz = 42;
62			* function bar() {
63			* $baz = 23;
64			* return self::$baz;
65			* }
66			* }
67			* </code>
68			*
69			* @return void
70			*/
71			public function testRuleAppliesToLocalVariableWithSameNameAsStaticProperty()
72			{
73			$rule = new UnusedLocalVariable();
74			$rule->addProperty('allow-unused-foreach-variables', 'false');
75			$rule->setReport($this->getReportMock(1));
76			$rule->apply($this->getMethod());
77			}
78
79			/**
80			* testRuleAppliesToLocalVariableWithSameNameAsStaticArrayProperty
81			*
82			* <code>
83			* class Foo
84			* protected $baz = array(array(1=>42));
85			* function bar() {
86			* $baz = 23;
87			* return self::$baz[0][1];
88			* }
89			* }
90			* </code>
91			*
92			* @return void
93			*/
94			public function testRuleAppliesToLocalVariableWithSameNameAsStaticArrayProperty()
95			{
96			$rule = new UnusedLocalVariable();
97			$rule->addProperty('allow-unused-foreach-variables', 'false');
98			$rule->setReport($this->getReportMock(1));
99			$rule->apply($this->getMethod());
100			}
101
102			/**
103			* testRuleDoesApplyToCompoundVariableInString
104			*
105			* <code>
106			* class Foo
107			* function bar() {
108			* $baz = 23;
109			* return "${baz}_wibble";
110			* }
111			* }
112			* </code>
113			*
114			* @return void
115			*/
116			public function testRuleDoesApplyToCompoundVariableInString()
117			{
118			$rule = new UnusedLocalVariable();
119			$rule->addProperty('allow-unused-foreach-variables', 'false');
120			$rule->setReport($this->getReportMock(0));
121			$rule->apply($this->getMethod());
122			}
123
124			/**
125			* testRuleDoesNotApplyToLocalVariableUsedInCompoundVariable
126			*
127			* <code>
128			* class Foo {
129			* protected static $bar = 42;
130			* public function baz()
131			* {
132			* $name = 'bar';
133			* return self::${$name};
134			* }
135			* }
136			* </code>
137			*
138			* @return void
139			*/
140			public function testRuleDoesNotApplyToLocalVariableUsedInCompoundVariable()
141			{
142			$rule = new UnusedLocalVariable();
143			$rule->addProperty('allow-unused-foreach-variables', 'false');
144			$rule->setReport($this->getReportMock(0));
145			$rule->apply($this->getMethod());
146			}
147
148			/**
149			* testRuleDoesNotApplyToThisVariable
150			*
151			* @return void
152			*/
153			public function testRuleDoesNotApplyToThisVariable()
154			{
155			$rule = new UnusedLocalVariable();
156			$rule->addProperty('allow-unused-foreach-variables', 'false');
157			$rule->setReport($this->getReportMock(0));
158			$rule->apply($this->getMethod());
159			}
160
161			/**
162			* testRuleDoesNotApplyToStaticProperty
163			*
164			* @return void
165			*/
166			public function testRuleDoesNotApplyToStaticProperty()
167			{
168			$rule = new UnusedLocalVariable();
169			$rule->addProperty('allow-unused-foreach-variables', 'false');
170			$rule->setReport($this->getReportMock(0));
171			$rule->apply($this->getMethod());
172			}
173
174			/**
175			* testRuleDoesNotApplyToStaticArrayProperty
176			*
177			* @return void
178			*/
179			public function testRuleDoesNotApplyToStaticArrayProperty()
180			{
181			$rule = new UnusedLocalVariable();
182			$rule->addProperty('allow-unused-foreach-variables', 'false');
183			$rule->setReport($this->getReportMock(0));
184			$rule->apply($this->getMethod());
185			}
186
187			/**
188			* testRuleDoesNotApplyToMethodArgument
189			*
190			* <code>
191			* class Foo {
192			* function bar() {
193			* $baz = 42;
194			* $this->foo($baz);
195			* }
196			* }
197			* </code>
198			*
199			* @return void
200			*/
201			public function testRuleDoesNotApplyToMethodArgument()
202			{
203			$rule = new UnusedLocalVariable();
204			$rule->addProperty('allow-unused-foreach-variables', 'false');
205			$rule->setReport($this->getReportMock(0));
206			$rule->apply($this->getMethod());
207			}
208
209			/**
210			* testRuleDoesNotApplyToStaticObjectProperty
211			*
212			* @return void
213			*/
214			public function testRuleDoesNotApplyToStaticObjectProperty()
215			{
216			$rule = new UnusedLocalVariable();
217			$rule->addProperty('allow-unused-foreach-variables', 'false');
218			$rule->setReport($this->getReportMock(0));
219			$rule->apply($this->getMethod());
220			}
221
222			/**
223			* testRuleDoesNotApplyToDynamicProperty
224			*
225			* @return void
226			*/
227			public function testRuleDoesNotApplyToDynamicProperty()
228			{
229			$rule = new UnusedLocalVariable();
230			$rule->addProperty('allow-unused-foreach-variables', 'false');
231			$rule->setReport($this->getReportMock(0));
232			$rule->apply($this->getMethod());
233			}
234
235			/**
236			* testRuleDoesNotApplyToUnusedParameters
237			*
238			* @return void
239			*/
240			public function testRuleDoesNotApplyToUnusedParameters()
241			{
242			$rule = new UnusedLocalVariable();
243			$rule->addProperty('allow-unused-foreach-variables', 'false');
244			$rule->setReport($this->getReportMock(0));
245			$rule->apply($this->getMethod());
246			}
247
248			/**
249			* testRuleDoesNotApplyToArgcSuperGlobal
250			*
251			* @return void
252			*/
253			public function testRuleDoesNotApplyToArgcSuperGlobal()
254			{
255			$rule = new UnusedLocalVariable();
256			$rule->addProperty('allow-unused-foreach-variables', 'false');
257			$rule->setReport($this->getReportMock(0));
258			$rule->apply($this->getMethod());
259			}
260
261			/**
262			* testRuleDoesNotApplyToArgvSuperGlobal
263			*
264			* @return void
265			*/
266			public function testRuleDoesNotApplyToArgvSuperGlobal()
267			{
268			$rule = new UnusedLocalVariable();
269			$rule->addProperty('allow-unused-foreach-variables', 'false');
270			$rule->setReport($this->getReportMock(0));
271			$rule->apply($this->getMethod());
272			}
273
274			/**
275			* testRuleDoesNotApplyToGlobalsSuperGlobal
276			*
277			* @return void
278			*/
279			public function testRuleDoesNotApplyToGlobalsSuperGlobal()
280			{
281			$rule = new UnusedLocalVariable();
282			$rule->addProperty('allow-unused-foreach-variables', 'false');
283			$rule->setReport($this->getReportMock(0));
284			$rule->apply($this->getMethod());
285			}
286
287			/**
288			* testRuleDoesNotApplyToCookieSuperGlobal
289			*
290			* @return void
291			*/
292			public function testRuleDoesNotApplyToCookieSuperGlobal()
293			{
294			$rule = new UnusedLocalVariable();
295			$rule->addProperty('allow-unused-foreach-variables', 'false');
296			$rule->setReport($this->getReportMock(0));
297			$rule->apply($this->getMethod());
298			}
299
300			/**
301			* testRuleDoesNotApplyToEnvSuperGlobal
302			*
303			* @return void
304			*/
305			public function testRuleDoesNotApplyToEnvSuperGlobal()
306			{
307			$rule = new UnusedLocalVariable();
308			$rule->addProperty('allow-unused-foreach-variables', 'false');
309			$rule->setReport($this->getReportMock(0));
310			$rule->apply($this->getMethod());
311			}
312
313			/**
314			* testRuleDoesNotApplyToFilesSuperGlobal
315			*
316			* @return void
317			*/
318			public function testRuleDoesNotApplyToFilesSuperGlobal()
319			{
320			$rule = new UnusedLocalVariable();
321			$rule->addProperty('allow-unused-foreach-variables', 'false');
322			$rule->setReport($this->getReportMock(0));
323			$rule->apply($this->getMethod());
324			}
325
326			/**
327			* testRuleDoesNotApplyToGetSuperGlobal
328			*
329			* @return void
330			*/
331			public function testRuleDoesNotApplyToGetSuperGlobal()
332			{
333			$rule = new UnusedLocalVariable();
334			$rule->addProperty('allow-unused-foreach-variables', 'false');
335			$rule->setReport($this->getReportMock(0));
336			$rule->apply($this->getMethod());
337			}
338
339			/**
340			* testRuleDoesNotApplyToPostSuperGlobal
341			*
342			* @return void
343			*/
344			public function testRuleDoesNotApplyToPostSuperGlobal()
345			{
346			$rule = new UnusedLocalVariable();
347			$rule->addProperty('allow-unused-foreach-variables', 'false');
348			$rule->setReport($this->getReportMock(0));
349			$rule->apply($this->getMethod());
350			}
351
352			/**
353			* testRuleDoesNotApplyToRequestSuperGlobal
354			*
355			* @return void
356			*/
357			public function testRuleDoesNotApplyToRequestSuperGlobal()
358			{
359			$rule = new UnusedLocalVariable();
360			$rule->addProperty('allow-unused-foreach-variables', 'false');
361			$rule->setReport($this->getReportMock(0));
362			$rule->apply($this->getMethod());
363			}
364
365			/**
366			* testRuleDoesNotApplyToSessionSuperGlobal
367			*
368			* @return void
369			*/
370			public function testRuleDoesNotApplyToSessionSuperGlobal()
371			{
372			$rule = new UnusedLocalVariable();
373			$rule->addProperty('allow-unused-foreach-variables', 'false');
374			$rule->setReport($this->getReportMock(0));
375			$rule->apply($this->getMethod());
376			}
377
378			/**
379			* testRuleDoesNotApplyToServerSuperGlobal
380			*
381			* @return void
382			*/
383			public function testRuleDoesNotApplyToServerSuperGlobal()
384			{
385			$rule = new UnusedLocalVariable();
386			$rule->addProperty('allow-unused-foreach-variables', 'false');
387			$rule->setReport($this->getReportMock(0));
388			$rule->apply($this->getMethod());
389			}
390
391			/**
392			* testRuleDoesNotApplyToHttpRawPostDataSuperGlobal
393			*
394			* @return void
395			*/
396			public function testRuleDoesNotApplyToHttpRawPostDataSuperGlobal()
397			{
398			$rule = new UnusedLocalVariable();
399			$rule->addProperty('allow-unused-foreach-variables', 'false');
400			$rule->setReport($this->getReportMock(0));
401			$rule->apply($this->getMethod());
402			}
403
404			/**
405			* testRuleDoesNotApplyToUnusedLocalVariableInFunction
406			*
407			* @return void
408			*/
409			public function testRuleDoesNotApplyToUnusedLocalVariableInFunction()
410			{
411			$rule = new UnusedLocalVariable();
412			$rule->addProperty('allow-unused-foreach-variables', 'false');
413			$rule->setReport($this->getReportMock(0));
414			$rule->apply($this->getFunction());
415			}
416
417			/**
418			* testRuleDoesNotApplyToUnusedLocalVariableInMethod
419			*
420			* @return void
421			*/
422			public function testRuleDoesNotApplyToUnusedLocalVariableInMethod()
423			{
424			$rule = new UnusedLocalVariable();
425			$rule->addProperty('allow-unused-foreach-variables', 'false');
426			$rule->setReport($this->getReportMock(0));
427			$rule->apply($this->getMethod());
428			}
429
430			/**
431			* testRuleDoesNotApplyToLocalVariableUsedAsArrayIndex
432			*
433			* <code>
434			* class Foo {
435			* public function bar() {
436			* foreach ($baz as $key) {
437			* self::$values[$key] = 42;
438			* }
439			* }
440			* }
441			* </code>
442			*
443			* @return void
444			*/
445			public function testRuleDoesNotApplyToLocalVariableUsedAsArrayIndex()
446			{
447			$rule = new UnusedLocalVariable();
448			$rule->addProperty('allow-unused-foreach-variables', 'false');
449			$rule->setReport($this->getReportMock(0));
450			$rule->apply($this->getMethod());
451			}
452
453			/**
454			* testRuleAppliesToUnusedForeachKeyWhenNotIgnored
455			*
456			* @return void
457			*/
458			public function testRuleAppliesToUnusedForeachKeyWhenNotIgnored()
459			{
460			$rule = new UnusedLocalVariable();
461			$rule->addProperty('allow-unused-foreach-variables', 'false');
462			$rule->setReport($this->getReportMock(1));
463			$rule->apply($this->getMethod());
464			}
465
466			/**
467			* testRuleAppliesToUnusedForeachValueWhenNotIgnored
468			*
469			* @return void
470			*/
471			public function testRuleAppliesToUnusedForeachValueWhenNotIgnored()
472			{
473			$rule = new UnusedLocalVariable();
474			$rule->addProperty('allow-unused-foreach-variables', 'false');
475			$rule->setReport($this->getReportMock(1));
476			$rule->apply($this->getMethod());
477			}
478
479			/**
480			* testRuleDoesNotApplyToUnusedForeachKeyWhenIgnored
481			*
482			* @return void
483			*/
484			public function testRuleDoesNotApplyToUnusedForeachKeyWhenIgnored()
485			{
486			$rule = new UnusedLocalVariable();
487			$rule->addProperty('allow-unused-foreach-variables', 'true');
488			$rule->setReport($this->getReportMock(0));
489			$rule->apply($this->getMethod());
490			}
491
492			/**
493			* testRuleDoesNotApplyToUnusedForeachKeyWhenWhitelisted
494			*
495			* @return void
496			*/
497			public function testRuleDoesNotApplyToUnusedForeachKeyWhenWhitelisted()
498			{
499			$rule = new UnusedLocalVariable();
500			$rule->addProperty('allow-unused-foreach-variables', 'false');
501			$rule->addProperty('exceptions', '_');
502			$rule->setReport($this->getReportMock(0));
503			$rule->apply($this->getMethod());
504			}
505
506			/**
507			* testRuleDoesNotAppliesToWhitelistedUnusedLocaleVariable
508			*
509			* @return void
510			*/
511			public function testRuleDoesNotAppliesToWhitelistedUnusedLocaleVariable()
512			{
513			$rule = new UnusedLocalVariable();
514			$rule->addProperty('allow-unused-foreach-variables', 'false');
515			$rule->addProperty('exceptions', '_');
516			$rule->setReport($this->getReportMock(0));
517			$rule->apply($this->getMethod());
518			}
519
520			/**
521			* testRuleStillAppliesWhenSomeUnusedLocaleAreWhitelisted
522			*
523			* @return void
524			*/
525			public function testRuleStillAppliesWhenSomeUnusedLocaleAreWhitelisted()
526			{
527			$rule = new UnusedLocalVariable();
528			$rule->addProperty('allow-unused-foreach-variables', 'false');
529			$rule->addProperty('exceptions', '_');
530			$rule->setReport($this->getReportMock(1));
531			$rule->apply($this->getMethod());
532			}
533
534			/**
535			* testRuleDoesNotApplyToUnusedForeachValueWhenIgnored
536			*
537			* @return void
538			*/
539			public function testRuleDoesNotApplyToUnusedForeachValueWhenIgnored()
540			{
541			$rule = new UnusedLocalVariable();
542			$rule->addProperty('allow-unused-foreach-variables', 'true');
543			$rule->setReport($this->getReportMock(0));
544			$rule->apply($this->getMethod());
545			}
546
547			/**
548			* testRuleDoesNotApplyToLocalVariableUsedAsStringIndex
549			*
550			* <code>
551			* class Foo {
552			* public function bar() {
553			* foreach ($baz as $key) {
554			* self::$string{$key} = 'a';
555			* }
556			* }
557			* }
558			* </code>
559			*
560			* @return void
561			*/
562			public function testRuleDoesNotApplyToLocalVariableUsedAsStringIndex()
563			{
564			$rule = new UnusedLocalVariable();
565			$rule->addProperty('allow-unused-foreach-variables', 'false');
566			$rule->setReport($this->getReportMock(0));
567			$rule->apply($this->getMethod());
568			}
569
570			/**
571			* testRuleDoesNotApplyToCatchStatement
572			*
573			* <code>
574			* class Foo {
575			* public function bar() {
576			* try {
577			* } catch (Exception $e) {
578			* }
579			* }
580			* }
581			* </code>
582			*
583			* @return void
584			*/
585			public function testRuleDoesNotApplyToCatchStatement()
586			{
587			$rule = new UnusedLocalVariable();
588			$rule->addProperty('allow-unused-foreach-variables', 'false');
589			$rule->setReport($this->getReportMock(0));
590			$rule->apply($this->getMethod());
591			}
592
593			/**
594			* testRuleDoesNotApplyToCompactFunction
595			*
596			* <code>
597			* class Foo {
598			* public function bar() {
599			* $key = 'ok';
600			* return compact('key');
601			* }
602			* }
603			* </code>
604			*
605			* @return void
606			*/
607			public function testRuleDoesNotApplyToCompactFunction()
608			{
609			$rule = new UnusedLocalVariable();
610			$rule->addProperty('allow-unused-foreach-variables', 'false');
611			$rule->setReport($this->getReportMock(0));
612			$rule->apply($this->getMethod());
613			}
614
615			/**
616			* @return void
617			* @since 2.0.0
618			*/
619			public function testCompactFunctionRuleWorksCaseInsensitive()
620			{
621			$rule = new UnusedLocalVariable();
622			$rule->addProperty('allow-unused-foreach-variables', 'false');
623			$rule->setReport($this->getReportMock(0));
624			$rule->apply($this->getMethod());
625			}
626
627			/**
628			* testRuleDoesNotApplyToNamespacedCompactFunction
629			*
630			* <code>
631			* namespace Baz;
632			*
633			* class Foo {
634			* public function bar() {
635			* $key = 'ok';
636			* return compact('key');
637			* }
638			* }
639			* </code>
640			*
641			* @return void
642			*/
643			public function testRuleDoesNotApplyToNamespacedCompactFunction()
644			{
645			$rule = new UnusedLocalVariable();
646			$rule->addProperty('allow-unused-foreach-variables', 'false');
647			$rule->setReport($this->getReportMock(0));
648			$rule->apply($this->getMethod());
649			}
650
651			/**
652			* @return void
653			* @since 2.0.1
654			*/
655			public function testNamespacedCompactFunctionRuleWorksCaseInsensitive()
656			{
657			$rule = new UnusedLocalVariable();
658			$rule->addProperty('allow-unused-foreach-variables', 'false');
659			$rule->setReport($this->getReportMock(0));
660			$rule->apply($this->getMethod());
661			}
662
663			/**
664			* testRuleNotAppliesToPredefinedVariables.php
665			*
666			* @return void
667			*/
668			public function testRuleNotAppliesToPredefinedVariables()
669			{
670			$rule = new UnusedLocalVariable();
671			$rule->addProperty('allow-unused-foreach-variables', 'false');
672			$rule->setReport($this->getReportMock(1));
673			$rule->apply($this->getMethod());
674			}
675			}
676

SomeBlackMagic / phpmd

testRuleDoesNotApplyToUnusedLocalVariableInMethod() A last analyzed 2019-11-06 10:20 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testRuleDoesNotApplyToUnusedLocalVariableInMethod() A
last analyzed 2019-11-06 10:20 UTC