PHPCSStandards / PHPCSUtils / 407

pending completion

Build # 407

Build Type

Pull #111

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/PHPCSStandards/PHPCSUtils/commit/b0a97e259">UtilityMethodTestCase: auto-skip JS/CSS tests when using PHPCS 4.x

This implements automatic test skipping for JS/CSS tests on PHPCS 4.x, on which support for JS/CSS has been dropped.

Ref: https://github.com/squizlabs/PHP_CodeSniffer/commit/</a><a class="double-link" href="https://github.com/PHPCSStandards/PHPCSUtils/commit/ea52e7b48">ea52e7b48</a>

Pull Request Pull Request #111: UtilityMethodTestCase: auto-skip JS/CSS tests when using PHPCS 4.x

Run Details

6 of 6 new or added lines in 1 file covered. (100.0%)

2311 of 2355 relevant lines covered (98.13%)

69.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.29

/PHPCSUtils/TestUtils/UtilityMethodTestCase.php

<?php
/**
 * PHPCSUtils, utility functions and classes for PHP_CodeSniffer sniff developers.
 *
 * @package   PHPCSUtils
 * @copyright 2019-2020 PHPCSUtils Contributors
 * @license   https://opensource.org/licenses/LGPL-3.0 LGPL3
 * @link      https://github.com/PHPCSStandards/PHPCSUtils
 */

namespace PHPCSUtils\TestUtils;

use PHP_CodeSniffer\Exceptions\RuntimeException;
use PHP_CodeSniffer\Exceptions\TokenizerException;
use PHPCSUtils\BackCompat\Helper;
use PHPUnit\Framework\TestCase;
use ReflectionClass;

/**
 * Base class for use when testing utility methods for PHP_CodeSniffer.
 *
 * This class is compatible with PHP_CodeSniffer 2.x as well as 3.x.
 *
 * This class is compatible with PHPUnit 4.5 - 9.x providing the PHPCSUtils autoload
 * file is included in the test bootstrap.
 *
 * To allow for testing of tab vs space content, the tabWidth is set to `4` by default.
 *
 * Typical usage:
 *
 * Test case file `path/to/ClassUnderTestUnitTest.inc`:
 * ```php
 * <?php
 *
 * /* testTestCaseDescription * /
 * const BAR = false;
 * ```
 *
 * Test file `path/to/ClassUnderTestUnitTest.php`:
 * ```php
 * <?php
 *
 * use PHPCSUtils\TestUtils\UtilityMethodTestCase;
 * use YourStandard\ClassUnderTest;
 *
 * class ClassUnderTestUnitTest extends UtilityMethodTestCase {
 *
 *     /**
 *      * Testing utility method MyMethod.
 *      *
 *      * @dataProvider dataMyMethod
 *      *
 *      * @covers \YourStandard\ClassUnderTest::MyMethod
 *      *
 *      * @param string $commentString The comment which prefaces the target token in the test file.
 *      * @param string $expected      The expected return value.
 *      *
 *      * @return void
 *      * /
 *    public function testMyMethod($commentString, $expected)
 *    {
 *        $stackPtr = $this->getTargetToken($commentString, [\T_TOKEN_CONSTANT, \T_ANOTHER_TOKEN]);
 *        $class    = new ClassUnderTest();
 *        $result   = $class->MyMethod(self::$phpcsFile, $stackPtr);
 *        // Or for static utility methods:
 *        $result   = ClassUnderTest::MyMethod(self::$phpcsFile, $stackPtr);
 *
 *        $this->assertSame($expected, $result);
 *    }
 *
 *    /**
 *     * Data Provider.
 *     *
 *     * @see testMyMethod() For the array format.
 *     *
 *     * @return array
 *     * /
 *    public function dataMyMethod()
 *    {
 *        return array(
 *            array('/* testTestCaseDescription * /', false),
 *        );
 *    }
 * }
 * ```
 *
 * Note:
 * - Remove the space between the comment closers `* /` for a working example.
 * - Each test case separator comment MUST start with `/* test`.
 *   This is to allow the `getTargetToken()` method to distinquish between the
 *   test separation comments and comments which may be part of the test case.
 * - The test case file and unit test file should be placed in the same directory.
 * - For working examples using this abstract class, have a look at the unit tests
 *   for the PHPCSUtils utility functions themselves.
 *
 * @since 1.0.0
 */
