vendor/phpunit/php-code-coverage/tests/TestCase.php

   1 <?php
   2 /*
   3  * This file is part of the php-code-coverage package.
   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 namespace SebastianBergmann\CodeCoverage;
  12
  13 use SebastianBergmann\CodeCoverage\Driver\Driver;
  14 use SebastianBergmann\CodeCoverage\Report\Xml\Coverage;
  15
  16 abstract class TestCase extends \PHPUnit\Framework\TestCase
  17 {
  18     protected static $TEST_TMP_PATH;
  19
  20     public static function setUpBeforeClass(): void
  21     {
  22         self::$TEST_TMP_PATH = TEST_FILES_PATH . 'tmp';
  23     }
  24
  25     protected function getXdebugDataForBankAccount()
  26     {
  27         return [
  28             [
  29                 TEST_FILES_PATH . 'BankAccount.php' => [
  30                     8  => 1,
  31                     9  => -2,
  32                     13 => -1,
  33                     14 => -1,
  34                     15 => -1,
  35                     16 => -1,
  36                     18 => -1,
  37                     22 => -1,
  38                     24 => -1,
  39                     25 => -2,
  40                     29 => -1,
  41                     31 => -1,
  42                     32 => -2
  43                 ]
  44             ],
  45             [
  46                 TEST_FILES_PATH . 'BankAccount.php' => [
  47                     8  => 1,
  48                     13 => 1,
  49                     16 => 1,
  50                     29 => 1,
  51                 ]
  52             ],
  53             [
  54                 TEST_FILES_PATH . 'BankAccount.php' => [
  55                     8  => 1,
  56                     13 => 1,
  57                     16 => 1,
  58                     22 => 1,
  59                 ]
  60             ],
  61             [
  62                 TEST_FILES_PATH . 'BankAccount.php' => [
  63                     8  => 1,
  64                     13 => 1,
  65                     14 => 1,
  66                     15 => 1,
  67                     18 => 1,
  68                     22 => 1,
  69                     24 => 1,
  70                     29 => 1,
  71                     31 => 1,
  72                 ]
  73             ]
  74         ];
  75     }
  76
  77     protected function getCoverageForBankAccount(): CodeCoverage
  78     {
  79         $data = $this->getXdebugDataForBankAccount();
  80
  81         $stub = $this->createMock(Driver::class);
  82
  83         $stub->expects($this->any())
  84             ->method('stop')
  85             ->will($this->onConsecutiveCalls(
  86                 $data[0],
  87                 $data[1],
  88                 $data[2],
  89                 $data[3]
  90             ));
  91
  92         $filter = new Filter;
  93         $filter->addFileToWhitelist(TEST_FILES_PATH . 'BankAccount.php');
  94
  95         $coverage = new CodeCoverage($stub, $filter);
  96
  97         $coverage->start(
  98             new \BankAccountTest('testBalanceIsInitiallyZero'),
  99             true
 100         );
 101
 102         $coverage->stop(
 103             true,
 104             [TEST_FILES_PATH . 'BankAccount.php' => range(6, 9)]
 105         );
 106
 107         $coverage->start(
 108             new \BankAccountTest('testBalanceCannotBecomeNegative')
 109         );
 110
 111         $coverage->stop(
 112             true,
 113             [TEST_FILES_PATH . 'BankAccount.php' => range(27, 32)]
 114         );
 115
 116         $coverage->start(
 117             new \BankAccountTest('testBalanceCannotBecomeNegative2')
 118         );
 119
 120         $coverage->stop(
 121             true,
 122             [TEST_FILES_PATH . 'BankAccount.php' => range(20, 25)]
 123         );
 124
 125         $coverage->start(
 126             new \BankAccountTest('testDepositWithdrawMoney')
 127         );
 128
 129         $coverage->stop(
 130             true,
 131             [
 132                 TEST_FILES_PATH . 'BankAccount.php' => array_merge(
 133                     range(6, 9),
 134                     range(20, 25),
 135                     range(27, 32)
 136                 )
 137             ]
 138         );
 139
 140         return $coverage;
 141     }
 142
 143     protected function getCoverageForBankAccountForFirstTwoTests(): CodeCoverage
 144     {
 145         $data = $this->getXdebugDataForBankAccount();
 146
 147         $stub = $this->createMock(Driver::class);
 148
 149         $stub->expects($this->any())
 150             ->method('stop')
 151             ->will($this->onConsecutiveCalls(
 152                 $data[0],
 153                 $data[1]
 154             ));
 155
 156         $filter = new Filter;
 157         $filter->addFileToWhitelist(TEST_FILES_PATH . 'BankAccount.php');
 158
 159         $coverage = new CodeCoverage($stub, $filter);
 160
 161         $coverage->start(
 162             new \BankAccountTest('testBalanceIsInitiallyZero'),
 163             true
 164         );
 165
 166         $coverage->stop(
 167             true,
 168             [TEST_FILES_PATH . 'BankAccount.php' => range(6, 9)]
 169         );
 170
 171         $coverage->start(
 172             new \BankAccountTest('testBalanceCannotBecomeNegative')
 173         );
 174
 175         $coverage->stop(
 176             true,
 177             [TEST_FILES_PATH . 'BankAccount.php' => range(27, 32)]
 178         );
 179
 180         return $coverage;
 181     }
 182
 183     protected function getCoverageForBankAccountForLastTwoTests()
 184     {
 185         $data = $this->getXdebugDataForBankAccount();
 186
 187         $stub = $this->createMock(Driver::class);
 188
 189         $stub->expects($this->any())
 190             ->method('stop')
 191             ->will($this->onConsecutiveCalls(
 192                 $data[2],
 193                 $data[3]
 194             ));
 195
 196         $filter = new Filter;
 197         $filter->addFileToWhitelist(TEST_FILES_PATH . 'BankAccount.php');
 198
 199         $coverage = new CodeCoverage($stub, $filter);
 200
 201         $coverage->start(
 202             new \BankAccountTest('testBalanceCannotBecomeNegative2')
 203         );
 204
 205         $coverage->stop(
 206             true,
 207             [TEST_FILES_PATH . 'BankAccount.php' => range(20, 25)]
 208         );
 209
 210         $coverage->start(
 211             new \BankAccountTest('testDepositWithdrawMoney')
 212         );
 213
 214         $coverage->stop(
 215             true,
 216             [
 217                 TEST_FILES_PATH . 'BankAccount.php' => array_merge(
 218                     range(6, 9),
 219                     range(20, 25),
 220                     range(27, 32)
 221                 )
 222             ]
 223         );
 224
 225         return $coverage;
 226     }
 227
 228     protected function getExpectedDataArrayForBankAccount(): array
 229     {
 230         return [
 231             TEST_FILES_PATH . 'BankAccount.php' => [
 232                 8 => [
 233                     0 => 'BankAccountTest::testBalanceIsInitiallyZero',
 234                     1 => 'BankAccountTest::testDepositWithdrawMoney'
 235                 ],
 236                 9  => null,
 237                 13 => [],
 238                 14 => [],
 239                 15 => [],
 240                 16 => [],
 241                 18 => [],
 242                 22 => [
 243                     0 => 'BankAccountTest::testBalanceCannotBecomeNegative2',
 244                     1 => 'BankAccountTest::testDepositWithdrawMoney'
 245                 ],
 246                 24 => [
 247                     0 => 'BankAccountTest::testDepositWithdrawMoney',
 248                 ],
 249                 25 => null,
 250                 29 => [
 251                     0 => 'BankAccountTest::testBalanceCannotBecomeNegative',
 252                     1 => 'BankAccountTest::testDepositWithdrawMoney'
 253                 ],
 254                 31 => [
 255                     0 => 'BankAccountTest::testDepositWithdrawMoney'
 256                 ],
 257                 32 => null
 258             ]
 259         ];
 260     }
 261
 262     protected function getExpectedDataArrayForBankAccountInReverseOrder(): array
 263     {
 264         return [
 265             TEST_FILES_PATH . 'BankAccount.php' => [
 266                 8 => [
 267                     0 => 'BankAccountTest::testDepositWithdrawMoney',
 268                     1 => 'BankAccountTest::testBalanceIsInitiallyZero'
 269                 ],
 270                 9  => null,
 271                 13 => [],
 272                 14 => [],
 273                 15 => [],
 274                 16 => [],
 275                 18 => [],
 276                 22 => [
 277                     0 => 'BankAccountTest::testBalanceCannotBecomeNegative2',
 278                     1 => 'BankAccountTest::testDepositWithdrawMoney'
 279                 ],
 280                 24 => [
 281                     0 => 'BankAccountTest::testDepositWithdrawMoney',
 282                 ],
 283                 25 => null,
 284                 29 => [
 285                     0 => 'BankAccountTest::testDepositWithdrawMoney',
 286                     1 => 'BankAccountTest::testBalanceCannotBecomeNegative'
 287                 ],
 288                 31 => [
 289                     0 => 'BankAccountTest::testDepositWithdrawMoney'
 290                 ],
 291                 32 => null
 292             ]
 293         ];
 294     }
 295
 296     protected function getCoverageForFileWithIgnoredLines(): CodeCoverage
 297     {
 298         $filter = new Filter;
 299         $filter->addFileToWhitelist(TEST_FILES_PATH . 'source_with_ignore.php');
 300
 301         $coverage = new CodeCoverage(
 302             $this->setUpXdebugStubForFileWithIgnoredLines(),
 303             $filter
 304         );
 305
 306         $coverage->start('FileWithIgnoredLines', true);
 307         $coverage->stop();
 308
 309         return $coverage;
 310     }
 311
 312     protected function setUpXdebugStubForFileWithIgnoredLines(): Driver
 313     {
 314         $stub = $this->createMock(Driver::class);
 315
 316         $stub->expects($this->any())
 317             ->method('stop')
 318             ->will($this->returnValue(
 319                 [
 320                     TEST_FILES_PATH . 'source_with_ignore.php' => [
 321                         2 => 1,
 322                         4 => -1,
 323                         6 => -1,
 324                         7 => 1
 325                     ]
 326                 ]
 327             ));
 328
 329         return $stub;
 330     }
 331
 332     protected function getCoverageForClassWithAnonymousFunction(): CodeCoverage
 333     {
 334         $filter = new Filter;
 335         $filter->addFileToWhitelist(TEST_FILES_PATH . 'source_with_class_and_anonymous_function.php');
 336
 337         $coverage = new CodeCoverage(
 338             $this->setUpXdebugStubForClassWithAnonymousFunction(),
 339             $filter
 340         );
 341
 342         $coverage->start('ClassWithAnonymousFunction', true);
 343         $coverage->stop();
 344
 345         return $coverage;
 346     }
 347
 348     protected function setUpXdebugStubForClassWithAnonymousFunction(): Driver
 349     {
 350         $stub = $this->createMock(Driver::class);
 351
 352         $stub->expects($this->any())
 353             ->method('stop')
 354             ->will($this->returnValue(
 355                 [
 356                     TEST_FILES_PATH . 'source_with_class_and_anonymous_function.php' => [
 357                         7  => 1,
 358                         9  => 1,
 359                         10 => -1,
 360                         11 => 1,
 361                         12 => 1,
 362                         13 => 1,
 363                         14 => 1,
 364                         17 => 1,
 365                         18 => 1
 366                     ]
 367                 ]
 368             ));
 369
 370         return $stub;
 371     }
 372
 373     protected function getCoverageForCrashParsing(): CodeCoverage
 374     {
 375         $filter = new Filter;
 376         $filter->addFileToWhitelist(TEST_FILES_PATH . 'Crash.php');
 377
 378         // This is a file with invalid syntax, so it isn't executed.
 379         return new CodeCoverage(
 380             $this->setUpXdebugStubForCrashParsing(),
 381             $filter
 382         );
 383     }
 384
 385     protected function setUpXdebugStubForCrashParsing(): Driver
 386     {
 387         $stub = $this->createMock(Driver::class);
 388
 389         $stub->expects($this->any())
 390             ->method('stop')
 391             ->will($this->returnValue([]));
 392         return $stub;
 393     }
 394
 395 }