/vendor/phpunit/phpunit/tests/Util/TestTest.php

https://bitbucket.org/alan_cordova/api-sb-map · PHP · 823 lines · 703 code · 67 blank · 53 comment · 11 complexity · 8ca0cd7a872e3c3ebb68925178148b3b MD5 · raw file

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