← Back to branch summary

~canonical-sysadmins/wordpress/openstack-objectstorage-k8s

« back to all changes in this revision

Viewing changes to vendor/phpunit/php-code-coverage/tests/PHP/CodeCoverage/FilterTest.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/php-code-coverage/tests/PHP/CodeCoverage/FilterTest.php
 
1
<?php
 
2
/*
 
3
 * This file is part of the PHP_CodeCoverage 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
if (!defined('TEST_FILES_PATH')) {
 
12
    define(
 
13
      'TEST_FILES_PATH',
 
14
      dirname(dirname(dirname(__FILE__))) . DIRECTORY_SEPARATOR .
 
15
      '_files' . DIRECTORY_SEPARATOR
 
16
    );
 
17
}
 
18
 
 
19
/**
 
20
 * Tests for the PHP_CodeCoverage_Filter class.
 
21
 *
 
22
 * @category   PHP
 
23
 * @package    CodeCoverage
 
24
 * @subpackage Tests
 
25
 * @author     Sebastian Bergmann <sebastian@phpunit.de>
 
26
 * @copyright  Sebastian Bergmann <sebastian@phpunit.de>
 
27
 * @license    http://www.opensource.org/licenses/BSD-3-Clause  The BSD 3-Clause License
 
28
 * @link       http://github.com/sebastianbergmann/php-code-coverage
 
29
 * @since      Class available since Release 1.0.0
 
30
 */
 
31
class PHP_CodeCoverage_FilterTest extends PHPUnit_Framework_TestCase
 
