UnusedLocalVariableTest::testRuleDoesNotApplyToCompactWithDoubleQuotesFunction() - Code Metrics - Inspection of "Merge pull request #844 from babanesma/compact_dou..." - phpmd/phpmd - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 939e6f...c3b5bc )

by Tobias van

created 2021-02-28 20:57 UTC

testRuleDoesNotApplyToCompactWithDoubleQuotesFunction() A

↳ 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->getReportWithOneViolation());
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleAppliesToUnusedLocalVariable
     *
     * @return void
     */
    public function testRuleAppliesToUnusedLocalVariableDeclaredTwice()
    {
        $rule = new UnusedLocalVariable();
        $rule->setReport($this->getReportWithOneViolation());
        $rule->apply($this->getMethod());
    }

    /**
     * testInnerFunctionParametersDoNotHideUnusedVariables
     *
     * @return void
     */
    public function testInnerFunctionParametersDoNotHideUnusedVariables()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportWithOneViolation());
        $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->getReportWithOneViolation());
        $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->getReportWithOneViolation());
        $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->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $rule->apply($this->getMethod());
    }

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

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

    /**
     * testRuleDoesNotApplyToStaticArrayProperty
     *
     * @return void
     */
    public function testRuleDoesNotApplyToStaticArrayProperty()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $rule->apply($this->getMethod());
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * testRuleDoesNotApplyToUnusedLocalVariableInMethod
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedLocalVariableInMethod()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $rule->apply($this->getMethod());
    }

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

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

    /**
     * testRuleDoesNotApplyToUnusedForeachKeyWhenIgnored
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedForeachKeyWhenIgnored()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'true');
        $rule->setReport($this->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $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->getReportWithOneViolation());
        $rule->apply($this->getMethod());
    }

    /**
     * testRuleDoesNotApplyToUnusedForeachValueWhenIgnored
     *
     * @return void
     */
    public function testRuleDoesNotApplyToUnusedForeachValueWhenIgnored()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'true');
        $rule->setReport($this->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $rule->apply($this->getMethod());
    }

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

    /**
     * @test
     * @return void
     * @since 2.0.0
     */
    public function testCompactFunctionRuleWorksCaseInsensitive()
    {
        $rule = new UnusedLocalVariable();
        $rule->addProperty('allow-unused-foreach-variables', 'false');
        $rule->setReport($this->getReportWithNoViolation());
        $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->getReportWithNoViolation());
        $rule->apply($this->getMethod());
    }

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

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

phpmd / phpmd

Push — master ( 939e6f...c3b5bc )

testRuleDoesNotApplyToCompactWithDoubleQuotesFunction() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like