abstract class UtilityMethodTestCase extends TestCase
{

    /**
     * The PHPCS version the tests are being run on.
     *
     * @since 1.0.0
     *
     * @var string
     */
    protected static $phpcsVersion = '0';

    /**
     * The file extension of the test case file (without leading dot).
     *
     * This allows concrete test classes to overrule the default `inc` with, for instance,
     * `js` or `css` when applicable.
     *
     * @since 1.0.0
     *
     * @var string
     */
    protected static $fileExtension = 'inc';

    /**
     * Full path to the test case file associated with the concrete test class.
     *
     * Optional. If left empty, the case file will be presumed to be in
     * the same directory and named the same as the test class, but with an
     * `inc` file extension.
     *
     * @since 1.0.0
     *
     * @var string
     */
    protected static $caseFile = '';

    /**
     * The tab width setting to use when tokenizing the file.
     *
     * This allows for test case files to use a different tab width than the default.
     *
     * @since 1.0.0
     *
     * @var int
     */
    protected static $tabWidth = 4;

    /**
     * The {@see \PHP_CodeSniffer\Files\File} object containing the parsed contents of the test case file.
     *
     * @since 1.0.0
     *
     * @var \PHP_CodeSniffer\Files\File
     */
    protected static $phpcsFile;

    /**
     * Set the name of a sniff to pass to PHPCS to limit the run (and force it to record errors).
     *
     * Normally, this propery won't need to be overloaded, but for utility methods which record
     * violations and contain fixers, setting a dummy sniff name equal to the sniff name passed
     * in the error code for `addError()`/`addWarning()` during the test, will allow for testing
     * the recording of these violations, as well as testing the fixer.
     *
     * @since 1.0.0
     *
     * @var array
     */
    protected static $selectedSniff = ['Dummy.Dummy.Dummy'];

    /**
     * Initialize PHPCS & tokenize the test case file.
     *
     * The test case file for a unit test class has to be in the same directory
     * directory and use the same file name as the test class, using the .inc extension.
     *
     * @since 1.0.0
     *
     * @beforeClass
     *
     * @return void
     */
    public static function setUpTestFile()
    {
        parent::setUpBeforeClass();

        self::$phpcsVersion = Helper::getVersion();

        $caseFile = static::$caseFile;
        if (\is_string($caseFile) === false || $caseFile === '') {
            $testClass = \get_called_class();
            $testFile  = (new ReflectionClass($testClass))->getFileName();
            $caseFile  = \substr($testFile, 0, -3) . static::$fileExtension;
        }

        if (\is_readable($caseFile) === false) {
            parent::fail("Test case file missing. Expected case file location: $caseFile");
        }

        $contents = \file_get_contents($caseFile);

        if (\version_compare(self::$phpcsVersion, '2.99.99', '>')) {
            // PHPCS 3.x.
            $config = new \PHP_CodeSniffer\Config();

            /*
             * We just need to provide a standard so PHPCS will tokenize the file.
             * The standard itself doesn't actually matter for testing utility methods,
             * so use the smallest one to get the fastest results.
             */
            $config->standards = ['PSR1'];

            /*
             * Limiting the run to just one sniff will make it, yet again, slightly faster.
             * Picked the simplest/fastest sniff available which is registered in PSR1.
             */
            $config->sniffs = static::$selectedSniff;

            // Disable caching.
            $config->cache = false;

            // Also set a tab-width to enable testing tab-replaced vs `orig_content`.
            $config->tabWidth = static::$tabWidth;

            $ruleset = new \PHP_CodeSniffer\Ruleset($config);

            // Make sure the file gets parsed correctly based on the file type.
            $contents = 'phpcs_input_file: ' . $caseFile . \PHP_EOL . $contents;

            self::$phpcsFile = new \PHP_CodeSniffer\Files\DummyFile($contents, $ruleset, $config);

            // Only tokenize the file, do not process it.
            try {
                self::$phpcsFile->parse();
            } catch (TokenizerException $e) {
                // PHPCS 3.5.0 and higher.
            } catch (RuntimeException $e) {
                // PHPCS 3.0.0 < 3.5.0.
            }
        } else {
            // PHPCS 2.x.
            $phpcs           = new \PHP_CodeSniffer(null, static::$tabWidth);
            self::$phpcsFile = new \PHP_CodeSniffer_File(
                $caseFile,
                [],
                [],
                $phpcs
            );

            /*
             * Using error silencing to drown out "undefined index" notices for tokenizer
             * issues in PHPCS 2.x which won't get fixed anymore anyway.
             */
            @self::$phpcsFile->start($contents);
        }

        // Fail the test if the case file failed to tokenize.
        if (self::$phpcsFile->numTokens === 0) {
            parent::fail("Tokenizing of the test case file failed for case file: $caseFile");
        }
    }