32
{
 
33
    protected $filter;
 
34
    protected $files;
 
35
 
 
36
    protected function setUp()
 
37
    {
 
38
        $this->filter = unserialize('O:23:"PHP_CodeCoverage_Filter":0:{}');
 
39
 
 
40
        $this->files = array(
 
41
          TEST_FILES_PATH . 'BankAccount.php',
 
42
          TEST_FILES_PATH . 'BankAccountTest.php',
 
43
          TEST_FILES_PATH . 'CoverageClassExtendedTest.php',
 
44
          TEST_FILES_PATH . 'CoverageClassTest.php',
 
45
          TEST_FILES_PATH . 'CoverageFunctionParenthesesTest.php',
 
46
          TEST_FILES_PATH . 'CoverageFunctionParenthesesWhitespaceTest.php',
 
47
          TEST_FILES_PATH . 'CoverageFunctionTest.php',
 
48
          TEST_FILES_PATH . 'CoverageMethodOneLineAnnotationTest.php',
 
49
          TEST_FILES_PATH . 'CoverageMethodParenthesesTest.php',
 
50
          TEST_FILES_PATH . 'CoverageMethodParenthesesWhitespaceTest.php',
 
51
          TEST_FILES_PATH . 'CoverageMethodTest.php',
 
52
          TEST_FILES_PATH . 'CoverageNoneTest.php',
 
53
          TEST_FILES_PATH . 'CoverageNotPrivateTest.php',
 
54
          TEST_FILES_PATH . 'CoverageNotProtectedTest.php',
 
55
          TEST_FILES_PATH . 'CoverageNotPublicTest.php',
 
56
          TEST_FILES_PATH . 'CoverageNothingTest.php',
 
57
          TEST_FILES_PATH . 'CoveragePrivateTest.php',
 
58
          TEST_FILES_PATH . 'CoverageProtectedTest.php',
 
59
          TEST_FILES_PATH . 'CoveragePublicTest.php',
 
60
          TEST_FILES_PATH . 'CoverageTwoDefaultClassAnnotations.php',
 
61
          TEST_FILES_PATH . 'CoveredClass.php',
 
62
          TEST_FILES_PATH . 'CoveredFunction.php',
 
63
          TEST_FILES_PATH . 'NamespaceCoverageClassExtendedTest.php',
 
64
          TEST_FILES_PATH . 'NamespaceCoverageClassTest.php',
 
65
          TEST_FILES_PATH . 'NamespaceCoverageCoversClassPublicTest.php',
 
66
          TEST_FILES_PATH . 'NamespaceCoverageCoversClassTest.php',
 
67
          TEST_FILES_PATH . 'NamespaceCoverageMethodTest.php',
 
68
          TEST_FILES_PATH . 'NamespaceCoverageNotPrivateTest.php',
 
69
          TEST_FILES_PATH . 'NamespaceCoverageNotProtectedTest.php',
 
70
          TEST_FILES_PATH . 'NamespaceCoverageNotPublicTest.php',
 
71
          TEST_FILES_PATH . 'NamespaceCoveragePrivateTest.php',
 
72
          TEST_FILES_PATH . 'NamespaceCoverageProtectedTest.php',
 
73
          TEST_FILES_PATH . 'NamespaceCoveragePublicTest.php',
 
74
          TEST_FILES_PATH . 'NamespaceCoveredClass.php',
 
75
          TEST_FILES_PATH . 'NotExistingCoveredElementTest.php',
 
76
          TEST_FILES_PATH . 'source_with_class_and_anonymous_function.php',
 
77
          TEST_FILES_PATH . 'source_with_ignore.php',
 
78
          TEST_FILES_PATH . 'source_with_namespace.php',
 
79
          TEST_FILES_PATH . 'source_with_oneline_annotations.php',
 
80
          TEST_FILES_PATH . 'source_without_ignore.php',
 
81
          TEST_FILES_PATH . 'source_without_namespace.php'
 
82
        );
 
83
    }
 
84
 
 
85
    /**
 
86
     * @covers PHP_CodeCoverage_Filter::addFileToBlacklist
 
87
     * @covers PHP_CodeCoverage_Filter::getBlacklist
 
88
     */
 
89
    public function testAddingAFileToTheBlacklistWorks()
 
90
    {
 
91
        $this->filter->addFileToBlacklist($this->files[0]);
 
92
 
 
93
        $this->assertEquals(
 
94
          array($this->files[0]), $this->filter->getBlacklist()
 
95
        );
 
96
    }
 
97
 
 
98
    /**
 
99
     * @covers PHP_CodeCoverage_Filter::removeFileFromBlacklist
 
100
     * @covers PHP_CodeCoverage_Filter::getBlacklist
 
101
     */
 
102
    public function testRemovingAFileFromTheBlacklistWorks()
 
103
    {
 
104
        $this->filter->addFileToBlacklist($this->files[0]);
 
105
        $this->filter->removeFileFromBlacklist($this->files[0]);
 
106
 
 
107
        $this->assertEquals(array(), $this->filter->getBlacklist());
 
108
    }
 
109
 
 
110
    /**
 
111
     * @covers  PHP_CodeCoverage_Filter::addDirectoryToBlacklist
 
112
     * @covers  PHP_CodeCoverage_Filter::getBlacklist
 
113
     * @depends testAddingAFileToTheBlacklistWorks
 
114
     */
 
115
    public function testAddingADirectoryToTheBlacklistWorks()
 
116
    {
 
117
        $this->filter->addDirectoryToBlacklist(TEST_FILES_PATH);
 
118
 
 
119
        $blacklist = $this->filter->getBlacklist();
 
120
        sort($blacklist);
 
121
 
 
122
        $this->assertEquals($this->files, $blacklist);
 
123
    }
 
124
 
 
125
    /**
 
126
     * @covers PHP_CodeCoverage_Filter::addFilesToBlacklist
 
127
     * @covers PHP_CodeCoverage_Filter::getBlacklist
 
128
     */
 
129
    public function testAddingFilesToTheBlacklistWorks()
 
130
    {
 
131
        $facade = new File_Iterator_Facade;
 
132
        $files  = $facade->getFilesAsArray(
 
133
          TEST_FILES_PATH, $suffixes = '.php'
 
134
        );
 
135
 
 
136
        $this->filter->addFilesToBlacklist($files);
 
137
 
 
138
        $blacklist = $this->filter->getBlacklist();
 
139
        sort($blacklist);
 
140
 
 
141
        $this->assertEquals($this->files, $blacklist);
 
142
    }
 
143
 
 
144
    /**
 
145
     * @covers  PHP_CodeCoverage_Filter::removeDirectoryFromBlacklist
 
146
     * @covers  PHP_CodeCoverage_Filter::getBlacklist
 
147
     * @depends testAddingADirectoryToTheBlacklistWorks
 
148
     */
 
149
    public function testRemovingADirectoryFromTheBlacklistWorks()
 
150
    {
 
151
        $this->filter->addDirectoryToBlacklist(TEST_FILES_PATH);
 
152
        $this->filter->removeDirectoryFromBlacklist(TEST_FILES_PATH);
 
153
 
 
154
        $this->assertEquals(array(), $this->filter->getBlacklist());
 
155
    }
 
156
 
 
157
    /**
 
158
     * @covers PHP_CodeCoverage_Filter::addFileToWhitelist
 
159
     * @covers PHP_CodeCoverage_Filter::getWhitelist
 
160
     */
 
161
    public function testAddingAFileToTheWhitelistWorks()
 
162
    {
 
163
        $this->filter->addFileToWhitelist($this->files[0]);
 
164
 
 
165
        $this->assertEquals(
 
166
          array($this->files[0]), $this->filter->getWhitelist()
 
167
        );
 
168
    }
 
169
 
 
170
    /**
 
171
     * @covers PHP_CodeCoverage_Filter::removeFileFromWhitelist
 
172
     * @covers PHP_CodeCoverage_Filter::getWhitelist
 
173
     */
 
174
    public function testRemovingAFileFromTheWhitelistWorks()
 
175
    {
 
176
        $this->filter->addFileToWhitelist($this->files[0]);
 
177
        $this->filter->removeFileFromWhitelist($this->files[0]);
 
178
 
 
179
        $this->assertEquals(array(), $this->filter->getWhitelist());
 
180
    }
 
181
 
 
182
    /**
 
183
     * @covers  PHP_CodeCoverage_Filter::addDirectoryToWhitelist
 
184
     * @covers  PHP_CodeCoverage_Filter::getWhitelist
 
185
     * @depends testAddingAFileToTheWhitelistWorks
 
186
     */
 
187
    public function testAddingADirectoryToTheWhitelistWorks()
 
188
    {
 
189
        $this->filter->addDirectoryToWhitelist(TEST_FILES_PATH);
 
190
 
 
191
        $whitelist = $this->filter->getWhitelist();
 
192
        sort($whitelist);
 
193
 
 
194
        $this->assertEquals($this->files, $whitelist);
 
195
    }
 
196
 
 
197
    /**
 
198
     * @covers PHP_CodeCoverage_Filter::addFilesToWhitelist
 
199
     * @covers PHP_CodeCoverage_Filter::getBlacklist
 
200
     */
 
201
    public function testAddingFilesToTheWhitelistWorks()
 
202
    {
 
203
        $facade = new File_Iterator_Facade;
 
204
        $files  = $facade->getFilesAsArray(
 
205
          TEST_FILES_PATH, $suffixes = '.php'
 
206
        );
 
207
 
 
208
        $this->filter->addFilesToWhitelist($files);
 
209
 
 
210
        $whitelist = $this->filter->getWhitelist();
 
211
        sort($whitelist);
 
212
 
 
213
        $this->assertEquals($this->files, $whitelist);
 
214
    }
 
215
 
 
216
    /**
 
217
     * @covers  PHP_CodeCoverage_Filter::removeDirectoryFromWhitelist
 
218
     * @covers  PHP_CodeCoverage_Filter::getWhitelist
 
219
     * @depends testAddingADirectoryToTheWhitelistWorks
 
220
     */
 
221
    public function testRemovingADirectoryFromTheWhitelistWorks()
 
222
    {
 
223
        $this->filter->addDirectoryToWhitelist(TEST_FILES_PATH);
 
224
        $this->filter->removeDirectoryFromWhitelist(TEST_FILES_PATH);
 
225
 
 
226
        $this->assertEquals(array(), $this->filter->getWhitelist());
 
227
    }
 
228
 
 
229
    /**
 
230
     * @covers PHP_CodeCoverage_Filter::isFile
 
231
     */
 
232
    public function testIsFile()
 
233
    {
 
234
        $this->assertFalse($this->filter->isFile('vfs://root/a/path'));
 
235
        $this->assertFalse($this->filter->isFile('xdebug://debug-eval'));
 
236
        $this->assertFalse($this->filter->isFile('eval()\'d code'));
 
237
        $this->assertFalse($this->filter->isFile('runtime-created function'));
 
238
        $this->assertFalse($this->filter->isFile('assert code'));
 
239
        $this->assertFalse($this->filter->isFile('regexp code'));
 
240
        $this->assertTrue($this->filter->isFile(__FILE__));
 
241
    }
 
242
 
 
243
    /**
 
244
     * @covers PHP_CodeCoverage_Filter::isFiltered
 
245
     */
 
246
    public function testBlacklistedFileIsFiltered()
 
247
    {
 
248
        $this->filter->addFileToBlacklist($this->files[0]);
 
249
        $this->assertTrue($this->filter->isFiltered($this->files[0]));
 
250
    }
 
251
 
 
252
    /**
 
253
     * @covers PHP_CodeCoverage_Filter::isFiltered
 
254
     */
 
255
    public function testWhitelistedFileIsNotFiltered()
 
256
    {
 
257
        $this->filter->addFileToWhitelist($this->files[0]);
 
258
        $this->assertFalse($this->filter->isFiltered($this->files[0]));
 
259
    }
 
260
 
 
261
    /**
 
262
     * @covers PHP_CodeCoverage_Filter::isFiltered
 
263
     */
 
264
    public function testNotWhitelistedFileIsFiltered()
 
265
    {
 
266
        $this->filter->addFileToWhitelist($this->files[0]);
 
267
        $this->assertTrue($this->filter->isFiltered($this->files[1]));
 
268
    }
 
269
 
 
270
    /**
 
271
     * @covers PHP_CodeCoverage_Filter::isFiltered
 
272
     * @covers PHP_CodeCoverage_Filter::isFile
 
273
     */
 
274
    public function testNonFilesAreFiltered()
 
275
    {
 
276
        $this->assertTrue($this->filter->isFiltered('vfs://root/a/path'));
 
277
        $this->assertTrue($this->filter->isFiltered('xdebug://debug-eval'));
 
278
        $this->assertTrue($this->filter->isFiltered('eval()\'d code'));
 
279
        $this->assertTrue($this->filter->isFiltered('runtime-created function'));
 
280
        $this->assertTrue($this->filter->isFiltered('assert code'));
 
281
        $this->assertTrue($this->filter->isFiltered('regexp code'));
 
282
        $this->assertFalse($this->filter->isFiltered(__FILE__));
 
283
    }
 
284
}