← Back to branch summary

~ballot/wordpress/openstack-objectstorage-breaking-insight

« back to all changes in this revision

Viewing changes to vendor/phpunit/phpunit/tests/Util/TestTest.php

  • Committer: Jacek Nykis
  • Date: 2015-02-11 15:35:31 UTC
  • Revision ID: jacek.nykis@canonical.com-20150211153531-hmy6zi0ov2qfkl0b
Initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/phpunit/phpunit/tests/Util/TestTest.php
 
1
<?php
 
2
/*
 
3
 * This file is part of PHPUnit.
 
4
 *
 
5
 * (c) Sebastian Bergmann <sebastian@phpunit.de>
 
6
 *
 
7
 * For the full copyright and license information, please view the LICENSE
 
8
 * file that was distributed with this source code.
 
9
 */
 
10
 
 
11
if (!defined('TEST_FILES_PATH')) {
 
12
    define(
 
13
        'TEST_FILES_PATH',
 
14
        dirname(__DIR__) . DIRECTORY_SEPARATOR .
 
15
        '_files' . DIRECTORY_SEPARATOR
 
16
    );
 
17
}
 
18
 
 
19
/**
 
20
 *
 
21
 *
 
22
 * @package    PHPUnit
 
23
 * @author     Sebastian Bergmann <sebastian@phpunit.de>
 
24
 * @copyright  Sebastian Bergmann <sebastian@phpunit.de>
 
25
 * @license    http://www.opensource.org/licenses/BSD-3-Clause  The BSD 3-Clause License
 
26
 * @link       http://www.phpunit.de/
 
27
 * @since      Class available since Release 3.3.6
 
28
 */
 
29
class Util_TestTest extends PHPUnit_Framework_TestCase
 
