www.aleph1.co.uk Git - yaffs-website/blob - 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 require TEST_FILES_PATH . 'CoverageNamespacedFunctionTest.php';
  20 require TEST_FILES_PATH . 'NamespaceCoveredFunction.php';
  21
  22 /**
  23  * @since      Class available since Release 3.3.6
  24  */
  25 class Util_TestTest extends PHPUnit_Framework_TestCase
  26 {
  27     /**
  28      * @covers PHPUnit_Util_Test::getExpectedException
  29      *
  30      * @todo   Split up in separate tests
  31      */
  32     public function testGetExpectedException()
  33     {
  34         $this->assertArraySubset(
  35           array('class' => 'FooBarBaz', 'code' => null, 'message' => ''),
  36           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testOne')
  37         );
  38
  39         $this->assertArraySubset(
  40           array('class' => 'Foo_Bar_Baz', 'code' => null, 'message' => ''),
  41           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testTwo')
  42         );
  43
  44         $this->assertArraySubset(
  45           array('class' => 'Foo\Bar\Baz', 'code' => null, 'message' => ''),
  46           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testThree')
  47         );
  48
  49         $this->assertArraySubset(
  50           array('class' => 'ほげ', 'code' => null, 'message' => ''),
  51           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testFour')
  52         );
  53
  54         $this->assertArraySubset(
  55           array('class' => 'Class', 'code' => 1234, 'message' => 'Message'),
  56           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testFive')
  57         );
  58
  59         $this->assertArraySubset(
  60           array('class' => 'Class', 'code' => 1234, 'message' => 'Message'),
  61           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testSix')
  62         );
  63
  64         $this->assertArraySubset(
  65           array('class' => 'Class', 'code' => 'ExceptionCode', 'message' => 'Message'),
  66           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testSeven')
  67         );
  68
  69         $this->assertArraySubset(
  70           array('class' => 'Class', 'code' => 0, 'message' => 'Message'),
  71           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testEight')
  72         );
  73
  74         $this->assertArraySubset(
  75           array('class' => 'Class', 'code' => ExceptionTest::ERROR_CODE, 'message' => ExceptionTest::ERROR_MESSAGE),
  76           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testNine')
  77         );
  78
  79         $this->assertArraySubset(
  80           array('class' => 'Class', 'code' => null, 'message' => ''),
  81           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testSingleLine')
  82         );
  83
  84         $this->assertArraySubset(
  85           array('class' => 'Class', 'code' => My\Space\ExceptionNamespaceTest::ERROR_CODE, 'message' => My\Space\ExceptionNamespaceTest::ERROR_MESSAGE),
  86           PHPUnit_Util_Test::getExpectedException('My\Space\ExceptionNamespaceTest', 'testConstants')
  87         );
  88
  89         // Ensure the Class::CONST expression is only evaluated when the constant really exists
  90         $this->assertArraySubset(
  91           array('class' => 'Class', 'code' => 'ExceptionTest::UNKNOWN_CODE_CONSTANT', 'message' => 'ExceptionTest::UNKNOWN_MESSAGE_CONSTANT'),
  92           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testUnknownConstants')
  93         );
  94
  95         $this->assertArraySubset(
  96           array('class' => 'Class', 'code' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_CODE_CONSTANT', 'message' => 'My\Space\ExceptionNamespaceTest::UNKNOWN_MESSAGE_CONSTANT'),
  97           PHPUnit_Util_Test::getExpectedException('My\Space\ExceptionNamespaceTest', 'testUnknownConstants')
  98         );
  99     }
 100
 101     /**
 102      * @covers PHPUnit_Util_Test::getExpectedException
 103      */
 104     public function testGetExpectedRegExp()
 105     {
 106         $this->assertArraySubset(
 107           array('message_regex' => '#regex#'),
 108           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testWithRegexMessage')
 109         );
 110
 111         $this->assertArraySubset(
 112           array('message_regex' => '#regex#'),
 113           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testWithRegexMessageFromClassConstant')
 114         );
 115
 116         $this->assertArraySubset(
 117           array('message_regex' => 'ExceptionTest::UNKNOWN_MESSAGE_REGEX_CONSTANT'),
 118           PHPUnit_Util_Test::getExpectedException('ExceptionTest', 'testWithUnknowRegexMessageFromClassConstant')
 119         );
 120     }
 121
 122     /**
 123      * @covers       PHPUnit_Util_Test::getRequirements
 124      * @dataProvider requirementsProvider
 125      */
 126     public function testGetRequirements($test, $result)
 127     {
 128         $this->assertEquals(
 129             $result,
 130             PHPUnit_Util_Test::getRequirements('RequirementsTest', $test)
 131         );
 132     }
 133
 134     public function requirementsProvider()
 135     {
 136         return array(
 137             array('testOne',    array()),
 138             array('testTwo',    array('PHPUnit'    => '1.0')),
 139             array('testThree',  array('PHP'        => '2.0')),
 140             array('testFour',   array('PHPUnit'    => '2.0', 'PHP' => '1.0')),
 141             array('testFive',   array('PHP'        => '5.4.0RC6')),
 142             array('testSix',    array('PHP'        => '5.4.0-alpha1')),
 143             array('testSeven',  array('PHP'        => '5.4.0beta2')),
 144             array('testEight',  array('PHP'        => '5.4-dev')),
 145             array('testNine',   array('functions'  => array('testFunc'))),
 146             array('testTen',    array('extensions' => array('testExt'))),
 147             array('testEleven', array('OS'         => '/Linux/i')),
 148             array(
 149               'testSpace',
 150               array(
 151                 'extensions' => array('spl'),
 152                 'OS'         => '/.*/i'
 153               )
 154             ),
 155             array(
 156               'testAllPossibleRequirements',
 157               array(
 158                 'PHP'       => '99-dev',
 159                 'PHPUnit'   => '9-dev',
 160                 'OS'        => '/DOESNOTEXIST/i',
 161                 'functions' => array(
 162                   'testFuncOne',
 163                   'testFuncTwo',
 164                 ),
 165                 'extensions' => array(
 166                   'testExtOne',
 167                   'testExtTwo',
 168                 )
 169               )
 170             )
 171         );
 172     }
 173
 174     /**
 175      * @covers PHPUnit_Util_Test::getRequirements
 176      */
 177     public function testGetRequirementsMergesClassAndMethodDocBlocks()
 178     {
 179         $expectedAnnotations = array(
 180             'PHP'       => '5.4',
 181             'PHPUnit'   => '3.7',
 182             'OS'        => '/WINNT/i',
 183             'functions' => array(
 184               'testFuncClass',
 185               'testFuncMethod',
 186             ),
 187             'extensions' => array(
 188               'testExtClass',
 189               'testExtMethod',
 190             )
 191         );
 192
 193         $this->assertEquals(
 194             $expectedAnnotations,
 195             PHPUnit_Util_Test::getRequirements('RequirementsClassDocBlockTest', 'testMethod')
 196         );
 197     }
 198
 199     /**
 200      * @covers       PHPUnit_Util_Test::getMissingRequirements
 201      * @dataProvider missingRequirementsProvider
 202      */
 203     public function testGetMissingRequirements($test, $result)
 204     {
 205         $this->assertEquals(
 206             $result,
 207             PHPUnit_Util_Test::getMissingRequirements('RequirementsTest', $test)
 208         );
 209     }
 210
 211     public function missingRequirementsProvider()
 212     {
 213         return array(
 214             array('testOne',            array()),
 215             array('testNine',           array('Function testFunc is required.')),
 216             array('testTen',            array('Extension testExt is required.')),
 217             array('testAlwaysSkip',     array('PHPUnit 1111111 (or later) is required.')),
 218             array('testAlwaysSkip2',    array('PHP 9999999 (or later) is required.')),
 219             array('testAlwaysSkip3',    array('Operating system matching /DOESNOTEXIST/i is required.')),
 220             array('testAllPossibleRequirements', array(
 221               'PHP 99-dev (or later) is required.',
 222               'PHPUnit 9-dev (or later) is required.',
 223               'Operating system matching /DOESNOTEXIST/i is required.',
 224               'Function testFuncOne is required.',
 225               'Function testFuncTwo is required.',
 226               'Extension testExtOne is required.',
 227               'Extension testExtTwo is required.',
 228             )),
 229         );
 230     }
 231
 232     /**
 233      * @coversNothing
 234      *
 235      * @todo   This test does not really test functionality of PHPUnit_Util_Test
 236      */
 237     public function testGetProvidedDataRegEx()
 238     {
 239         $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider method', $matches);
 240         $this->assertEquals(1, $result);
 241         $this->assertEquals('method', $matches[1]);
 242
 243         $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider class::method', $matches);
 244         $this->assertEquals(1, $result);
 245         $this->assertEquals('class::method', $matches[1]);
 246
 247         $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\class::method', $matches);
 248         $this->assertEquals(1, $result);
 249         $this->assertEquals('namespace\class::method', $matches[1]);
 250
 251         $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider namespace\namespace\class::method', $matches);
 252         $this->assertEquals(1, $result);
 253         $this->assertEquals('namespace\namespace\class::method', $matches[1]);
 254
 255         $result = preg_match(PHPUnit_Util_Test::REGEX_DATA_PROVIDER, '@dataProvider メソッド', $matches);
 256         $this->assertEquals(1, $result);
 257         $this->assertEquals('メソッド', $matches[1]);
 258     }
 259
 260     /**
 261      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 262      */
 263     public function testTestWithEmptyAnnotation()
 264     {
 265         $result = PHPUnit_Util_Test::getDataFromTestWithAnnotation("/**\n * @anotherAnnotation\n */");
 266         $this->assertNull($result);
 267     }
 268
 269     /**
 270      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 271      */
 272     public function testTestWithSimpleCase()
 273     {
 274         $result = PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 275                                                                      * @testWith [1]
 276                                                                      */');
 277         $this->assertEquals(array(array(1)), $result);
 278     }
 279
 280     /**
 281      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 282      */
 283     public function testTestWithMultiLineMultiParameterCase()
 284     {
 285         $result = PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 286                                                                      * @testWith [1, 2]
 287                                                                      * [3, 4]
 288                                                                      */');
 289         $this->assertEquals(array(array(1, 2), array(3, 4)), $result);
 290     }
 291
 292     /**
 293      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 294      */
 295     public function testTestWithVariousTypes()
 296     {
 297         $result = PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 298             * @testWith ["ab"]
 299             *           [true]
 300             *           [null]
 301          */');
 302         $this->assertEquals(array(array('ab'), array(true), array(null)), $result);
 303     }
 304
 305     /**
 306      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 307      */
 308     public function testTestWithAnnotationAfter()
 309     {
 310         $result = PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 311                                                                      * @testWith [1]
 312                                                                      *           [2]
 313                                                                      * @annotation
 314                                                                      */');
 315         $this->assertEquals(array(array(1), array(2)), $result);
 316     }
 317
 318     /**
 319      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 320      */
 321     public function testTestWithSimpleTextAfter()
 322     {
 323         $result = PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 324                                                                      * @testWith [1]
 325                                                                      *           [2]
 326                                                                      * blah blah
 327                                                                      */');
 328         $this->assertEquals(array(array(1), array(2)), $result);
 329     }
 330
 331     /**
 332      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 333      */
 334     public function testTestWithCharacterEscape()
 335     {
 336         $result = PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 337                                                                      * @testWith ["\"", "\""]
 338                                                                      */');
 339         $this->assertEquals(array(array('"', '"')), $result);
 340     }
 341
 342     /**
 343      * @covers PHPUnit_Util_Test::getDataFromTestWithAnnotation
 344      */
 345     public function testTestWithThrowsProperExceptionIfDatasetCannotBeParsed()
 346     {
 347         $this->setExpectedExceptionRegExp(
 348             'PHPUnit_Framework_Exception',
 349             '/^The dataset for the @testWith annotation cannot be parsed:/'
 350         );
 351         PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 352                                                            * @testWith [s]
 353                                                            */');
 354     }
 355
 356     public function testTestWithThrowsProperExceptionIfMultiLineDatasetCannotBeParsed()
 357     {
 358         $this->setExpectedExceptionRegExp(
 359             'PHPUnit_Framework_Exception',
 360             '/^The dataset for the @testWith annotation cannot be parsed:/'
 361         );
 362         PHPUnit_Util_Test::getDataFromTestWithAnnotation('/**
 363                                                            * @testWith ["valid"]
 364                                                            *           [invalid]
 365                                                            */');
 366     }
 367
 368     /**
 369      * @covers PHPUnit_Util_Test::getDependencies
 370      *
 371      * @todo   Not sure what this test tests (name is misleading at least)
 372      */
 373     public function testParseAnnotation()
 374     {
 375         $this->assertEquals(
 376             array('Foo', 'ほげ'),
 377             PHPUnit_Util_Test::getDependencies(get_class($this), 'methodForTestParseAnnotation')
 378         );
 379     }
 380
 381     /**
 382      * @depends Foo
 383      * @depends ほげ
 384      *
 385      * @todo    Remove fixture from test class
 386      */
 387     public function methodForTestParseAnnotation()
 388     {
 389     }
 390
 391     /**
 392      * @covers PHPUnit_Util_Test::getDependencies
 393      */
 394     public function testParseAnnotationThatIsOnlyOneLine()
 395     {
 396         $this->assertEquals(
 397             array('Bar'),
 398             PHPUnit_Util_Test::getDependencies(get_class($this), 'methodForTestParseAnnotationThatIsOnlyOneLine')
 399         );
 400     }
 401
 402     /** @depends Bar */
 403     public function methodForTestParseAnnotationThatIsOnlyOneLine()
 404     {
 405         // TODO Remove fixture from test class
 406     }
 407
 408     /**
 409      * @covers       PHPUnit_Util_Test::getLinesToBeCovered
 410      * @covers       PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 411      * @covers       PHPUnit_Util_Test::resolveElementToReflectionObjects
 412      * @dataProvider getLinesToBeCoveredProvider
 413      */
 414     public function testGetLinesToBeCovered($test, $lines)
 415     {
 416         if (strpos($test, 'Namespace') === 0) {
 417             $expected = array(
 418               TEST_FILES_PATH . 'NamespaceCoveredClass.php' => $lines
 419             );
 420         } elseif ($test === 'CoverageNoneTest') {
 421             $expected = array();
 422         } elseif ($test === 'CoverageNothingTest') {
 423             $expected = false;
 424         } elseif ($test === 'CoverageFunctionTest') {
 425             $expected = array(
 426               TEST_FILES_PATH . 'CoveredFunction.php' => $lines
 427             );
 428         } else {
 429             $expected = array(TEST_FILES_PATH . 'CoveredClass.php' => $lines);
 430         }
 431
 432         $this->assertEquals(
 433             $expected,
 434             PHPUnit_Util_Test::getLinesToBeCovered(
 435                 $test, 'testSomething'
 436             )
 437         );
 438     }
 439
 440     /**
 441      * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 442      * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 443      * @covers            PHPUnit_Util_Test::resolveElementToReflectionObjects
 444      * @expectedException PHPUnit_Framework_CodeCoverageException
 445      */
 446     public function testGetLinesToBeCovered2()
 447     {
 448         PHPUnit_Util_Test::getLinesToBeCovered(
 449             'NotExistingCoveredElementTest', 'testOne'
 450         );
 451     }
 452
 453     /**
 454      * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 455      * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 456      * @covers            PHPUnit_Util_Test::resolveElementToReflectionObjects
 457      * @expectedException PHPUnit_Framework_CodeCoverageException
 458      */
 459     public function testGetLinesToBeCovered3()
 460     {
 461         PHPUnit_Util_Test::getLinesToBeCovered(
 462             'NotExistingCoveredElementTest', 'testTwo'
 463         );
 464     }
 465
 466     /**
 467      * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 468      * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 469      * @covers            PHPUnit_Util_Test::resolveElementToReflectionObjects
 470      * @expectedException PHPUnit_Framework_CodeCoverageException
 471      */
 472     public function testGetLinesToBeCovered4()
 473     {
 474         PHPUnit_Util_Test::getLinesToBeCovered(
 475             'NotExistingCoveredElementTest', 'testThree'
 476         );
 477     }
 478
 479     /**
 480      * @covers PHPUnit_Util_Test::getLinesToBeCovered
 481      * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 482      */
 483     public function testGetLinesToBeCoveredSkipsNonExistentMethods()
 484     {
 485         $this->assertSame(
 486             array(),
 487             PHPUnit_Util_Test::getLinesToBeCovered(
 488                 'NotExistingCoveredElementTest',
 489                 'methodDoesNotExist'
 490             )
 491         );
 492     }
 493
 494     /**
 495      * @covers            PHPUnit_Util_Test::getLinesToBeCovered
 496      * @covers            PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 497      * @expectedException PHPUnit_Framework_CodeCoverageException
 498      */
 499     public function testTwoCoversDefaultClassAnnoationsAreNotAllowed()
 500     {
 501         PHPUnit_Util_Test::getLinesToBeCovered(
 502             'CoverageTwoDefaultClassAnnotations',
 503             'testSomething'
 504         );
 505     }
 506
 507     /**
 508      * @covers PHPUnit_Util_Test::getLinesToBeCovered
 509      * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 510      */
 511     public function testFunctionParenthesesAreAllowed()
 512     {
 513         $this->assertSame(
 514             array(TEST_FILES_PATH . 'CoveredFunction.php' => range(2, 4)),
 515             PHPUnit_Util_Test::getLinesToBeCovered(
 516                 'CoverageFunctionParenthesesTest',
 517                 'testSomething'
 518             )
 519         );
 520     }
 521
 522     /**
 523      * @covers PHPUnit_Util_Test::getLinesToBeCovered
 524      * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 525      */
 526     public function testFunctionParenthesesAreAllowedWithWhitespace()
 527     {
 528         $this->assertSame(
 529             array(TEST_FILES_PATH . 'CoveredFunction.php' => range(2, 4)),
 530             PHPUnit_Util_Test::getLinesToBeCovered(
 531                 'CoverageFunctionParenthesesWhitespaceTest',
 532                 'testSomething'
 533             )
 534         );
 535     }
 536
 537     /**
 538      * @covers PHPUnit_Util_Test::getLinesToBeCovered
 539      * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 540      */
 541     public function testMethodParenthesesAreAllowed()
 542     {
 543         $this->assertSame(
 544             array(TEST_FILES_PATH . 'CoveredClass.php' => range(31, 35)),
 545             PHPUnit_Util_Test::getLinesToBeCovered(
 546                 'CoverageMethodParenthesesTest',
 547                 'testSomething'
 548             )
 549         );
 550     }
 551
 552     /**
 553      * @covers PHPUnit_Util_Test::getLinesToBeCovered
 554      * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 555      */
 556     public function testMethodParenthesesAreAllowedWithWhitespace()
 557     {
 558         $this->assertSame(
 559             array(TEST_FILES_PATH . 'CoveredClass.php' => range(31, 35)),
 560             PHPUnit_Util_Test::getLinesToBeCovered(
 561                 'CoverageMethodParenthesesWhitespaceTest',
 562                 'testSomething'
 563             )
 564         );
 565     }
 566
 567     /**
 568      * @covers PHPUnit_Util_Test::getLinesToBeCovered
 569      * @covers PHPUnit_Util_Test::getLinesToBeCoveredOrUsed
 570      */
 571     public function testNamespacedFunctionCanBeCoveredOrUsed()
 572     {
 573         $this->assertEquals(
 574             array(
 575                 TEST_FILES_PATH . 'NamespaceCoveredFunction.php' => range(4, 7)
 576             ),
 577             PHPUnit_Util_Test::getLinesToBeCovered(
 578                 'CoverageNamespacedFunctionTest',
 579                 'testFunc'
 580             )
 581         );
 582     }
 583
 584     public function getLinesToBeCoveredProvider()
 585     {
 586         return array(
 587           array(
 588             'CoverageNoneTest',
 589             array()
 590           ),
 591           array(
 592             'CoverageClassExtendedTest',
 593             array_merge(range(19, 36), range(2, 17))
 594           ),
 595           array(
 596             'CoverageClassTest',
 597             range(19, 36)
 598           ),
 599           array(
 600             'CoverageMethodTest',
 601             range(31, 35)
 602           ),
 603           array(
 604             'CoverageMethodOneLineAnnotationTest',
 605             range(31, 35)
 606           ),
 607           array(
 608             'CoverageNotPrivateTest',
 609             array_merge(range(25, 29), range(31, 35))
 610           ),
 611           array(
 612             'CoverageNotProtectedTest',
 613             array_merge(range(21, 23), range(31, 35))
 614           ),
 615           array(
 616             'CoverageNotPublicTest',
 617             array_merge(range(21, 23), range(25, 29))
 618           ),
 619           array(
 620             'CoveragePrivateTest',
 621             range(21, 23)
 622           ),
 623           array(
 624             'CoverageProtectedTest',
 625             range(25, 29)
 626           ),
 627           array(
 628             'CoveragePublicTest',
 629             range(31, 35)
 630           ),
 631           array(
 632             'CoverageFunctionTest',
 633             range(2, 4)
 634           ),
 635           array(
 636             'NamespaceCoverageClassExtendedTest',
 637             array_merge(range(21, 38), range(4, 19))
 638           ),
 639           array(
 640             'NamespaceCoverageClassTest',
 641             range(21, 38)
 642           ),
 643           array(
 644             'NamespaceCoverageMethodTest',
 645             range(33, 37)
 646           ),
 647           array(
 648             'NamespaceCoverageNotPrivateTest',
 649             array_merge(range(27, 31), range(33, 37))
 650           ),
 651           array(
 652             'NamespaceCoverageNotProtectedTest',
 653             array_merge(range(23, 25), range(33, 37))
 654           ),
 655           array(
 656             'NamespaceCoverageNotPublicTest',
 657             array_merge(range(23, 25), range(27, 31))
 658           ),
 659           array(
 660             'NamespaceCoveragePrivateTest',
 661             range(23, 25)
 662           ),
 663           array(
 664             'NamespaceCoverageProtectedTest',
 665             range(27, 31)
 666           ),
 667           array(
 668             'NamespaceCoveragePublicTest',
 669             range(33, 37)
 670           ),
 671           array(
 672             'NamespaceCoverageCoversClassTest',
 673             array_merge(range(23, 25), range(27, 31), range(33, 37), range(6, 8), range(10, 13), range(15, 18))
 674           ),
 675           array(
 676             'NamespaceCoverageCoversClassPublicTest',
 677             range(33, 37)
 678           ),
 679           array(
 680             'CoverageNothingTest',
 681             false
 682           )
 683         );
 684     }
 685 }