    /**
     * Skip JS and CSS related tests on PHPCS 4.x.
     *
     * @since 1.0.0
     *
     * @before
     *
     * @return void
     */
    public function skipJSCSSTestsOnPHPCS4()
    {
        if (static::$fileExtension !== 'js' && static::$fileExtension !== 'css') {
            return;
        }

        if (\version_compare(self::$phpcsVersion, '3.99.99', '<=')) {
            return;
        }

        $this->markTestSkipped('JS and CSS support has been removed in PHPCS 4.');
    }

    /**
     * Clean up after finished test.
     *
     * @since 1.0.0
     *
     * @afterClass
     *
     * @return void
     */
    public static function resetTestFile()
    {
        self::$phpcsFile = null;
    }

    /**
     * Get the token pointer for a target token based on a specific comment found on the line before.
     *
     * Note: the test delimiter comment MUST start with "/* test" to allow this function to
     * distinguish between comments used *in* a test and test delimiters.
     *
     * @since 1.0.0
     *
     * @param string           $commentString The delimiter comment to look for.
     * @param int|string|array $tokenType     The type of token(s) to look for.
     * @param string           $tokenContent  Optional. The token content for the target token.
     *
     * @return int
     */
    public function getTargetToken($commentString, $tokenType, $tokenContent = null)
    {
        $start   = (self::$phpcsFile->numTokens - 1);
        $comment = self::$phpcsFile->findPrevious(
            \T_COMMENT,
            $start,
            null,
            false,
            $commentString
        );

        $tokens = self::$phpcsFile->getTokens();
        $end    = ($start + 1);

        // Limit the token finding to between this and the next delimiter comment.
        for ($i = ($comment + 1); $i < $end; $i++) {
            if ($tokens[$i]['code'] !== \T_COMMENT) {
                continue;
            }

            if (\stripos($tokens[$i]['content'], '/* test') === 0) {
                $end = $i;
                break;
            }
        }

        $target = self::$phpcsFile->findNext(
            $tokenType,
            ($comment + 1),
            $end,
            false,
            $tokenContent
        );

        if ($target === false) {
            $msg = 'Failed to find test target token for comment string: ' . $commentString;
            if ($tokenContent !== null) {
                $msg .= ' With token content: ' . $tokenContent;
            }

            $this->fail($msg);
        }

        return $target;
    }

    /**
     * Helper method to tell PHPUnit to expect a PHPCS Exception in a PHPUnit cross-version
     * compatible manner.
     *
     * @since 1.0.0
     *
     * @param string $msg  The expected exception message.
     * @param string $type The exception type to expect. Either 'runtime' or 'tokenizer'.
     *                     Defaults to 'runtime'.
     *
     * @return void
     */
    public function expectPhpcsException($msg, $type = 'runtime')
    {
        $exception = 'PHP_CodeSniffer\Exceptions\RuntimeException';
        if ($type === 'tokenizer') {
            $exception = 'PHP_CodeSniffer\Exceptions\TokenizerException';
        }

        if (\method_exists($this, 'expectException')) {
            // PHPUnit 5+.
            $this->expectException($exception);
            $this->expectExceptionMessage($msg);
        } else {
            // PHPUnit 4.
            $this->setExpectedException($exception, $msg);
        }
    }
}