30
{
 
31
    /**
 
32
     * @covers PHPUnit_Util_Test::getExpectedException
 
33
     * @todo   Split up in separate tests
 
34
     */
 
35
    public function testGetExpectedException()
 
36
    {
 
37
        $this->assertArraySubset(
 
38
          array('class' => 'FooBarBaz', 'code' => null, 'message' => ''),
 
39
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testOne')
 
40
        );
 
41
 
 
42
        $this->assertArraySubset(
 
43
          array('class' => 'Foo_Bar_Baz', 'code' => null, 'message' => ''),
 
44
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testTwo')
 
45
        );
 
46
 
 
47
        $this->assertArraySubset(
 
48
          array('class' => 'Foo\Bar\Baz', 'code' => null, 'message' => ''),
 
49
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testThree')
 
50
        );
 
51
 
 
52
        $this->assertArraySubset(
 
53
          array('class' => 'ほげ', 'code' => null, 'message' => ''),
 
54
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testFour')
 
55
        );
 
56
 
 
57
        $this->assertArraySubset(
 
58
          array('class' => 'Class', 'code' => 1234, 'message' => 'Message'),
 
59
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testFive')
 
60
        );
 
61
 
 
62
        $this->assertArraySubset(
 
63
          array('class' => 'Class', 'code' => 1234, 'message' => 'Message'),
 
64
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testSix')
 
65
        );
 
66
 
 
67
        $this->assertArraySubset(
 
68
          array('class' => 'Class', 'code' => 'ExceptionCode', 'message' => 'Message'),
 
69
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testSeven')
 
70
        );
 
71
 
 
72
        $this->assertArraySubset(
 
73
          array('class' => 'Class', 'code' => 0, 'message' => 'Message'),
 
74
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testEight')
 
75
        );
 
76
 
 
77
        $this->assertArraySubset(
 
78
          array('class' => 'Class', 'code' => ExceptionTest::ERROR_CODE, 'message' => ExceptionTest::ERROR_MESSAGE),
 
79
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testNine')
 
80
        );
 
81
 
 
82
        $this->assertArraySubset(
 
83
          array('class' => 'Class', 'code' => null, 'message' => ''),
 
84
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testSingleLine')
 
85
        );
 
86
 
 
87
        $this->assertArraySubset(
 
88
          array('class' => 'Class', 'code' => My\Space\ExceptionNamespaceTest::ERROR_CODE, 'message' => My\Space\ExceptionNamespaceTest::ERROR_MESSAGE),
 
89
          PHPUnit_Util_Test::getExpectedException('My\Space\ExceptionNamespaceTest', 'testConstants')
 
90
        );
 
91
 
 
92
        // Ensure the Class::CONST expression is only evaluated when the constant really exists
 
93
        $this->assertArraySubset(
 
94
          array('class' => 'Class', 'code' => 'ExceptionTest::UNKNOWN_CODE_CONSTANT', 'message' => 'ExceptionTest::UNKNOWN_MESSAGE_CONSTANT'),
 
95
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testUnknownConstants')
 
96
        );
 
97
 
 
98
        $this->assertArraySubset(
 
99
          array('class' => 'Class', 'code' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_CODE_CONSTANT', 'message' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_MESSAGE_CONSTANT'),
 
100
          PHPUnit_Util_Test::getExpectedException('My\Space\ExceptionNamespaceTest', 'testUnknownConstants')
 
101
        );
 
102
    }
 
103
 
 
104
    /**
 
105
     * @covers PHPUnit_Util_Test::getExpectedException
 
106
     */
 
107
    public function testGetExpectedRegExp()
 
108
    {
 
109
        $this->assertArraySubset(
 
110
          array('message_regex' => '#regex#'),
 
111
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testWithRegexMessage')
 
112
        );
 
113
 
 
114
        $this->assertArraySubset(
 
115
          array('message_regex' => '#regex#'),
 
116
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testWithRegexMessageFromClassConstant')
 
117
        );
 
118
 
 
119
        $this->assertArraySubset(
 
120
          array('message_regex' => 'ExceptionTest::UNKNOWN_MESSAGE_REGEX_CONSTANT'),
 
121
          PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testWithUnknowRegexMessageFromClassConstant')
 
122
        );
 
123
    }
 
124
 
 
125
    /**
 
126
     * @covers       PHPUnit_Util_Test::getRequirements
 
127
     * @dataProvider requirementsProvider
 
128
     */
 
129
    public function testGetRequirements($test, $result)
 
130
    {
 
131
        $this->assertEquals(
 
132
            $result,
 
133
            PHPUnit_Util_Test::getRequirements('RequirementsTest', $test)
 
134
        );
 
135
    }
 
136
 
 
137
    public function requirementsProvider()
 
138
    {
 
139
        return array(
 
140
            array('testOne',    array()),
 
141
            array('testTwo',    array('PHPUnit' => '1.0')),
 
142
            array('testThree',  array('PHP' => '2.0')),
 
143
            array('testFour',   array('PHPUnit'=>'2.0', 'PHP' => '1.0')),
 
144
            array('testFive',   array('PHP' => '5.4.0RC6')),
 
145
            array('testSix',    array('PHP' => '5.4.0-alpha1')),
 
146
            array('testSeven',  array('PHP' => '5.4.0beta2')),
 
147
            array('testEight',  array('PHP' => '5.4-dev')),
 
148
            array('testNine',   array('functions' => array('testFunc'))),
 
149
            array('testTen',    array('extensions' => array('testExt'))),
 
150
            array('testEleven', array('OS' => '/Linux/i')),
 
151
            array(
 
152
              'testSpace',
 
153
              array(
 
154
                'extensions' => array('spl'),
 
155
                'OS' => '/.*/i'
 
156
              )
 
157
            ),
 
158
            array(
 
159
              'testAllPossibleRequirements',
 
160
              array(
 
161
                'PHP' => '99-dev',
 
162
                'PHPUnit' => '9-dev',
 
163
                'OS' => '/DOESNOTEXIST/i',
 
164
                'functions' => array(
 
165
                  'testFuncOne',
 
166
                  'testFuncTwo',
 
167
                ),
 
168
                'extensions' => array(
 
169
                  'testExtOne',
 
170
                  'testExtTwo',
 
171
                )
 
172
              )
 
173
            )
 
174
        );
 
175
    }
 
176
 
 
177
    /**
 
178
     * @covers PHPUnit_Util_Test::getRequirements
 
179
     */
 
180
    public function testGetRequirementsMergesClassAndMethodDocBlocks()
 
181
    {
 
182
        $expectedAnnotations = array(
 
183
            'PHP' => '5.4',
 
184
            'PHPUnit' => '3.7',
 
185
            'OS' => '/WINNT/i',
 
186
            'functions' => array(
 
187
              'testFuncClass',
 
188
              'testFuncMethod',
 
189
            ),
 
190
            'extensions' => array(
 
191
              'testExtClass',
 
192
              'testExtMethod',
 
193
            )
 
194
        );
 
195
 
 
196
        $this->assertEquals(
 
197
            $expectedAnnotations,
 
198
            PHPUnit_Util_Test::getRequirements('RequirementsClassDocBlockTest', 'testMethod')
 
199
        );
 
200
    }
 
201
 
 
202
    /**
 
203
     * @covers       PHPUnit_Util_Test::getMissingRequirements
 
204
     * @dataProvider missingRequirementsProvider
 
205
     */
 
206
    public function testGetMissingRequirements($test, $result)
 
207
    {
 
208
        $this->assertEquals(
 
209
            $result,
 
210
            PHPUnit_Util_Test::getMissingRequirements('RequirementsTest', $test)
 
211
        );
 
212
    }
 
213
 
 
214
    public function missingRequirementsProvider()
 
215
    {
 
216
        return array(
 
217
            array('testOne',            array()),
 
218
            array('testNine',           array('Function testFunc is required.')),
 
219
            array('testTen',            array('Extension testExt is required.')),
 
220
            array('testAlwaysSkip',     array('PHPUnit 1111111 (or later) is required.')),
 
221
            array('testAlwaysSkip2',    array('PHP 9999999 (or later) is required.')),
 
222
            array('testAlwaysSkip3',    array('Operating system matching /DOESNOTEXIST/i is required.')),
 
223
            array('testAllPossibleRequirements', array(
 
224
              'PHP 99-dev (or later) is required.',
 
225
              'PHPUnit 9-dev (or later) is required.',
 
226
              'Operating system matching /DOESNOTEXIST/i is required.',
 
227
              'Function testFuncOne is required.',
 
228
              'Function testFuncTwo is required.',
 
229
              'Extension testExtOne is required.',
 
230
              'Extension testExtTwo is required.',
 
231
            )),
 
232
        );
 
233
    }
 
234
 
 
235
    /**
 
236
     * @coversNothing
 
237
     * @todo   This test does not really test functionality of PHPUnit_Util_Test
 
238
     */
 
239
    public function testGetProvidedDataRegEx()
 
240
    {
 
241
        $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider method', $matches);
 
242
        $this->assertEquals(1, $result);
 
243
        $this->assertEquals('method', $matches[1]);
 
244
 
 
245
        $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider class::method', $matches);
 
246
        $this->assertEquals(1, $result);
 
247
        $this->assertEquals('class::method', $matches[1]);
 
248
 
 
249
        $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\class::method', $matches);
 
250
        $this->assertEquals(1, $result);
 
251
        $this->assertEquals('namespace\class::method', $matches[1]);
 
252
 
 
253
        $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\namespace\class::method', $matches);
 
254
        $this->assertEquals(1, $result);
 
255
        $this->assertEquals('namespace\namespace\class::method', $matches[1]);
 
256
 
 
257
        $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider メソッド', $matches);
 
258
        $this->assertEquals(1, $result);
 
259
        $this->assertEquals('メソッド', $matches[1]);
 
260
    }
 
261
 
 
262
    /**
 
263
     * @covers PHPUnit_Util_Test::getDependencies
 
264
     * @todo   Not sure what this test tests (name is misleading at least)
 
265
     */
 
266
    public function testParseAnnotation()
 
267
    {
 
268
        $this->assertEquals(
 
269
            array('Foo', 'ほげ'),
 
270
            PHPUnit_Util_Test::getDependencies(get_class($this), 'methodForTestParseAnnotation')
 
271
        );
 
272
    }
 
273
 
 
274
    /**
 
275
     * @depends Foo
 
276
     * @depends ほげ
 
277
     * @todo    Remove fixture from test class
 
278
     */
 
279
    public function methodForTestParseAnnotation()
 
280
    {
 
281
    }
 
282
 
 
283
    /**
 
284
     * @covers PHPUnit_Util_Test::getDependencies
 
285
     */
 
286
    public function testParseAnnotationThatIsOnlyOneLine()
 
287
    {
 
288
        $this->assertEquals(
 
289
            array('Bar'),
 
290
            PHPUnit_Util_Test::getDependencies(get_class($this), 'methodForTestParseAnnotationThatIsOnlyOneLine')
 
291
        );
 
292
    }
 
293
 
 
294
    /** @depends Bar */
 
295
    public function methodForTestParseAnnotationThatIsOnlyOneLine()
 
296
    {
 
297
        // TODO Remove fixture from test class
 
298
    }
 
299
 
 
300
    /**
 
301
     * @covers       PHPUnit_Util_Test::getLinesToBeCovered
 
302
     * @covers       PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
303
     * @covers       PHPUnit_Util_Test::resolveElementToReflectionObjects
 
304
     * @dataProvider getLinesToBeCoveredProvider
 
305
     */
 
306
    public function testGetLinesToBeCovered($test, $lines)
 
307
    {
 
308
        if (strpos($test, 'Namespace') === 0) {
 
309
            $expected = array(
 
310
              TEST_FILES_PATH . 'NamespaceCoveredClass.php' => $lines
 
311
            );
 
312
        } elseif ($test === 'CoverageNoneTest') {
 
313
            $expected = array();
 
314
        } elseif ($test === 'CoverageNothingTest') {
 
315
            $expected = false;
 
316
        } elseif ($test === 'CoverageFunctionTest') {
 
317
            $expected = array(
 
318
              TEST_FILES_PATH . 'CoveredFunction.php' => $lines
 
319
            );
 
320
        } else {
 
321
            $expected = array(TEST_FILES_PATH . 'CoveredClass.php' => $lines);
 
322
        }
 
323
 
 
324
        $this->assertEquals(
 
325
            $expected,
 
326
            PHPUnit_Util_Test::getLinesToBeCovered(
 
327
                $test, 'testSomething'
 
328
            )
 
329
        );
 
330
    }
 
331
 
 
332
    /**
 
333
     * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 
334
     * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
335
     * @covers            PHPUnit_Util_Test::resolveElementToReflectionObjects
 
336
     * @expectedException PHPUnit_Framework_CodeCoverageException
 
337
     */
 
338
    public function testGetLinesToBeCovered2()
 
339
    {
 
340
        PHPUnit_Util_Test::getLinesToBeCovered(
 
341
            'NotExistingCoveredElementTest', 'testOne'
 
342
        );
 
343
    }
 
344
 
 
345
    /**
 
346
     * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 
347
     * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
348
     * @covers            PHPUnit_Util_Test::resolveElementToReflectionObjects
 
349
     * @expectedException PHPUnit_Framework_CodeCoverageException
 
350
     */
 
351
    public function testGetLinesToBeCovered3()
 
352
    {
 
353
        PHPUnit_Util_Test::getLinesToBeCovered(
 
354
            'NotExistingCoveredElementTest', 'testTwo'
 
355
        );
 
356
    }
 
357
 
 
358
    /**
 
359
     * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 
360
     * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
361
     * @covers            PHPUnit_Util_Test::resolveElementToReflectionObjects
 
362
     * @expectedException PHPUnit_Framework_CodeCoverageException
 
363
     */
 
364
    public function testGetLinesToBeCovered4()
 
365
    {
 
366
        PHPUnit_Util_Test::getLinesToBeCovered(
 
367
            'NotExistingCoveredElementTest', 'testThree'
 
368
        );
 
369
    }
 
370
 
 
371
    /**
 
372
     * @covers PHPUnit_Util_Test::getLinesToBeCovered
 
373
     * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
374
     */
 
375
    public function testGetLinesToBeCoveredSkipsNonExistantMethods()
 
376
    {
 
377
        $this->assertSame(
 
378
            array(),
 
379
            PHPUnit_Util_Test::getLinesToBeCovered(
 
380
                'NotExistingCoveredElementTest',
 
381
                'methodDoesNotExist'
 
382
            )
 
383
        );
 
384
    }
 
385
 
 
386
    /**
 
387
     * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 
388
     * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
389
     * @expectedException PHPUnit_Framework_CodeCoverageException
 
390
     */
 
391
    public function testTwoCoversDefaultClassAnnoationsAreNotAllowed()
 
392
    {
 
393
        PHPUnit_Util_Test::getLinesToBeCovered(
 
394
            'CoverageTwoDefaultClassAnnotations',
 
395
            'testSomething'
 
396
        );
 
397
    }
 
398
 
 
399
    /**
 
400
     * @covers PHPUnit_Util_Test::getLinesToBeCovered
 
401
     * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
402
     */
 
403
    public function testFunctionParenthesesAreAllowed()
 
404
    {
 
405
        $this->assertSame(
 
406
            array(TEST_FILES_PATH . 'CoveredFunction.php' => range(2, 4)),
 
407
            PHPUnit_Util_Test::getLinesToBeCovered(
 
408
                'CoverageFunctionParenthesesTest',
 
409
                'testSomething'
 
410
            )
 
411
        );
 
412
    }
 
413
 
 
414
    /**
 
415
     * @covers PHPUnit_Util_Test::getLinesToBeCovered
 
416
     * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
417
     */
 
418
    public function testFunctionParenthesesAreAllowedWithWhitespace()
 
419
    {
 
420
        $this->assertSame(
 
421
            array(TEST_FILES_PATH . 'CoveredFunction.php' => range(2, 4)),
 
422
            PHPUnit_Util_Test::getLinesToBeCovered(
 
423
                'CoverageFunctionParenthesesWhitespaceTest',
 
424
                'testSomething'
 
425
            )
 
426
        );
 
427
    }
 
428
 
 
429
    /**
 
430
     * @covers PHPUnit_Util_Test::getLinesToBeCovered
 
431
     * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
432
     */
 
433
    public function testMethodParenthesesAreAllowed()
 
434
    {
 
435
        $this->assertSame(
 
436
            array(TEST_FILES_PATH . 'CoveredClass.php' => range(31, 35)),
 
437
            PHPUnit_Util_Test::getLinesToBeCovered(
 
438
                'CoverageMethodParenthesesTest',
 
439
                'testSomething'
 
440
            )
 
441
        );
 
442
    }
 
443
 
 
444
    /**
 
445
     * @covers PHPUnit_Util_Test::getLinesToBeCovered
 
446
     * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 
447
     */
 
448
    public function testMethodParenthesesAreAllowedWithWhitespace()
 
449
    {
 
450
        $this->assertSame(
 
451
            array(TEST_FILES_PATH . 'CoveredClass.php' => range(31, 35)),
 
452
            PHPUnit_Util_Test::getLinesToBeCovered(
 
453
                'CoverageMethodParenthesesWhitespaceTest',
 
454
                'testSomething'
 
455
            )
 
456
        );
 
457
    }
 
458
 
 
459
    public function getLinesToBeCoveredProvider()
 
460
    {
 
461
        return array(
 
462
          array(
 
463
            'CoverageNoneTest',
 
464
            array()
 
465
          ),
 
466
          array(
 
467
            'CoverageClassExtendedTest',
 
468
            array_merge(range(19, 36), range(2, 17))
 
469
          ),
 
470
          array(
 
471
            'CoverageClassTest',
 
472
            range(19, 36)
 
473
          ),
 
474
          array(
 
475
            'CoverageMethodTest',
 
476
            range(31, 35)
 
477
          ),
 
478
          array(
 
479
            'CoverageMethodOneLineAnnotationTest',
 
480
            range(31, 35)
 
481
          ),
 
482
          array(
 
483
            'CoverageNotPrivateTest',
 
484
            array_merge(range(25, 29), range(31, 35))
 
485
          ),
 
486
          array(
 
487
            'CoverageNotProtectedTest',
 
488
            array_merge(range(21, 23), range(31, 35))
 
489
          ),
 
490
          array(
 
491
            'CoverageNotPublicTest',
 
492
            array_merge(range(21, 23), range(25, 29))
 
493
          ),
 
494
          array(
 
495
            'CoveragePrivateTest',
 
496
            range(21, 23)
 
497
          ),
 
498
          array(
 
499
            'CoverageProtectedTest',
 
500
            range(25, 29)
 
501
          ),
 
502
          array(
 
503
            'CoveragePublicTest',
 
504
            range(31, 35)
 
505
          ),
 
506
          array(
 
507
            'CoverageFunctionTest',
 
508
            range(2, 4)
 
509
          ),
 
510
          array(
 
511
            'NamespaceCoverageClassExtendedTest',
 
512
            array_merge(range(21, 38), range(4, 19))
 
513
          ),
 
514
          array(
 
515
            'NamespaceCoverageClassTest',
 
516
            range(21, 38)
 
517
          ),
 
518
          array(
 
519
            'NamespaceCoverageMethodTest',
 
520
            range(33, 37)
 
521
          ),
 
522
          array(
 
523
            'NamespaceCoverageNotPrivateTest',
 
524
            array_merge(range(27, 31), range(33, 37))
 
525
          ),
 
526
          array(
 
527
            'NamespaceCoverageNotProtectedTest',
 
528
            array_merge(range(23, 25), range(33, 37))
 
529
          ),
 
530
          array(
 
531
            'NamespaceCoverageNotPublicTest',
 
532
            array_merge(range(23, 25), range(27, 31))
 
533
          ),
 
534
          array(
 
535
            'NamespaceCoveragePrivateTest',
 
536
            range(23, 25)
 
537
          ),
 
538
          array(
 
539
            'NamespaceCoverageProtectedTest',
 
540
            range(27, 31)
 
541
          ),
 
542
          array(
 
543
            'NamespaceCoveragePublicTest',
 
544
            range(33, 37)
 
545
          ),
 
546
          array(
 
547
            'NamespaceCoverageCoversClassTest',
 
548
            array_merge(range(23, 25), range(27, 31), range(33, 37), range(6, 8), range(10, 13), range(15, 18))
 
549
          ),
 
550
          array(
 
551
            'NamespaceCoverageCoversClassPublicTest',
 
552
            range(33, 37)
 
553
          ),
 
554
          array(
 
555
            'CoverageNothingTest',
 
556
            false
 
557
          )
 
558
        );
 
559
    }
 
560
}