1	<?php
2	/**
3	* PHPCSUtils, utility functions and classes for PHP_CodeSniffer sniff developers.
4	*
5	* @package PHPCSUtils
6	* @copyright 2019-2020 PHPCSUtils Contributors
7	* @license https://opensource.org/licenses/LGPL-3.0 LGPL3
8	* @link https://github.com/PHPCSStandards/PHPCSUtils
9	*/
10
11	namespace PHPCSUtils\TestUtils;
12
13	use PHP_CodeSniffer\Exceptions\RuntimeException;
14	use PHP_CodeSniffer\Exceptions\TokenizerException;
15	use PHPCSUtils\BackCompat\Helper;
16	use PHPUnit\Framework\TestCase;
17	use ReflectionClass;
18
19	/**
20	* Base class for use when testing utility methods for PHP_CodeSniffer.
21	*
22	* This class is compatible with PHP_CodeSniffer 2.x as well as 3.x.
23	*
24	* This class is compatible with PHPUnit 4.5 - 9.x providing the PHPCSUtils autoload
25	* file is included in the test bootstrap.
26	*
27	* To allow for testing of tab vs space content, the tabWidth is set to `4` by default.
28	*
29	* Typical usage:
30	*
31	* Test case file `path/to/ClassUnderTestUnitTest.inc`:
32	* ```php
33	* <?php
34	*
35	* /* testTestCaseDescription * /
36	* const BAR = false;
37	* ```
38	*
39	* Test file `path/to/ClassUnderTestUnitTest.php`:
40	* ```php
41	* <?php
42	*
43	* use PHPCSUtils\TestUtils\UtilityMethodTestCase;
44	* use YourStandard\ClassUnderTest;
45	*
46	* class ClassUnderTestUnitTest extends UtilityMethodTestCase {
47	*
48	* /**
49	* * Testing utility method MyMethod.
50	* *
51	* * @dataProvider dataMyMethod
52	* *
53	* * @covers \YourStandard\ClassUnderTest::MyMethod
54	* *
55	* * @param string $commentString The comment which prefaces the target token in the test file.
56	* * @param string $expected The expected return value.
57	* *
58	* * @return void
59	* * /
60	* public function testMyMethod($commentString, $expected)
61	* {
62	* $stackPtr = $this->getTargetToken($commentString, [\T_TOKEN_CONSTANT, \T_ANOTHER_TOKEN]);
63	* $class = new ClassUnderTest();
64	* $result = $class->MyMethod(self::$phpcsFile, $stackPtr);
65	* // Or for static utility methods:
66	* $result = ClassUnderTest::MyMethod(self::$phpcsFile, $stackPtr);
67	*
68	* $this->assertSame($expected, $result);
69	* }
70	*
71	* /**
72	* * Data Provider.
73	* *
74	* * @see testMyMethod() For the array format.
75	* *
76	* * @return array
77	* * /
78	* public function dataMyMethod()
79	* {
80	* return array(
81	* array('/* testTestCaseDescription * /', false),
82	* );
83	* }
84	* }
85	* ```
86	*
87	* Note:
88	* - Remove the space between the comment closers `* /` for a working example.
89	* - Each test case separator comment MUST start with `/* test`.
90	* This is to allow the `getTargetToken()` method to distinquish between the
91	* test separation comments and comments which may be part of the test case.
92	* - The test case file and unit test file should be placed in the same directory.
93	* - For working examples using this abstract class, have a look at the unit tests
94	* for the PHPCSUtils utility functions themselves.
95	*
96	* @since 1.0.0
97	*/
98	abstract class UtilityMethodTestCase extends TestCase
99	{
100
101	/**
102	* The PHPCS version the tests are being run on.
103	*
104	* @since 1.0.0
105	*
106	* @var string
107	*/
108	protected static $phpcsVersion = '0';
109
110	/**
111	* The file extension of the test case file (without leading dot).
112	*
113	* This allows concrete test classes to overrule the default `inc` with, for instance,
114	* `js` or `css` when applicable.
115	*
116	* @since 1.0.0
117	*
118	* @var string
119	*/
120	protected static $fileExtension = 'inc';
121
122	/**
123	* Full path to the test case file associated with the concrete test class.
124	*
125	* Optional. If left empty, the case file will be presumed to be in
126	* the same directory and named the same as the test class, but with an
127	* `inc` file extension.
128	*
129	* @since 1.0.0
130	*
131	* @var string
132	*/
133	protected static $caseFile = '';
134
135	/**
136	* The tab width setting to use when tokenizing the file.
137	*
138	* This allows for test case files to use a different tab width than the default.
139	*
140	* @since 1.0.0
141	*
142	* @var int
143	*/
144	protected static $tabWidth = 4;
145
146	/**
147	* The {@see \PHP_CodeSniffer\Files\File} object containing the parsed contents of the test case file.
148	*
149	* @since 1.0.0
150	*
151	* @var \PHP_CodeSniffer\Files\File
152	*/
153	protected static $phpcsFile;
154
155	/**
156	* Set the name of a sniff to pass to PHPCS to limit the run (and force it to record errors).
157	*
158	* Normally, this propery won't need to be overloaded, but for utility methods which record
159	* violations and contain fixers, setting a dummy sniff name equal to the sniff name passed
160	* in the error code for `addError()`/`addWarning()` during the test, will allow for testing
161	* the recording of these violations, as well as testing the fixer.
162	*
163	* @since 1.0.0
164	*
165	* @var array
166	*/
167	protected static $selectedSniff = ['Dummy.Dummy.Dummy'];
168
169	/**
170	* Initialize PHPCS & tokenize the test case file.
171	*
172	* The test case file for a unit test class has to be in the same directory
173	* directory and use the same file name as the test class, using the .inc extension.
174	*
175	* @since 1.0.0
176	*
177	* @beforeClass
178	*
179	* @return void
180	*/
181	public static function setUpTestFile()
182	{
183	parent::setUpBeforeClass();	12✔
184
185	self::$phpcsVersion = Helper::getVersion();	12✔
186
187	$caseFile = static::$caseFile;	12✔
188	if (\is_string($caseFile) === false \|\| $caseFile === '') {	12✔
189	$testClass = \get_called_class();	12✔
190	$testFile = (new ReflectionClass($testClass))->getFileName();	12✔
191	$caseFile = \substr($testFile, 0, -3) . static::$fileExtension;	12✔
192	}	6✔
193
194	if (\is_readable($caseFile) === false) {	12✔
195	parent::fail("Test case file missing. Expected case file location: $caseFile");	4✔
196	}
197
198	$contents = \file_get_contents($caseFile);	8✔
199
200	if (\version_compare(self::$phpcsVersion, '2.99.99', '>')) {	8✔
201	// PHPCS 3.x.
202	$config = new \PHP_CodeSniffer\Config();	4✔
203
204	/*
205	* We just need to provide a standard so PHPCS will tokenize the file.
206	* The standard itself doesn't actually matter for testing utility methods,
207	* so use the smallest one to get the fastest results.
208	*/
209	$config->standards = ['PSR1'];	4✔
210
211	/*
212	* Limiting the run to just one sniff will make it, yet again, slightly faster.
213	* Picked the simplest/fastest sniff available which is registered in PSR1.
214	*/
215	$config->sniffs = static::$selectedSniff;	4✔
216
217	// Disable caching.
218	$config->cache = false;	4✔
219
220	// Also set a tab-width to enable testing tab-replaced vs `orig_content`.
221	$config->tabWidth = static::$tabWidth;	4✔
222
223	$ruleset = new \PHP_CodeSniffer\Ruleset($config);	4✔
224
225	// Make sure the file gets parsed correctly based on the file type.
226	$contents = 'phpcs_input_file: ' . $caseFile . \PHP_EOL . $contents;	4✔
227
228	self::$phpcsFile = new \PHP_CodeSniffer\Files\DummyFile($contents, $ruleset, $config);	4✔
229
230	// Only tokenize the file, do not process it.
231	try {
232	self::$phpcsFile->parse();	4✔
233	} catch (TokenizerException $e) {	2✔
234	// PHPCS 3.5.0 and higher.
235	} catch (RuntimeException $e) {	2✔
236	// PHPCS 3.0.0 < 3.5.0.
237	}
238	} else {	2✔
239	// PHPCS 2.x.
240	$phpcs = new \PHP_CodeSniffer(null, static::$tabWidth);	4✔
241	self::$phpcsFile = new \PHP_CodeSniffer_File(	4✔
242	$caseFile,	4✔
243	[],	4✔
244	[],	4✔
245	$phpcs
246	);	2✔
247
248	/*
249	* Using error silencing to drown out "undefined index" notices for tokenizer
250	* issues in PHPCS 2.x which won't get fixed anymore anyway.
251	*/
252	@self::$phpcsFile->start($contents);	4✔
253	}
254
255	// Fail the test if the case file failed to tokenize.
256	if (self::$phpcsFile->numTokens === 0) {	8✔
257	parent::fail("Tokenizing of the test case file failed for case file: $caseFile");	4✔
258	}
259	}	4✔
260
261	/**
262	* Skip JS and CSS related tests on PHPCS 4.x.
263	*
264	* @since 1.0.0
265	*
266	* @before
267	*
268	* @return void
269	*/
270	public function skipJSCSSTestsOnPHPCS4()
271	{
272	if (static::$fileExtension !== 'js' && static::$fileExtension !== 'css') {	56✔
273	return;	56✔
274	}
275
276	if (\version_compare(self::$phpcsVersion, '3.99.99', '<=')) {	×
277	return;	×
278	}
279
280	$this->markTestSkipped('JS and CSS support has been removed in PHPCS 4.');	×
281	}	×
282
283	/**
284	* Clean up after finished test.
285	*
286	* @since 1.0.0
287	*
288	* @afterClass
289	*
290	* @return void
291	*/
292	public static function resetTestFile()
293	{
294	self::$phpcsFile = null;	4✔
295	}	4✔
296
297	/**
298	* Get the token pointer for a target token based on a specific comment found on the line before.
299	*
300	* Note: the test delimiter comment MUST start with "/* test" to allow this function to
301	* distinguish between comments used in a test and test delimiters.
302	*
303	* @since 1.0.0
304	*
305	* @param string $commentString The delimiter comment to look for.
306	* @param int\|string\|array $tokenType The type of token(s) to look for.
307	* @param string $tokenContent Optional. The token content for the target token.
308	*
309	* @return int
310	*/
311	public function getTargetToken($commentString, $tokenType, $tokenContent = null)
312	{
313	$start = (self::$phpcsFile->numTokens - 1);	40✔
314	$comment = self::$phpcsFile->findPrevious(	40✔
315	\T_COMMENT,	40✔
316	$start,	20✔
317	null,	40✔
318	false,	40✔
319	$commentString
320	);	20✔
321
322	$tokens = self::$phpcsFile->getTokens();	40✔
323	$end = ($start + 1);	40✔
324
325	// Limit the token finding to between this and the next delimiter comment.
326	for ($i = ($comment + 1); $i < $end; $i++) {	40✔
327	if ($tokens[$i]['code'] !== \T_COMMENT) {	40✔
328	continue;	40✔
329	}
330
331	if (\stripos($tokens[$i]['content'], '/* test') === 0) {	40✔
332	$end = $i;	40✔
333	break;	40✔
334	}
335	}
336
337	$target = self::$phpcsFile->findNext(	40✔
338	$tokenType,	40✔
339	($comment + 1),	40✔
340	$end,	20✔
341	false,	40✔
342	$tokenContent
343	);	20✔
344
345	if ($target === false) {	40✔
346	$msg = 'Failed to find test target token for comment string: ' . $commentString;	4✔
347	if ($tokenContent !== null) {	4✔
348	$msg .= ' With token content: ' . $tokenContent;	4✔
349	}	2✔
350
351	$this->fail($msg);	4✔
352	}
353
354	return $target;	36✔
355	}
356
357	/**
358	* Helper method to tell PHPUnit to expect a PHPCS Exception in a PHPUnit cross-version
359	* compatible manner.
360	*
361	* @since 1.0.0
362	*
363	* @param string $msg The expected exception message.
364	* @param string $type The exception type to expect. Either 'runtime' or 'tokenizer'.
365	* Defaults to 'runtime'.
366	*
367	* @return void
368	*/
369	public function expectPhpcsException($msg, $type = 'runtime')
370	{
371	$exception = 'PHP_CodeSniffer\Exceptions\RuntimeException';	8✔
372	if ($type === 'tokenizer') {	8✔
373	$exception = 'PHP_CodeSniffer\Exceptions\TokenizerException';	4✔
374	}	2✔
375
376	if (\method_exists($this, 'expectException')) {	8✔
377	// PHPUnit 5+.
378	$this->expectException($exception);	5✔
379	$this->expectExceptionMessage($msg);	4✔
380	} else {
381	// PHPUnit 4.
382	$this->setExpectedException($exception, $msg);	4✔
383	}
384	}	8✔
385	}

PHPCSStandards / PHPCSUtils / 407

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous