← Back to branch summary

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

« back to all changes in this revision

Viewing changes to vendor/phpunit/phpunit/tests/Framework/ConstraintTest.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/Framework/ConstraintTest.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
/**
 
12
 *
 
13
 *
 
14
 * @package    PHPUnit
 
15
 * @author     Sebastian Bergmann <sebastian@phpunit.de>
 
16
 * @author     Bernhard Schussek <bschussek@2bepublished.at>
 
17
 * @copyright  Sebastian Bergmann <sebastian@phpunit.de>
 
18
 * @license    http://www.opensource.org/licenses/BSD-3-Clause  The BSD 3-Clause License
 
19
 * @link       http://www.phpunit.de/
 
20
 * @since      Class available since Release 3.0.0
 
21
 */
 
22
class Framework_ConstraintTest extends PHPUnit_Framework_TestCase
 
23
{
 
24
    /**
 
25
     * @covers PHPUnit_Framework_Constraint_ArrayHasKey
 
26
     * @covers PHPUnit_Framework_Assert::arrayHasKey
 
27
     * @covers PHPUnit_Framework_Constraint::count
 
28
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
29
     */
 
30
    public function testConstraintArrayHasKey()
 
31
    {
 
32
        $constraint = PHPUnit_Framework_Assert::arrayHasKey(0);
 
33
 
 
34
        $this->assertFalse($constraint->evaluate(array(), '', true));
 
35
        $this->assertEquals('has the key 0', $constraint->toString());
 
36
        $this->assertEquals(1, count($constraint));
 
37
 
 
38
        try {
 
39
            $constraint->evaluate(array());
 
40
        }
 
41
 
 
42
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
43
            $this->assertEquals(<<<EOF
 
44
Failed asserting that an array has the key 0.
 
45
 
 
46
EOF
 
47
              ,
 
48
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
49
            );
 
50
 
 
51
            return;
 
52
        }
 
53
 
 
54
        $this->fail();
 
55
    }
 
56
 
 
57
    /**
 
58
     * @covers PHPUnit_Framework_Constraint_ArrayHasKey
 
59
     * @covers PHPUnit_Framework_Assert::arrayHasKey
 
60
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
61
     */
 
62
    public function testConstraintArrayHasKey2()
 
63
    {
 
64
        $constraint = PHPUnit_Framework_Assert::arrayHasKey(0);
 
65
 
 
66
        try {
 
67
            $constraint->evaluate(array(), 'custom message');
 
68
        }
 
69
 
 
70
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
71
            $this->assertEquals(
 
72
              <<<EOF
 
73
custom message\nFailed asserting that an array has the key 0.
 
74
 
 
75
EOF
 
76
              ,
 
77
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
78
            );
 
79
 
 
80
            return;
 
81
        }
 
82
 
 
83
        $this->fail();
 
84
    }
 
85
 
 
86
    /**
 
87
     * @covers PHPUnit_Framework_Constraint_ArrayHasKey
 
88
     * @covers PHPUnit_Framework_Constraint_Not
 
89
     * @covers PHPUnit_Framework_Assert::arrayHasKey
 
90
     * @covers PHPUnit_Framework_Assert::logicalNot
 
91
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
92
     */
 
93
    public function testConstraintArrayNotHasKey()
 
94
    {
 
95
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
96
          PHPUnit_Framework_Assert::arrayHasKey(0)
 
97
        );
 
98
 
 
99
        $this->assertFalse($constraint->evaluate(array(0 => 1), '', true));
 
100
        $this->assertEquals('does not have the key 0', $constraint->toString());
 
101
        $this->assertEquals(1, count($constraint));
 
102
 
 
103
        try {
 
104
            $constraint->evaluate(array(0 => 1));
 
105
        }
 
106
 
 
107
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
108
            $this->assertEquals(
 
109
              <<<EOF
 
110
Failed asserting that an array does not have the key 0.
 
111
 
 
112
EOF
 
113
              ,
 
114
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
115
            );
 
116
 
 
117
            return;
 
118
        }
 
119
 
 
120
        $this->fail();
 
121
    }
 
122
 
 
123
    /**
 
124
     * @covers PHPUnit_Framework_Constraint_ArrayHasKey
 
125
     * @covers PHPUnit_Framework_Constraint_Not
 
126
     * @covers PHPUnit_Framework_Assert::arrayHasKey
 
127
     * @covers PHPUnit_Framework_Assert::logicalNot
 
128
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
129
     */
 
130
    public function testConstraintArrayNotHasKey2()
 
131
    {
 
132
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
133
          PHPUnit_Framework_Assert::arrayHasKey(0)
 
134
        );
 
135
 
 
136
        try {
 
137
            $constraint->evaluate(array(0), 'custom message');
 
138
        }
 
139
 
 
140
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
141
            $this->assertEquals(
 
142
              <<<EOF
 
143
custom message
 
144
Failed asserting that an array does not have the key 0.
 
145
 
 
146
EOF
 
147
              ,
 
148
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
149
            );
 
150
 
 
151
            return;
 
152
        }
 
153
 
 
154
        $this->fail();
 
155
    }
 
156
 
 
157
    /**
 
158
     * @covers PHPUnit_Framework_Constraint_FileExists
 
159
     * @covers PHPUnit_Framework_Assert::fileExists
 
160
     * @covers PHPUnit_Framework_Constraint::count
 
161
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
162
     */
 
163
    public function testConstraintFileExists()
 
164
    {
 
165
        $constraint = PHPUnit_Framework_Assert::fileExists();
 
166
 
 
167
        $this->assertFalse($constraint->evaluate('foo', '', true));
 
168
        $this->assertEquals('file exists', $constraint->toString());
 
169
        $this->assertEquals(1, count($constraint));
 
170
 
 
171
        try {
 
172
            $constraint->evaluate('foo');
 
173
        }
 
174
 
 
175
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
176
            $this->assertEquals(
 
177
              <<<EOF
 
178
Failed asserting that file "foo" exists.
 
179
 
 
180
EOF
 
181
              ,
 
182
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
183
            );
 
184
 
 
185
            return;
 
186
        }
 
187
 
 
188
        $this->fail();
 
189
    }
 
190
 
 
191
    /**
 
192
     * @covers PHPUnit_Framework_Constraint_FileExists
 
193
     * @covers PHPUnit_Framework_Assert::fileExists
 
194
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
195
     */
 
196
    public function testConstraintFileExists2()
 
197
    {
 
198
        $constraint = PHPUnit_Framework_Assert::fileExists();
 
199
 
 
200
        try {
 
201
            $constraint->evaluate('foo', 'custom message');
 
202
        }
 
203
 
 
204
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
205
            $this->assertEquals(<<<EOF
 
206
custom message
 
207
Failed asserting that file "foo" exists.
 
208
 
 
209
EOF
 
210
              ,
 
211
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
212
            );
 
213
 
 
214
            return;
 
215
        }
 
216
 
 
217
        $this->fail();
 
218
    }
 
219
 
 
220
    /**
 
221
     * @covers PHPUnit_Framework_Constraint_FileExists
 
222
     * @covers PHPUnit_Framework_Constraint_Not
 
223
     * @covers PHPUnit_Framework_Assert::logicalNot
 
224
     * @covers PHPUnit_Framework_Assert::fileExists
 
225
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
226
     */
 
227
    public function testConstraintFileNotExists()
 
228
    {
 
229
        $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
 
230
 
 
231
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
232
          PHPUnit_Framework_Assert::fileExists()
 
233
        );
 
234
 
 
235
        $this->assertFalse($constraint->evaluate($file, '', true));
 
236
        $this->assertEquals('file does not exist', $constraint->toString());
 
237
        $this->assertEquals(1, count($constraint));
 
238
 
 
239
        try {
 
240
            $constraint->evaluate($file);
 
241
        }
 
242
 
 
243
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
244
            $this->assertEquals(
 
245
              <<<EOF
 
246
Failed asserting that file "$file" does not exist.
 
247
 
 
248
EOF
 
249
              ,
 
250
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
251
            );
 
252
 
 
253
            return;
 
254
        }
 
255
 
 
256
        $this->fail();
 
257
    }
 
258
 
 
259
    /**
 
260
     * @covers PHPUnit_Framework_Constraint_FileExists
 
261
     * @covers PHPUnit_Framework_Constraint_Not
 
262
     * @covers PHPUnit_Framework_Assert::logicalNot
 
263
     * @covers PHPUnit_Framework_Assert::fileExists
 
264
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
265
     */
 
266
    public function testConstraintFileNotExists2()
 
267
    {
 
268
        $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php';
 
269
 
 
270
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
271
          PHPUnit_Framework_Assert::fileExists()
 
272
        );
 
273
 
 
274
        try {
 
275
            $constraint->evaluate($file, 'custom message');
 
276
        }
 
277
 
 
278
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
279
            $this->assertEquals(<<<EOF
 
280
custom message
 
281
Failed asserting that file "$file" does not exist.
 
282
 
 
283
EOF
 
284
              ,
 
285
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
286
            );
 
287
 
 
288
            return;
 
289
        }
 
290
 
 
291
        $this->fail();
 
292
    }
 
293
 
 
294
    /**
 
295
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
296
     * @covers PHPUnit_Framework_Assert::greaterThan
 
297
     * @covers PHPUnit_Framework_Constraint::count
 
298
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
299
     */
 
300
    public function testConstraintGreaterThan()
 
301
    {
 
302
        $constraint = PHPUnit_Framework_Assert::greaterThan(1);
 
303
 
 
304
        $this->assertFalse($constraint->evaluate(0, '', true));
 
305
        $this->assertTrue($constraint->evaluate(2, '', true));
 
306
        $this->assertEquals('is greater than 1', $constraint->toString());
 
307
        $this->assertEquals(1, count($constraint));
 
308
 
 
309
        try {
 
310
            $constraint->evaluate(0);
 
311
        }
 
312
 
 
313
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
314
            $this->assertEquals(
 
315
              <<<EOF
 
316
Failed asserting that 0 is greater than 1.
 
317
 
 
318
EOF
 
319
              ,
 
320
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
321
            );
 
322
 
 
323
            return;
 
324
        }
 
325
 
 
326
        $this->fail();
 
327
    }
 
328
 
 
329
    /**
 
330
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
331
     * @covers PHPUnit_Framework_Assert::greaterThan
 
332
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
333
     */
 
334
    public function testConstraintGreaterThan2()
 
335
    {
 
336
        $constraint = PHPUnit_Framework_Assert::greaterThan(1);
 
337
 
 
338
        try {
 
339
            $constraint->evaluate(0, 'custom message');
 
340
        }
 
341
 
 
342
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
343
            $this->assertEquals(
 
344
              <<<EOF
 
345
custom message
 
346
Failed asserting that 0 is greater than 1.
 
347
 
 
348
EOF
 
349
              ,
 
350
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
351
            );
 
352
 
 
353
            return;
 
354
        }
 
355
 
 
356
        $this->fail();
 
357
    }
 
358
 
 
359
    /**
 
360
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
361
     * @covers PHPUnit_Framework_Constraint_Not
 
362
     * @covers PHPUnit_Framework_Assert::greaterThan
 
363
     * @covers PHPUnit_Framework_Assert::logicalNot
 
364
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
365
     */
 
366
    public function testConstraintNotGreaterThan()
 
367
    {
 
368
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
369
          PHPUnit_Framework_Assert::greaterThan(1)
 
370
        );
 
371
 
 
372
        $this->assertTrue($constraint->evaluate(1, '', true));
 
373
        $this->assertEquals('is not greater than 1', $constraint->toString());
 
374
        $this->assertEquals(1, count($constraint));
 
375
 
 
376
        try {
 
377
            $constraint->evaluate(2);
 
378
        }
 
379
 
 
380
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
381
            $this->assertEquals(
 
382
              <<<EOF
 
383
Failed asserting that 2 is not greater than 1.
 
384
 
 
385
EOF
 
386
              ,
 
387
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
388
            );
 
389
 
 
390
            return;
 
391
        }
 
392
 
 
393
        $this->fail();
 
394
    }
 
395
 
 
396
    /**
 
397
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
398
     * @covers PHPUnit_Framework_Constraint_Not
 
399
     * @covers PHPUnit_Framework_Assert::greaterThan
 
400
     * @covers PHPUnit_Framework_Assert::logicalNot
 
401
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
402
     */
 
403
    public function testConstraintNotGreaterThan2()
 
404
    {
 
405
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
406
          PHPUnit_Framework_Assert::greaterThan(1)
 
407
        );
 
408
 
 
409
        try {
 
410
            $constraint->evaluate(2, 'custom message');
 
411
        }
 
412
 
 
413
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
414
            $this->assertEquals(
 
415
              <<<EOF
 
416
custom message
 
417
Failed asserting that 2 is not greater than 1.
 
418
 
 
419
EOF
 
420
              ,
 
421
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
422
            );
 
423
 
 
424
            return;
 
425
        }
 
426
 
 
427
        $this->fail();
 
428
    }
 
429
 
 
430
    /**
 
431
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
432
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
433
     * @covers PHPUnit_Framework_Constraint_Or
 
434
     * @covers PHPUnit_Framework_Assert::greaterThanOrEqual
 
435
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
436
     */
 
437
    public function testConstraintGreaterThanOrEqual()
 
438
    {
 
439
        $constraint = PHPUnit_Framework_Assert::greaterThanOrEqual(1);
 
440
 
 
441
        $this->assertTrue($constraint->evaluate(1, '', true));
 
442
        $this->assertFalse($constraint->evaluate(0, '', true));
 
443
        $this->assertEquals('is equal to 1 or is greater than 1', $constraint->toString());
 
444
        $this->assertEquals(2, count($constraint));
 
445
 
 
446
        try {
 
447
            $constraint->evaluate(0);
 
448
        }
 
449
 
 
450
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
451
            $this->assertEquals(
 
452
              <<<EOF
 
453
Failed asserting that 0 is equal to 1 or is greater than 1.
 
454
 
 
455
EOF
 
456
              ,
 
457
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
458
            );
 
459
 
 
460
            return;
 
461
        }
 
462
 
 
463
        $this->fail();
 
464
    }
 
465
 
 
466
    /**
 
467
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
468
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
469
     * @covers PHPUnit_Framework_Constraint_Or
 
470
     * @covers PHPUnit_Framework_Assert::greaterThanOrEqual
 
471
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
472
     */
 
473
    public function testConstraintGreaterThanOrEqual2()
 
474
    {
 
475
        $constraint = PHPUnit_Framework_Assert::greaterThanOrEqual(1);
 
476
 
 
477
        try {
 
478
            $constraint->evaluate(0, 'custom message');
 
479
        }
 
480
 
 
481
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
482
            $this->assertEquals(
 
483
              <<<EOF
 
484
custom message
 
485
Failed asserting that 0 is equal to 1 or is greater than 1.
 
486
 
 
487
EOF
 
488
              ,
 
489
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
490
            );
 
491
 
 
492
            return;
 
493
        }
 
494
 
 
495
        $this->fail();
 
496
    }
 
497
 
 
498
    /**
 
499
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
500
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
501
     * @covers PHPUnit_Framework_Constraint_Or
 
502
     * @covers PHPUnit_Framework_Constraint_Not
 
503
     * @covers PHPUnit_Framework_Assert::greaterThanOrEqual
 
504
     * @covers PHPUnit_Framework_Assert::logicalNot
 
505
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
506
     */
 
507
    public function testConstraintNotGreaterThanOrEqual()
 
508
    {
 
509
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
510
          PHPUnit_Framework_Assert::greaterThanOrEqual(1)
 
511
        );
 
512
 
 
513
        $this->assertFalse($constraint->evaluate(1, '', true));
 
514
        $this->assertEquals('not( is equal to 1 or is greater than 1 )', $constraint->toString());
 
515
        $this->assertEquals(2, count($constraint));
 
516
 
 
517
        try {
 
518
            $constraint->evaluate(1);
 
519
        }
 
520
 
 
521
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
522
            $this->assertEquals(
 
523
              <<<EOF
 
524
Failed asserting that not( 1 is equal to 1 or is greater than 1 ).
 
525
 
 
526
EOF
 
527
              ,
 
528
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
529
            );
 
530
 
 
531
            return;
 
532
        }
 
533
 
 
534
        $this->fail();
 
535
    }
 
536
 
 
537
    /**
 
538
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
539
     * @covers PHPUnit_Framework_Constraint_GreaterThan
 
540
     * @covers PHPUnit_Framework_Constraint_Or
 
541
     * @covers PHPUnit_Framework_Constraint_Not
 
542
     * @covers PHPUnit_Framework_Assert::greaterThanOrEqual
 
543
     * @covers PHPUnit_Framework_Assert::logicalNot
 
544
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
545
     */
 
546
    public function testConstraintNotGreaterThanOrEqual2()
 
547
    {
 
548
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
549
          PHPUnit_Framework_Assert::greaterThanOrEqual(1)
 
550
        );
 
551
 
 
552
        try {
 
553
            $constraint->evaluate(1, 'custom message');
 
554
        }
 
555
 
 
556
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
557
            $this->assertEquals(
 
558
              <<<EOF
 
559
custom message
 
560
Failed asserting that not( 1 is equal to 1 or is greater than 1 ).
 
561
 
 
562
EOF
 
563
              ,
 
564
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
565
            );
 
566
 
 
567
            return;
 
568
        }
 
569
 
 
570
        $this->fail();
 
571
    }
 
572
 
 
573
    /**
 
574
     * @covers PHPUnit_Framework_Constraint_IsAnything
 
575
     * @covers PHPUnit_Framework_Assert::anything
 
576
     * @covers PHPUnit_Framework_Constraint::count
 
577
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
578
     */
 
579
    public function testConstraintIsAnything()
 
580
    {
 
581
        $constraint = PHPUnit_Framework_Assert::anything();
 
582
 
 
583
        $this->assertTrue($constraint->evaluate(null, '', true));
 
584
        $this->assertNull($constraint->evaluate(null));
 
585
        $this->assertEquals('is anything', $constraint->toString());
 
586
        $this->assertEquals(0, count($constraint));
 
587
    }
 
588
 
 
589
    /**
 
590
     * @covers PHPUnit_Framework_Constraint_IsAnything
 
591
     * @covers PHPUnit_Framework_Constraint_Not
 
592
     * @covers PHPUnit_Framework_Assert::anything
 
593
     * @covers PHPUnit_Framework_Assert::logicalNot
 
594
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
595
     */
 
596
    public function testConstraintNotIsAnything()
 
597
    {
 
598
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
599
          PHPUnit_Framework_Assert::anything()
 
600
        );
 
601
 
 
602
        $this->assertFalse($constraint->evaluate(null, '', true));
 
603
        $this->assertEquals('is not anything', $constraint->toString());
 
604
        $this->assertEquals(0, count($constraint));
 
605
 
 
606
        try {
 
607
            $constraint->evaluate(null);
 
608
        }
 
609
 
 
610
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
611
            $this->assertEquals(
 
612
              <<<EOF
 
613
Failed asserting that null is not anything.
 
614
 
 
615
EOF
 
616
              ,
 
617
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
618
            );
 
619
 
 
620
            return;
 
621
        }
 
622
 
 
623
        $this->fail();
 
624
    }
 
625
 
 
626
    /**
 
627
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
628
     * @covers PHPUnit_Framework_Assert::equalTo
 
629
     * @covers PHPUnit_Framework_Constraint::count
 
630
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
631
     */
 
632
    public function testConstraintIsEqual()
 
633
    {
 
634
        $constraint = PHPUnit_Framework_Assert::equalTo(1);
 
635
 
 
636
        $this->assertTrue($constraint->evaluate(1, '', true));
 
637
        $this->assertFalse($constraint->evaluate(0, '', true));
 
638
        $this->assertEquals('is equal to 1', $constraint->toString());
 
639
        $this->assertEquals(1, count($constraint));
 
640
 
 
641
        try {
 
642
            $constraint->evaluate(0);
 
643
        }
 
644
 
 
645
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
646
            $this->assertEquals(
 
647
              <<<EOF
 
648
Failed asserting that 0 matches expected 1.
 
649
 
 
650
EOF
 
651
              ,
 
652
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
653
            );
 
654
 
 
655
            return;
 
656
        }
 
657
 
 
658
        $this->fail();
 
659
    }
 
660
 
 
661
    public function isEqualProvider()
 
662
    {
 
663
        $a = new stdClass;
 
664
        $a->foo = 'bar';
 
665
        $b = new stdClass;
 
666
        $ahash = spl_object_hash($a);
 
667
        $bhash = spl_object_hash($b);
 
668
 
 
669
        $c = new stdClass;
 
670
        $c->foo = 'bar';
 
671
        $c->int = 1;
 
672
        $c->array = array(0, array(1), array(2), 3);
 
673
        $c->related = new stdClass;
 
674
        $c->related->foo = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk";
 
675
        $c->self = $c;
 
676
        $c->c = $c;
 
677
        $d = new stdClass;
 
678
        $d->foo = 'bar';
 
679
        $d->int = 2;
 
680
        $d->array = array(0, array(4), array(2), 3);
 
681
        $d->related = new stdClass;
 
682
        $d->related->foo = "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk";
 
683
        $d->self = $d;
 
684
        $d->c = $c;
 
685
 
 
686
        $storage1 = new SplObjectStorage;
 
687
        $storage1->attach($a);
 
688
        $storage1->attach($b);
 
689
        $storage2 = new SplObjectStorage;
 
690
        $storage2->attach($b);
 
691
        $storage1hash = spl_object_hash($storage1);
 
692
        $storage2hash = spl_object_hash($storage2);
 
693
 
 
694
        $dom1 = new DOMDocument;
 
695
        $dom1->preserveWhiteSpace = false;
 
696
        $dom1->loadXML('<root></root>');
 
697
        $dom2 = new DOMDocument;
 
698
        $dom2->preserveWhiteSpace = false;
 
699
        $dom2->loadXML('<root><foo/></root>');
 
700
 
 
701
        return array(
 
702
            array(1, 0, <<<EOF
 
703
Failed asserting that 0 matches expected 1.
 
704
 
 
705
EOF
 
706
            ),
 
707
            array(1.1, 0, <<<EOF
 
708
Failed asserting that 0 matches expected 1.1.
 
709
 
 
710
EOF
 
711
            ),
 
712
            array('a', 'b', <<<EOF
 
713
Failed asserting that two strings are equal.
 
714
--- Expected
 
715
+++ Actual
 
716
@@ @@
 
717
-'a'
 
718
+'b'
 
719
 
 
720
EOF
 
721
            ),
 
722
            array("a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk", "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk", <<<EOF
 
723
Failed asserting that two strings are equal.
 
724
--- Expected
 
725
+++ Actual
 
726
@@ @@
 
727
 'a
 
728
-b
 
729
+p
 
730
 
 
731
@@ @@
 
732
 i
 
733
-j
 
734
+w
 
735
 k'
 
736
 
 
737
EOF
 
738
            ),
 
739
            array(1, array(0), <<<EOF
 
740
Array (...) does not match expected type "integer".
 
741
 
 
742
EOF
 
743
            ),
 
744
            array(array(0), 1, <<<EOF
 
745
1 does not match expected type "array".
 
746
 
 
747
EOF
 
748
            ),
 
749
            array(array(0), array(1), <<<EOF
 
750
Failed asserting that two arrays are equal.
 
751
--- Expected
 
752
+++ Actual
 
753
@@ @@
 
754
 Array (
 
755
-    0 => 0
 
756
+    0 => 1
 
757
 )
 
758
 
 
759
EOF
 
760
            ),
 
761
            array(array(true), array('true'), <<<EOF
 
762
Failed asserting that two arrays are equal.
 
763
--- Expected
 
764
+++ Actual
 
765
@@ @@
 
766
 Array (
 
767
-    0 => true
 
768
+    0 => 'true'
 
769
 )
 
770
 
 
771
EOF
 
772
            ),
 
773
            array(array(0, array(1), array(2), 3), array(0, array(4), array(2), 3), <<<EOF
 
774
Failed asserting that two arrays are equal.
 
775
--- Expected
 
776
+++ Actual
 
777
@@ @@
 
778
 Array (
 
779
     0 => 0
 
780
     1 => Array (
 
781
-        0 => 1
 
782
+        0 => 4
 
783
     )
 
784
     2 => Array (...)
 
785
     3 => 3
 
786
 )
 
787
 
 
788
EOF
 
789
            ),
 
790
            array($a, array(0), <<<EOF
 
791
Array (...) does not match expected type "object".
 
792
 
 
793
EOF
 
794
            ),
 
795
            array(array(0), $a, <<<EOF
 
796
stdClass Object (...) does not match expected type "array".
 
797
 
 
798
EOF
 
799
            ),
 
800
            array($a, $b, <<<EOF
 
801
Failed asserting that two objects are equal.
 
802
--- Expected
 
803
+++ Actual
 
804
@@ @@
 
805
 stdClass Object (
 
806
-    'foo' => 'bar'
 
807
 )
 
808
 
 
809
EOF
 
810
            ),
 
811
            array($c, $d, <<<EOF
 
812
Failed asserting that two objects are equal.
 
813
--- Expected
 
814
+++ Actual
 
815
@@ @@
 
816
 stdClass Object (
 
817
     'foo' => 'bar'
 
818
-    'int' => 1
 
819
+    'int' => 2
 
820
     'array' => Array (
 
821
         0 => 0
 
822
         1 => Array (
 
823
-            0 => 1
 
824
+            0 => 4
 
825
 
 
826
@@ @@
 
827
         'foo' => 'a
 
828
-        b
 
829
+        p
 
830
 
 
831
@@ @@
 
832
         i
 
833
-        j
 
834
+        w
 
835
         k'
 
836
     )
 
837
     'self' => stdClass Object (...)
 
838
     'c' => stdClass Object (...)
 
839
 )
 
840
 
 
841
EOF
 
842
            ),
 
843
            array($storage1, $storage2, <<<EOF
 
844
Failed asserting that two objects are equal.
 
845
--- Expected
 
846
+++ Actual
 
847
@@ @@
 
848
-SplObjectStorage Object &$storage1hash (
 
849
-    '$ahash' => Array &0 (
 
850
-        'obj' => stdClass Object &$ahash (
 
851
-            'foo' => 'bar'
 
852
-        )
 
853
+SplObjectStorage Object &$storage2hash (
 
854
+    '$bhash' => Array &0 (
 
855
+        'obj' => stdClass Object &$bhash ()
 
856
         'inf' => null
 
857
     )
 
858
-    '$bhash' => Array &0
 
859
 )
 
860
 
 
861
EOF
 
862
            ),
 
863
            array($dom1, $dom2, <<<EOF
 
864
Failed asserting that two DOM documents are equal.
 
865
--- Expected
 
866
+++ Actual
 
867
@@ @@
 
868
 <?xml version="1.0"?>
 
869
-<root/>
 
870
+<root>
 
871
+  <foo/>
 
872
+</root>
 
873
 
 
874
EOF
 
875
            ),
 
876
            array(
 
877
              new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 
878
              new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')),
 
879
              <<<EOF
 
880
Failed asserting that two DateTime objects are equal.
 
881
--- Expected
 
882
+++ Actual
 
883
@@ @@
 
884
-2013-03-29T04:13:35-0400
 
885
+2013-03-29T04:13:35-0500
 
886
 
 
887
EOF
 
888
            ),
 
889
        );
 
890
    }
 
891
 
 
892
    /**
 
893
     * @dataProvider isEqualProvider
 
894
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
895
     * @covers PHPUnit_Framework_Assert::equalTo
 
896
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
897
     */
 
898
    public function testConstraintIsEqual2($expected, $actual, $message)
 
899
    {
 
900
        $constraint = PHPUnit_Framework_Assert::equalTo($expected);
 
901
 
 
902
        try {
 
903
            $constraint->evaluate($actual, 'custom message');
 
904
        }
 
905
 
 
906
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
907
            $this->assertEquals(
 
908
              "custom message\n$message",
 
909
              $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e))
 
910
            );
 
911
 
 
912
            return;
 
913
        }
 
914
 
 
915
        $this->fail();
 
916
    }
 
917
 
 
918
    /**
 
919
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
920
     * @covers PHPUnit_Framework_Constraint_Not
 
921
     * @covers PHPUnit_Framework_Assert::equalTo
 
922
     * @covers PHPUnit_Framework_Assert::logicalNot
 
923
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
924
     */
 
925
    public function testConstraintIsNotEqual()
 
926
    {
 
927
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
928
          PHPUnit_Framework_Assert::equalTo(1)
 
929
        );
 
930
 
 
931
        $this->assertTrue($constraint->evaluate(0, '', true));
 
932
        $this->assertFalse($constraint->evaluate(1, '', true));
 
933
        $this->assertEquals('is not equal to 1', $constraint->toString());
 
934
        $this->assertEquals(1, count($constraint));
 
935
 
 
936
        try {
 
937
            $constraint->evaluate(1);
 
938
        }
 
939
 
 
940
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
941
            $this->assertEquals(
 
942
              <<<EOF
 
943
Failed asserting that 1 is not equal to 1.
 
944
 
 
945
EOF
 
946
              ,
 
947
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
948
            );
 
949
 
 
950
            return;
 
951
        }
 
952
 
 
953
        $this->fail();
 
954
    }
 
955
 
 
956
    /**
 
957
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
958
     * @covers PHPUnit_Framework_Constraint_Not
 
959
     * @covers PHPUnit_Framework_Assert::equalTo
 
960
     * @covers PHPUnit_Framework_Assert::logicalNot
 
961
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
962
     */
 
963
    public function testConstraintIsNotEqual2()
 
964
    {
 
965
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
966
          PHPUnit_Framework_Assert::equalTo(1)
 
967
        );
 
968
 
 
969
        try {
 
970
            $constraint->evaluate(1, 'custom message');
 
971
        }
 
972
 
 
973
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
974
            $this->assertEquals(
 
975
              <<<EOF
 
976
custom message
 
977
Failed asserting that 1 is not equal to 1.
 
978
 
 
979
EOF
 
980
              ,
 
981
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
982
            );
 
983
 
 
984
            return;
 
985
        }
 
986
 
 
987
        $this->fail();
 
988
    }
 
989
 
 
990
    /**
 
991
     * @covers PHPUnit_Framework_Constraint_IsIdentical
 
992
     * @covers PHPUnit_Framework_Assert::identicalTo
 
993
     * @covers PHPUnit_Framework_Constraint::count
 
994
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
995
     */
 
996
    public function testConstraintIsIdentical()
 
997
    {
 
998
        $a = new stdClass;
 
999
        $b = new stdClass;
 
1000
 
 
1001
        $constraint = PHPUnit_Framework_Assert::identicalTo($a);
 
1002
 
 
1003
        $this->assertFalse($constraint->evaluate($b, '', true));
 
1004
        $this->assertTrue($constraint->evaluate($a, '', true));
 
1005
        $this->assertEquals('is identical to an object of class "stdClass"', $constraint->toString());
 
1006
        $this->assertEquals(1, count($constraint));
 
1007
 
 
1008
        try {
 
1009
            $constraint->evaluate($b);
 
1010
        }
 
1011
 
 
1012
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1013
            $this->assertEquals(<<<EOF
 
1014
Failed asserting that two variables reference the same object.
 
1015
 
 
1016
EOF
 
1017
              ,
 
1018
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1019
            );
 
1020
 
 
1021
            return;
 
1022
        }
 
1023
 
 
1024
        $this->fail();
 
1025
    }
 
1026
 
 
1027
    /**
 
1028
     * @covers PHPUnit_Framework_Constraint_IsIdentical
 
1029
     * @covers PHPUnit_Framework_Assert::identicalTo
 
1030
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1031
     */
 
1032
    public function testConstraintIsIdentical2()
 
1033
    {
 
1034
        $a = new stdClass;
 
1035
        $b = new stdClass;
 
1036
 
 
1037
        $constraint = PHPUnit_Framework_Assert::identicalTo($a);
 
1038
 
 
1039
        try {
 
1040
            $constraint->evaluate($b, 'custom message');
 
1041
        }
 
1042
 
 
1043
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1044
            $this->assertEquals(<<<EOF
 
1045
custom message
 
1046
Failed asserting that two variables reference the same object.
 
1047
 
 
1048
EOF
 
1049
              ,
 
1050
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1051
            );
 
1052
 
 
1053
            return;
 
1054
        }
 
1055
 
 
1056
        $this->fail();
 
1057
    }
 
1058
 
 
1059
    /**
 
1060
     * @covers PHPUnit_Framework_Constraint_IsIdentical
 
1061
     * @covers PHPUnit_Framework_Assert::identicalTo
 
1062
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1063
     */
 
1064
    public function testConstraintIsIdentical3()
 
1065
    {
 
1066
        $constraint = PHPUnit_Framework_Assert::identicalTo('a');
 
1067
 
 
1068
        try {
 
1069
            $constraint->evaluate('b', 'custom message');
 
1070
        }
 
1071
 
 
1072
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1073
            $this->assertEquals(<<<EOF
 
1074
custom message
 
1075
Failed asserting that two strings are identical.
 
1076
--- Expected
 
1077
+++ Actual
 
1078
@@ @@
 
1079
-a
 
1080
+b
 
1081
 
 
1082
EOF
 
1083
              ,
 
1084
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1085
            );
 
1086
 
 
1087
            return;
 
1088
        }
 
1089
 
 
1090
        $this->fail();
 
1091
    }
 
1092
 
 
1093
    /**
 
1094
     * @covers PHPUnit_Framework_Constraint_IsIdentical
 
1095
     * @covers PHPUnit_Framework_Constraint_Not
 
1096
     * @covers PHPUnit_Framework_Assert::identicalTo
 
1097
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1098
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1099
     */
 
1100
    public function testConstraintIsNotIdentical()
 
1101
    {
 
1102
        $a = new stdClass;
 
1103
        $b = new stdClass;
 
1104
 
 
1105
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1106
          PHPUnit_Framework_Assert::identicalTo($a)
 
1107
        );
 
1108
 
 
1109
        $this->assertTrue($constraint->evaluate($b, '', true));
 
1110
        $this->assertFalse($constraint->evaluate($a, '', true));
 
1111
        $this->assertEquals('is not identical to an object of class "stdClass"', $constraint->toString());
 
1112
        $this->assertEquals(1, count($constraint));
 
1113
 
 
1114
        try {
 
1115
            $constraint->evaluate($a);
 
1116
        }
 
1117
 
 
1118
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1119
            $this->assertEquals(<<<EOF
 
1120
Failed asserting that two variables don't reference the same object.
 
1121
 
 
1122
EOF
 
1123
              ,
 
1124
              $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e))
 
1125
            );
 
1126
 
 
1127
            return;
 
1128
        }
 
1129
 
 
1130
        $this->fail();
 
1131
    }
 
1132
 
 
1133
    /**
 
1134
     * @covers PHPUnit_Framework_Constraint_IsIdentical
 
1135
     * @covers PHPUnit_Framework_Constraint_Not
 
1136
     * @covers PHPUnit_Framework_Assert::identicalTo
 
1137
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1138
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1139
     */
 
1140
    public function testConstraintIsNotIdentical2()
 
1141
    {
 
1142
        $a = new stdClass;
 
1143
 
 
1144
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1145
          PHPUnit_Framework_Assert::identicalTo($a)
 
1146
        );
 
1147
 
 
1148
        try {
 
1149
            $constraint->evaluate($a, 'custom message');
 
1150
        }
 
1151
 
 
1152
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1153
            $this->assertEquals(<<<EOF
 
1154
custom message
 
1155
Failed asserting that two variables don't reference the same object.
 
1156
 
 
1157
EOF
 
1158
              ,
 
1159
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1160
            );
 
1161
 
 
1162
            return;
 
1163
        }
 
1164
 
 
1165
        $this->fail();
 
1166
    }
 
1167
 
 
1168
    /**
 
1169
     * @covers PHPUnit_Framework_Constraint_IsIdentical
 
1170
     * @covers PHPUnit_Framework_Constraint_Not
 
1171
     * @covers PHPUnit_Framework_Assert::identicalTo
 
1172
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1173
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1174
     */
 
1175
    public function testConstraintIsNotIdentical3()
 
1176
    {
 
1177
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1178
          PHPUnit_Framework_Assert::identicalTo('a')
 
1179
        );
 
1180
 
 
1181
        try {
 
1182
            $constraint->evaluate('a', 'custom message');
 
1183
        }
 
1184
 
 
1185
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1186
            $this->assertEquals(<<<EOF
 
1187
custom message
 
1188
Failed asserting that two strings are not identical.
 
1189
 
 
1190
EOF
 
1191
              ,
 
1192
              $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e))
 
1193
            );
 
1194
 
 
1195
            return;
 
1196
        }
 
1197
 
 
1198
        $this->fail();
 
1199
    }
 
1200
 
 
1201
    /**
 
1202
     * @covers PHPUnit_Framework_Constraint_IsInstanceOf
 
1203
     * @covers PHPUnit_Framework_Assert::isInstanceOf
 
1204
     * @covers PHPUnit_Framework_Constraint::count
 
1205
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1206
     */
 
1207
    public function testConstraintIsInstanceOf()
 
1208
    {
 
1209
        $constraint = PHPUnit_Framework_Assert::isInstanceOf('Exception');
 
1210
 
 
1211
        $this->assertFalse($constraint->evaluate(new stdClass, '', true));
 
1212
        $this->assertTrue($constraint->evaluate(new Exception, '', true));
 
1213
        $this->assertEquals('is instance of class "Exception"', $constraint->toString());
 
1214
        $this->assertEquals(1, count($constraint));
 
1215
 
 
1216
        $interfaceConstraint = PHPUnit_Framework_Assert::isInstanceOf('Countable');
 
1217
        $this->assertFalse($interfaceConstraint->evaluate(new stdClass, '', true));
 
1218
        $this->assertTrue($interfaceConstraint->evaluate(new ArrayObject, '', true));
 
1219
        $this->assertEquals('is instance of interface "Countable"', $interfaceConstraint->toString());
 
1220
 
 
1221
        try {
 
1222
            $constraint->evaluate(new stdClass);
 
1223
        }
 
1224
 
 
1225
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1226
            $this->assertEquals(
 
1227
              <<<EOF
 
1228
Failed asserting that stdClass Object () is an instance of class "Exception".
 
1229
 
 
1230
EOF
 
1231
              ,
 
1232
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1233
            );
 
1234
 
 
1235
            return;
 
1236
        }
 
1237
 
 
1238
        $this->fail();
 
1239
    }
 
1240
 
 
1241
    /**
 
1242
     * @covers PHPUnit_Framework_Constraint_IsInstanceOf
 
1243
     * @covers PHPUnit_Framework_Assert::isInstanceOf
 
1244
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1245
     */
 
1246
    public function testConstraintIsInstanceOf2()
 
1247
    {
 
1248
        $constraint = PHPUnit_Framework_Assert::isInstanceOf('Exception');
 
1249
 
 
1250
        try {
 
1251
            $constraint->evaluate(new stdClass, 'custom message');
 
1252
        }
 
1253
 
 
1254
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1255
            $this->assertEquals(<<<EOF
 
1256
custom message
 
1257
Failed asserting that stdClass Object () is an instance of class "Exception".
 
1258
 
 
1259
EOF
 
1260
              ,
 
1261
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1262
            );
 
1263
 
 
1264
            return;
 
1265
        }
 
1266
 
 
1267
        $this->fail();
 
1268
    }
 
1269
 
 
1270
    /**
 
1271
     * @covers PHPUnit_Framework_Constraint_IsInstanceOf
 
1272
     * @covers PHPUnit_Framework_Constraint_Not
 
1273
     * @covers PHPUnit_Framework_Assert::isInstanceOf
 
1274
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1275
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1276
     */
 
1277
    public function testConstraintIsNotInstanceOf()
 
1278
    {
 
1279
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1280
          PHPUnit_Framework_Assert::isInstanceOf('stdClass')
 
1281
        );
 
1282
 
 
1283
        $this->assertFalse($constraint->evaluate(new stdClass, '', true));
 
1284
        $this->assertTrue($constraint->evaluate(new Exception, '', true));
 
1285
        $this->assertEquals('is not instance of class "stdClass"', $constraint->toString());
 
1286
        $this->assertEquals(1, count($constraint));
 
1287
 
 
1288
        try {
 
1289
            $constraint->evaluate(new stdClass);
 
1290
        }
 
1291
 
 
1292
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1293
            $this->assertEquals(
 
1294
              <<<EOF
 
1295
Failed asserting that stdClass Object () is not an instance of class "stdClass".
 
1296
 
 
1297
EOF
 
1298
              ,
 
1299
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1300
            );
 
1301
 
 
1302
            return;
 
1303
        }
 
1304
 
 
1305
        $this->fail();
 
1306
    }
 
1307
 
 
1308
    /**
 
1309
     * @covers PHPUnit_Framework_Constraint_IsInstanceOf
 
1310
     * @covers PHPUnit_Framework_Constraint_Not
 
1311
     * @covers PHPUnit_Framework_Assert::isInstanceOf
 
1312
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1313
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1314
     */
 
1315
    public function testConstraintIsNotInstanceOf2()
 
1316
    {
 
1317
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1318
          PHPUnit_Framework_Assert::isInstanceOf('stdClass')
 
1319
        );
 
1320
 
 
1321
        try {
 
1322
            $constraint->evaluate(new stdClass, 'custom message');
 
1323
        }
 
1324
 
 
1325
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1326
            $this->assertEquals(<<<EOF
 
1327
custom message
 
1328
Failed asserting that stdClass Object () is not an instance of class "stdClass".
 
1329
 
 
1330
EOF
 
1331
              ,
 
1332
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1333
            );
 
1334
 
 
1335
            return;
 
1336
        }
 
1337
 
 
1338
        $this->fail();
 
1339
    }
 
1340
 
 
1341
    /**
 
1342
     * @covers PHPUnit_Framework_Constraint_IsType
 
1343
     * @covers PHPUnit_Framework_Assert::isType
 
1344
     * @covers PHPUnit_Framework_Constraint::count
 
1345
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1346
     */
 
1347
    public function testConstraintIsType()
 
1348
    {
 
1349
        $constraint = PHPUnit_Framework_Assert::isType('string');
 
1350
 
 
1351
        $this->assertFalse($constraint->evaluate(0, '', true));
 
1352
        $this->assertTrue($constraint->evaluate('', '', true));
 
1353
        $this->assertEquals('is of type "string"', $constraint->toString());
 
1354
        $this->assertEquals(1, count($constraint));
 
1355
 
 
1356
        try {
 
1357
            $constraint->evaluate(new stdClass);
 
1358
        }
 
1359
 
 
1360
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1361
            $this->assertStringMatchesFormat(<<<EOF
 
1362
Failed asserting that stdClass Object &%x () is of type "string".
 
1363
 
 
1364
EOF
 
1365
              ,
 
1366
              $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e))
 
1367
            );
 
1368
 
 
1369
            return;
 
1370
        }
 
1371
 
 
1372
        $this->fail();
 
1373
    }
 
1374
 
 
1375
    /**
 
1376
     * @covers PHPUnit_Framework_Constraint_IsType
 
1377
     * @covers PHPUnit_Framework_Assert::isType
 
1378
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1379
     */
 
1380
    public function testConstraintIsType2()
 
1381
    {
 
1382
        $constraint = PHPUnit_Framework_Assert::isType('string');
 
1383
 
 
1384
        try {
 
1385
            $constraint->evaluate(new stdClass, 'custom message');
 
1386
        }
 
1387
 
 
1388
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1389
            $this->assertStringMatchesFormat(<<<EOF
 
1390
custom message
 
1391
Failed asserting that stdClass Object &%x () is of type "string".
 
1392
 
 
1393
EOF
 
1394
              ,
 
1395
              $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e))
 
1396
            );
 
1397
 
 
1398
            return;
 
1399
        }
 
1400
 
 
1401
        $this->fail();
 
1402
    }
 
1403
 
 
1404
    /**
 
1405
     * @covers PHPUnit_Framework_Constraint_IsType
 
1406
     * @covers PHPUnit_Framework_Constraint_Not
 
1407
     * @covers PHPUnit_Framework_Assert::isType
 
1408
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1409
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1410
     */
 
1411
    public function testConstraintIsNotType()
 
1412
    {
 
1413
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1414
          PHPUnit_Framework_Assert::isType('string')
 
1415
        );
 
1416
 
 
1417
        $this->assertTrue($constraint->evaluate(0, '', true));
 
1418
        $this->assertFalse($constraint->evaluate('', '', true));
 
1419
        $this->assertEquals('is not of type "string"', $constraint->toString());
 
1420
        $this->assertEquals(1, count($constraint));
 
1421
 
 
1422
        try {
 
1423
            $constraint->evaluate('');
 
1424
        }
 
1425
 
 
1426
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1427
            $this->assertEquals(
 
1428
              <<<EOF
 
1429
Failed asserting that '' is not of type "string".
 
1430
 
 
1431
EOF
 
1432
              ,
 
1433
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1434
            );
 
1435
 
 
1436
            return;
 
1437
        }
 
1438
 
 
1439
        $this->fail();
 
1440
    }
 
1441
 
 
1442
    /**
 
1443
     * @covers PHPUnit_Framework_Constraint_IsType
 
1444
     * @covers PHPUnit_Framework_Constraint_Not
 
1445
     * @covers PHPUnit_Framework_Assert::isType
 
1446
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1447
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1448
     */
 
1449
    public function testConstraintIsNotType2()
 
1450
    {
 
1451
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1452
          PHPUnit_Framework_Assert::isType('string')
 
1453
        );
 
1454
 
 
1455
        try {
 
1456
            $constraint->evaluate('', 'custom message');
 
1457
        }
 
1458
 
 
1459
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1460
            $this->assertEquals(<<<EOF
 
1461
custom message
 
1462
Failed asserting that '' is not of type "string".
 
1463
 
 
1464
EOF
 
1465
              ,
 
1466
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1467
            );
 
1468
 
 
1469
            return;
 
1470
        }
 
1471
 
 
1472
        $this->fail();
 
1473
    }
 
1474
 
 
1475
    /**
 
1476
     * @covers PHPUnit_Framework_Constraint_IsNull
 
1477
     * @covers PHPUnit_Framework_Assert::isNull
 
1478
     * @covers PHPUnit_Framework_Constraint::count
 
1479
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1480
     */
 
1481
    public function testConstraintIsNull()
 
1482
    {
 
1483
        $constraint = PHPUnit_Framework_Assert::isNull();
 
1484
 
 
1485
        $this->assertFalse($constraint->evaluate(0, '', true));
 
1486
        $this->assertTrue($constraint->evaluate(null, '', true));
 
1487
        $this->assertEquals('is null', $constraint->toString());
 
1488
        $this->assertEquals(1, count($constraint));
 
1489
 
 
1490
        try {
 
1491
            $constraint->evaluate(0);
 
1492
        }
 
1493
 
 
1494
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1495
            $this->assertEquals(<<<EOF
 
1496
Failed asserting that 0 is null.
 
1497
 
 
1498
EOF
 
1499
              ,
 
1500
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1501
            );
 
1502
 
 
1503
            return;
 
1504
        }
 
1505
 
 
1506
        $this->fail();
 
1507
    }
 
1508
 
 
1509
    /**
 
1510
     * @covers PHPUnit_Framework_Constraint_IsNull
 
1511
     * @covers PHPUnit_Framework_Assert::isNull
 
1512
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1513
     */
 
1514
    public function testConstraintIsNull2()
 
1515
    {
 
1516
        $constraint = PHPUnit_Framework_Assert::isNull();
 
1517
 
 
1518
        try {
 
1519
            $constraint->evaluate(0, 'custom message');
 
1520
        }
 
1521
 
 
1522
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1523
            $this->assertEquals(<<<EOF
 
1524
custom message
 
1525
Failed asserting that 0 is null.
 
1526
 
 
1527
EOF
 
1528
              ,
 
1529
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1530
            );
 
1531
 
 
1532
            return;
 
1533
        }
 
1534
 
 
1535
        $this->fail();
 
1536
    }
 
1537
 
 
1538
    /**
 
1539
     * @covers PHPUnit_Framework_Constraint_IsNull
 
1540
     * @covers PHPUnit_Framework_Constraint_Not
 
1541
     * @covers PHPUnit_Framework_Assert::isNull
 
1542
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1543
     * @covers PHPUnit_Framework_Constraint::count
 
1544
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1545
     */
 
1546
    public function testConstraintIsNotNull()
 
1547
    {
 
1548
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1549
          PHPUnit_Framework_Assert::isNull()
 
1550
        );
 
1551
 
 
1552
        $this->assertFalse($constraint->evaluate(null, '', true));
 
1553
        $this->assertTrue($constraint->evaluate(0, '', true));
 
1554
        $this->assertEquals('is not null', $constraint->toString());
 
1555
        $this->assertEquals(1, count($constraint));
 
1556
 
 
1557
        try {
 
1558
            $constraint->evaluate(null);
 
1559
        }
 
1560
 
 
1561
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1562
            $this->assertEquals(<<<EOF
 
1563
Failed asserting that null is not null.
 
1564
 
 
1565
EOF
 
1566
              ,
 
1567
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1568
            );
 
1569
 
 
1570
            return;
 
1571
        }
 
1572
 
 
1573
        $this->fail();
 
1574
    }
 
1575
 
 
1576
    /**
 
1577
     * @covers PHPUnit_Framework_Constraint_IsNull
 
1578
     * @covers PHPUnit_Framework_Constraint_Not
 
1579
     * @covers PHPUnit_Framework_Assert::isNull
 
1580
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1581
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1582
     */
 
1583
    public function testConstraintIsNotNull2()
 
1584
    {
 
1585
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1586
          PHPUnit_Framework_Assert::isNull()
 
1587
        );
 
1588
 
 
1589
        try {
 
1590
            $constraint->evaluate(null, 'custom message');
 
1591
        }
 
1592
 
 
1593
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1594
            $this->assertEquals(<<<EOF
 
1595
custom message
 
1596
Failed asserting that null is not null.
 
1597
 
 
1598
EOF
 
1599
              ,
 
1600
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1601
            );
 
1602
 
 
1603
            return;
 
1604
        }
 
1605
 
 
1606
        $this->fail();
 
1607
    }
 
1608
 
 
1609
    /**
 
1610
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1611
     * @covers PHPUnit_Framework_Assert::lessThan
 
1612
     * @covers PHPUnit_Framework_Constraint::count
 
1613
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1614
     */
 
1615
    public function testConstraintLessThan()
 
1616
    {
 
1617
        $constraint = PHPUnit_Framework_Assert::lessThan(1);
 
1618
 
 
1619
        $this->assertTrue($constraint->evaluate(0, '', true));
 
1620
        $this->assertFalse($constraint->evaluate(1, '', true));
 
1621
        $this->assertEquals('is less than 1', $constraint->toString());
 
1622
        $this->assertEquals(1, count($constraint));
 
1623
 
 
1624
        try {
 
1625
            $constraint->evaluate(1);
 
1626
        }
 
1627
 
 
1628
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1629
            $this->assertEquals(
 
1630
              <<<EOF
 
1631
Failed asserting that 1 is less than 1.
 
1632
 
 
1633
EOF
 
1634
              ,
 
1635
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1636
            );
 
1637
 
 
1638
            return;
 
1639
        }
 
1640
 
 
1641
        $this->fail();
 
1642
    }
 
1643
 
 
1644
    /**
 
1645
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1646
     * @covers PHPUnit_Framework_Assert::lessThan
 
1647
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1648
     */
 
1649
    public function testConstraintLessThan2()
 
1650
    {
 
1651
        $constraint = PHPUnit_Framework_Assert::lessThan(1);
 
1652
 
 
1653
        try {
 
1654
            $constraint->evaluate(1, 'custom message');
 
1655
        }
 
1656
 
 
1657
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1658
            $this->assertEquals(
 
1659
              <<<EOF
 
1660
custom message
 
1661
Failed asserting that 1 is less than 1.
 
1662
 
 
1663
EOF
 
1664
              ,
 
1665
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1666
            );
 
1667
 
 
1668
            return;
 
1669
        }
 
1670
 
 
1671
        $this->fail();
 
1672
    }
 
1673
 
 
1674
    /**
 
1675
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1676
     * @covers PHPUnit_Framework_Constraint_Not
 
1677
     * @covers PHPUnit_Framework_Assert::lessThan
 
1678
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1679
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1680
     */
 
1681
    public function testConstraintNotLessThan()
 
1682
    {
 
1683
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1684
          PHPUnit_Framework_Assert::lessThan(1)
 
1685
        );
 
1686
 
 
1687
        $this->assertTrue($constraint->evaluate(1, '', true));
 
1688
        $this->assertFalse($constraint->evaluate(0, '', true));
 
1689
        $this->assertEquals('is not less than 1', $constraint->toString());
 
1690
        $this->assertEquals(1, count($constraint));
 
1691
 
 
1692
        try {
 
1693
            $constraint->evaluate(0);
 
1694
        }
 
1695
 
 
1696
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1697
            $this->assertEquals(
 
1698
              <<<EOF
 
1699
Failed asserting that 0 is not less than 1.
 
1700
 
 
1701
EOF
 
1702
              ,
 
1703
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1704
            );
 
1705
 
 
1706
            return;
 
1707
        }
 
1708
 
 
1709
        $this->fail();
 
1710
    }
 
1711
 
 
1712
    /**
 
1713
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1714
     * @covers PHPUnit_Framework_Constraint_Not
 
1715
     * @covers PHPUnit_Framework_Assert::lessThan
 
1716
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1717
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1718
     */
 
1719
    public function testConstraintNotLessThan2()
 
1720
    {
 
1721
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1722
          PHPUnit_Framework_Assert::lessThan(1)
 
1723
        );
 
1724
 
 
1725
        try {
 
1726
            $constraint->evaluate(0, 'custom message');
 
1727
        }
 
1728
 
 
1729
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1730
            $this->assertEquals(
 
1731
              <<<EOF
 
1732
custom message
 
1733
Failed asserting that 0 is not less than 1.
 
1734
 
 
1735
EOF
 
1736
              ,
 
1737
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1738
            );
 
1739
 
 
1740
            return;
 
1741
        }
 
1742
 
 
1743
        $this->fail();
 
1744
    }
 
1745
 
 
1746
    /**
 
1747
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
1748
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1749
     * @covers PHPUnit_Framework_Constraint_Or
 
1750
     * @covers PHPUnit_Framework_Assert::lessThanOrEqual
 
1751
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1752
     */
 
1753
    public function testConstraintLessThanOrEqual()
 
1754
    {
 
1755
        $constraint = PHPUnit_Framework_Assert::lessThanOrEqual(1);
 
1756
 
 
1757
        $this->assertTrue($constraint->evaluate(1, '', true));
 
1758
        $this->assertFalse($constraint->evaluate(2, '', true));
 
1759
        $this->assertEquals('is equal to 1 or is less than 1', $constraint->toString());
 
1760
        $this->assertEquals(2, count($constraint));
 
1761
 
 
1762
        try {
 
1763
            $constraint->evaluate(2);
 
1764
        }
 
1765
 
 
1766
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1767
            $this->assertEquals(
 
1768
              <<<EOF
 
1769
Failed asserting that 2 is equal to 1 or is less than 1.
 
1770
 
 
1771
EOF
 
1772
              ,
 
1773
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1774
            );
 
1775
 
 
1776
            return;
 
1777
        }
 
1778
 
 
1779
        $this->fail();
 
1780
    }
 
1781
 
 
1782
    /**
 
1783
     * @covers PHPUnit_Framework_Constraint_Callback
 
1784
     */
 
1785
    public function testConstraintCallback()
 
1786
    {
 
1787
        $closureReflect = function($parameter) {
 
1788
            return $parameter;
 
1789
        };
 
1790
 
 
1791
        $closureWithoutParameter = function() {
 
1792
            return true;
 
1793
        };
 
1794
 
 
1795
        $constraint = PHPUnit_Framework_Assert::callback($closureWithoutParameter);
 
1796
        $this->assertTrue($constraint->evaluate('', '', true));
 
1797
 
 
1798
        $constraint = PHPUnit_Framework_Assert::callback($closureReflect);
 
1799
        $this->assertTrue($constraint->evaluate(true, '', true));
 
1800
        $this->assertFalse($constraint->evaluate(false, '', true));
 
1801
 
 
1802
        $callback = array($this, 'callbackReturningTrue');
 
1803
        $constraint = PHPUnit_Framework_Assert::callback($callback);
 
1804
        $this->assertTrue($constraint->evaluate(false,  '', true));
 
1805
 
 
1806
        $callback = array('Framework_ConstraintTest', 'staticCallbackReturningTrue');
 
1807
        $constraint = PHPUnit_Framework_Assert::callback($callback);
 
1808
        $this->assertTrue($constraint->evaluate(null, '', true));
 
1809
 
 
1810
        $this->assertEquals('is accepted by specified callback', $constraint->toString());
 
1811
    }
 
1812
 
 
1813
    /**
 
1814
     * @covers PHPUnit_Framework_Constraint_Callback
 
1815
     * @expectedException PHPUnit_Framework_ExpectationFailedException
 
1816
     * @expectedExceptionMessage Failed asserting that 'This fails' is accepted by specified callback.
 
1817
     */
 
1818
    public function testConstraintCallbackFailure()
 
1819
    {
 
1820
        $constraint = PHPUnit_Framework_Assert::callback(function() {
 
1821
            return false;
 
1822
        });
 
1823
        $constraint->evaluate('This fails');
 
1824
    }
 
1825
 
 
1826
    public function callbackReturningTrue()
 
1827
    {
 
1828
        return true;
 
1829
    }
 
1830
 
 
1831
    public static function staticCallbackReturningTrue()
 
1832
    {
 
1833
        return true;
 
1834
    }
 
1835
 
 
1836
    /**
 
1837
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
1838
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1839
     * @covers PHPUnit_Framework_Constraint_Or
 
1840
     * @covers PHPUnit_Framework_Assert::lessThanOrEqual
 
1841
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1842
     */
 
1843
    public function testConstraintLessThanOrEqual2()
 
1844
    {
 
1845
        $constraint = PHPUnit_Framework_Assert::lessThanOrEqual(1);
 
1846
 
 
1847
        try {
 
1848
            $constraint->evaluate(2, 'custom message');
 
1849
        }
 
1850
 
 
1851
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1852
            $this->assertEquals(
 
1853
              <<<EOF
 
1854
custom message
 
1855
Failed asserting that 2 is equal to 1 or is less than 1.
 
1856
 
 
1857
EOF
 
1858
              ,
 
1859
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1860
            );
 
1861
 
 
1862
            return;
 
1863
        }
 
1864
 
 
1865
        $this->fail();
 
1866
    }
 
1867
 
 
1868
    /**
 
1869
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
1870
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1871
     * @covers PHPUnit_Framework_Constraint_Or
 
1872
     * @covers PHPUnit_Framework_Constraint_Not
 
1873
     * @covers PHPUnit_Framework_Assert::lessThanOrEqual
 
1874
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1875
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1876
     */
 
1877
    public function testConstraintNotLessThanOrEqual()
 
1878
    {
 
1879
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1880
          PHPUnit_Framework_Assert::lessThanOrEqual(1)
 
1881
        );
 
1882
 
 
1883
        $this->assertTrue($constraint->evaluate(2, '', true));
 
1884
        $this->assertFalse($constraint->evaluate(1, '', true));
 
1885
        $this->assertEquals('not( is equal to 1 or is less than 1 )', $constraint->toString());
 
1886
        $this->assertEquals(2, count($constraint));
 
1887
 
 
1888
        try {
 
1889
            $constraint->evaluate(1);
 
1890
        }
 
1891
 
 
1892
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1893
            $this->assertEquals(
 
1894
              <<<EOF
 
1895
Failed asserting that not( 1 is equal to 1 or is less than 1 ).
 
1896
 
 
1897
EOF
 
1898
              ,
 
1899
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1900
            );
 
1901
 
 
1902
            return;
 
1903
        }
 
1904
 
 
1905
        $this->fail();
 
1906
    }
 
1907
 
 
1908
    /**
 
1909
     * @covers PHPUnit_Framework_Constraint_IsEqual
 
1910
     * @covers PHPUnit_Framework_Constraint_LessThan
 
1911
     * @covers PHPUnit_Framework_Constraint_Or
 
1912
     * @covers PHPUnit_Framework_Constraint_Not
 
1913
     * @covers PHPUnit_Framework_Assert::lessThanOrEqual
 
1914
     * @covers PHPUnit_Framework_Assert::logicalNot
 
1915
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1916
     */
 
1917
    public function testConstraintNotLessThanOrEqual2()
 
1918
    {
 
1919
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
1920
          PHPUnit_Framework_Assert::lessThanOrEqual(1)
 
1921
        );
 
1922
 
 
1923
        try {
 
1924
            $constraint->evaluate(1, 'custom message');
 
1925
        }
 
1926
 
 
1927
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1928
            $this->assertEquals(
 
1929
              <<<EOF
 
1930
custom message
 
1931
Failed asserting that not( 1 is equal to 1 or is less than 1 ).
 
1932
 
 
1933
EOF
 
1934
              ,
 
1935
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1936
            );
 
1937
 
 
1938
            return;
 
1939
        }
 
1940
 
 
1941
        $this->fail();
 
1942
    }
 
1943
 
 
1944
    /**
 
1945
     * @covers PHPUnit_Framework_Constraint_ClassHasAttribute
 
1946
     * @covers PHPUnit_Framework_Assert::classHasAttribute
 
1947
     * @covers PHPUnit_Framework_Constraint::count
 
1948
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1949
     */
 
1950
    public function testConstraintClassHasAttribute()
 
1951
    {
 
1952
        $constraint = PHPUnit_Framework_Assert::classHasAttribute('privateAttribute');
 
1953
 
 
1954
        $this->assertTrue($constraint->evaluate('ClassWithNonPublicAttributes', '', true));
 
1955
        $this->assertFalse($constraint->evaluate('stdClass', '', true));
 
1956
        $this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
 
1957
        $this->assertEquals(1, count($constraint));
 
1958
 
 
1959
        try {
 
1960
            $constraint->evaluate('stdClass');
 
1961
        }
 
1962
 
 
1963
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1964
            $this->assertEquals(
 
1965
              <<<EOF
 
1966
Failed asserting that class "stdClass" has attribute "privateAttribute".
 
1967
 
 
1968
EOF
 
1969
              ,
 
1970
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
1971
            );
 
1972
 
 
1973
            return;
 
1974
        }
 
1975
 
 
1976
        $this->fail();
 
1977
    }
 
1978
 
 
1979
    /**
 
1980
     * @covers PHPUnit_Framework_Constraint_ClassHasAttribute
 
1981
     * @covers PHPUnit_Framework_Assert::classHasAttribute
 
1982
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
1983
     */
 
1984
    public function testConstraintClassHasAttribute2()
 
1985
    {
 
1986
        $constraint = PHPUnit_Framework_Assert::classHasAttribute('privateAttribute');
 
1987
 
 
1988
        try {
 
1989
            $constraint->evaluate('stdClass', 'custom message');
 
1990
        }
 
1991
 
 
1992
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
1993
            $this->assertEquals(<<<EOF
 
1994
custom message
 
1995
Failed asserting that class "stdClass" has attribute "privateAttribute".
 
1996
 
 
1997
EOF
 
1998
              ,
 
1999
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2000
            );
 
2001
 
 
2002
            return;
 
2003
        }
 
2004
 
 
2005
        $this->fail();
 
2006
    }
 
2007
 
 
2008
    /**
 
2009
     * @covers PHPUnit_Framework_Constraint_ClassHasAttribute
 
2010
     * @covers PHPUnit_Framework_Constraint_Not
 
2011
     * @covers PHPUnit_Framework_Assert::classHasAttribute
 
2012
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2013
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2014
     */
 
2015
    public function testConstraintClassNotHasAttribute()
 
2016
    {
 
2017
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2018
          PHPUnit_Framework_Assert::classHasAttribute('privateAttribute')
 
2019
        );
 
2020
 
 
2021
        $this->assertTrue($constraint->evaluate('stdClass', '', true));
 
2022
        $this->assertFalse($constraint->evaluate('ClassWithNonPublicAttributes', '', true));
 
2023
        $this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
 
2024
        $this->assertEquals(1, count($constraint));
 
2025
 
 
2026
        try {
 
2027
            $constraint->evaluate('ClassWithNonPublicAttributes');
 
2028
        }
 
2029
 
 
2030
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2031
            $this->assertEquals(
 
2032
              <<<EOF
 
2033
Failed asserting that class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
2034
 
 
2035
EOF
 
2036
              ,
 
2037
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2038
            );
 
2039
 
 
2040
            return;
 
2041
        }
 
2042
 
 
2043
        $this->fail();
 
2044
    }
 
2045
 
 
2046
    /**
 
2047
     * @covers PHPUnit_Framework_Constraint_ClassHasAttribute
 
2048
     * @covers PHPUnit_Framework_Constraint_Not
 
2049
     * @covers PHPUnit_Framework_Assert::classHasAttribute
 
2050
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2051
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2052
     */
 
2053
    public function testConstraintClassNotHasAttribute2()
 
2054
    {
 
2055
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2056
          PHPUnit_Framework_Assert::classHasAttribute('privateAttribute')
 
2057
        );
 
2058
 
 
2059
        try {
 
2060
            $constraint->evaluate('ClassWithNonPublicAttributes', 'custom message');
 
2061
        }
 
2062
 
 
2063
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2064
            $this->assertEquals(<<<EOF
 
2065
custom message
 
2066
Failed asserting that class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
2067
 
 
2068
EOF
 
2069
              ,
 
2070
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2071
            );
 
2072
 
 
2073
            return;
 
2074
        }
 
2075
 
 
2076
        $this->fail();
 
2077
    }
 
2078
 
 
2079
    /**
 
2080
     * @covers PHPUnit_Framework_Constraint_ClassHasStaticAttribute
 
2081
     * @covers PHPUnit_Framework_Assert::classHasStaticAttribute
 
2082
     * @covers PHPUnit_Framework_Constraint::count
 
2083
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2084
     */
 
2085
    public function testConstraintClassHasStaticAttribute()
 
2086
    {
 
2087
        $constraint = PHPUnit_Framework_Assert::classHasStaticAttribute('privateStaticAttribute');
 
2088
 
 
2089
        $this->assertTrue($constraint->evaluate('ClassWithNonPublicAttributes', '', true));
 
2090
        $this->assertFalse($constraint->evaluate('stdClass', '', true));
 
2091
        $this->assertEquals('has static attribute "privateStaticAttribute"', $constraint->toString());
 
2092
        $this->assertEquals(1, count($constraint));
 
2093
 
 
2094
        try {
 
2095
            $constraint->evaluate('stdClass');
 
2096
        }
 
2097
 
 
2098
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2099
            $this->assertEquals(
 
2100
              <<<EOF
 
2101
Failed asserting that class "stdClass" has static attribute "privateStaticAttribute".
 
2102
 
 
2103
EOF
 
2104
              ,
 
2105
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2106
            );
 
2107
 
 
2108
            return;
 
2109
        }
 
2110
 
 
2111
        $this->fail();
 
2112
    }
 
2113
 
 
2114
    /**
 
2115
     * @covers PHPUnit_Framework_Constraint_ClassHasStaticAttribute
 
2116
     * @covers PHPUnit_Framework_Assert::classHasStaticAttribute
 
2117
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2118
     */
 
2119
    public function testConstraintClassHasStaticAttribute2()
 
2120
    {
 
2121
        $constraint = PHPUnit_Framework_Assert::classHasStaticAttribute('foo');
 
2122
 
 
2123
        try {
 
2124
            $constraint->evaluate('stdClass', 'custom message');
 
2125
        }
 
2126
 
 
2127
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2128
            $this->assertEquals(<<<EOF
 
2129
custom message
 
2130
Failed asserting that class "stdClass" has static attribute "foo".
 
2131
 
 
2132
EOF
 
2133
              ,
 
2134
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2135
            );
 
2136
 
 
2137
            return;
 
2138
        }
 
2139
 
 
2140
        $this->fail();
 
2141
    }
 
2142
 
 
2143
    /**
 
2144
     * @covers PHPUnit_Framework_Constraint_ClassHasStaticAttribute
 
2145
     * @covers PHPUnit_Framework_Constraint_Not
 
2146
     * @covers PHPUnit_Framework_Assert::classHasStaticAttribute
 
2147
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2148
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2149
     */
 
2150
    public function testConstraintClassNotHasStaticAttribute()
 
2151
    {
 
2152
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2153
          PHPUnit_Framework_Assert::classHasStaticAttribute('privateStaticAttribute')
 
2154
        );
 
2155
 
 
2156
        $this->assertTrue($constraint->evaluate('stdClass', '', true));
 
2157
        $this->assertFalse($constraint->evaluate('ClassWithNonPublicAttributes', '', true));
 
2158
        $this->assertEquals('does not have static attribute "privateStaticAttribute"', $constraint->toString());
 
2159
        $this->assertEquals(1, count($constraint));
 
2160
 
 
2161
        try {
 
2162
            $constraint->evaluate('ClassWithNonPublicAttributes');
 
2163
        }
 
2164
 
 
2165
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2166
            $this->assertEquals(
 
2167
              <<<EOF
 
2168
Failed asserting that class "ClassWithNonPublicAttributes" does not have static attribute "privateStaticAttribute".
 
2169
 
 
2170
EOF
 
2171
              ,
 
2172
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2173
            );
 
2174
 
 
2175
            return;
 
2176
        }
 
2177
 
 
2178
        $this->fail();
 
2179
    }
 
2180
 
 
2181
    /**
 
2182
     * @covers PHPUnit_Framework_Constraint_ClassHasStaticAttribute
 
2183
     * @covers PHPUnit_Framework_Constraint_Not
 
2184
     * @covers PHPUnit_Framework_Assert::classHasStaticAttribute
 
2185
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2186
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2187
     */
 
2188
    public function testConstraintClassNotHasStaticAttribute2()
 
2189
    {
 
2190
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2191
          PHPUnit_Framework_Assert::classHasStaticAttribute('privateStaticAttribute')
 
2192
        );
 
2193
 
 
2194
        try {
 
2195
            $constraint->evaluate('ClassWithNonPublicAttributes', 'custom message');
 
2196
        }
 
2197
 
 
2198
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2199
            $this->assertEquals(<<<EOF
 
2200
custom message
 
2201
Failed asserting that class "ClassWithNonPublicAttributes" does not have static attribute "privateStaticAttribute".
 
2202
 
 
2203
EOF
 
2204
              ,
 
2205
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2206
            );
 
2207
 
 
2208
            return;
 
2209
        }
 
2210
 
 
2211
        $this->fail();
 
2212
    }
 
2213
 
 
2214
    /**
 
2215
     * @covers PHPUnit_Framework_Constraint_ObjectHasAttribute
 
2216
     * @covers PHPUnit_Framework_Assert::objectHasAttribute
 
2217
     * @covers PHPUnit_Framework_Constraint::count
 
2218
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2219
     */
 
2220
    public function testConstraintObjectHasAttribute()
 
2221
    {
 
2222
        $constraint = PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute');
 
2223
 
 
2224
        $this->assertTrue($constraint->evaluate(new ClassWithNonPublicAttributes, '', true));
 
2225
        $this->assertFalse($constraint->evaluate(new stdClass, '', true));
 
2226
        $this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
 
2227
        $this->assertEquals(1, count($constraint));
 
2228
 
 
2229
        try {
 
2230
            $constraint->evaluate(new stdClass);
 
2231
        }
 
2232
 
 
2233
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2234
            $this->assertEquals(
 
2235
              <<<EOF
 
2236
Failed asserting that object of class "stdClass" has attribute "privateAttribute".
 
2237
 
 
2238
EOF
 
2239
              ,
 
2240
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2241
            );
 
2242
 
 
2243
            return;
 
2244
        }
 
2245
 
 
2246
        $this->fail();
 
2247
    }
 
2248
 
 
2249
    /**
 
2250
     * @covers PHPUnit_Framework_Constraint_ObjectHasAttribute
 
2251
     * @covers PHPUnit_Framework_Assert::objectHasAttribute
 
2252
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2253
     */
 
2254
    public function testConstraintObjectHasAttribute2()
 
2255
    {
 
2256
        $constraint = PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute');
 
2257
 
 
2258
        try {
 
2259
            $constraint->evaluate(new stdClass, 'custom message');
 
2260
        }
 
2261
 
 
2262
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2263
            $this->assertEquals(<<<EOF
 
2264
custom message
 
2265
Failed asserting that object of class "stdClass" has attribute "privateAttribute".
 
2266
 
 
2267
EOF
 
2268
              ,
 
2269
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2270
            );
 
2271
 
 
2272
            return;
 
2273
        }
 
2274
 
 
2275
        $this->fail();
 
2276
    }
 
2277
 
 
2278
    /**
 
2279
     * @covers PHPUnit_Framework_Constraint_ObjectHasAttribute
 
2280
     * @covers PHPUnit_Framework_Constraint_Not
 
2281
     * @covers PHPUnit_Framework_Assert::objectHasAttribute
 
2282
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2283
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2284
     */
 
2285
    public function testConstraintObjectNotHasAttribute()
 
2286
    {
 
2287
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2288
          PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute')
 
2289
        );
 
2290
 
 
2291
        $this->assertTrue($constraint->evaluate(new stdClass, '', true));
 
2292
        $this->assertFalse($constraint->evaluate(new ClassWithNonPublicAttributes, '', true));
 
2293
        $this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
 
2294
        $this->assertEquals(1, count($constraint));
 
2295
 
 
2296
        try {
 
2297
            $constraint->evaluate(new ClassWithNonPublicAttributes);
 
2298
        }
 
2299
 
 
2300
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2301
            $this->assertEquals(
 
2302
              <<<EOF
 
2303
Failed asserting that object of class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
2304
 
 
2305
EOF
 
2306
              ,
 
2307
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2308
            );
 
2309
 
 
2310
            return;
 
2311
        }
 
2312
 
 
2313
        $this->fail();
 
2314
    }
 
2315
 
 
2316
    /**
 
2317
     * @covers PHPUnit_Framework_Constraint_ObjectHasAttribute
 
2318
     * @covers PHPUnit_Framework_Constraint_Not
 
2319
     * @covers PHPUnit_Framework_Assert::objectHasAttribute
 
2320
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2321
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2322
     */
 
2323
    public function testConstraintObjectNotHasAttribute2()
 
2324
    {
 
2325
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2326
          PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute')
 
2327
        );
 
2328
 
 
2329
        try {
 
2330
            $constraint->evaluate(new ClassWithNonPublicAttributes, 'custom message');
 
2331
        }
 
2332
 
 
2333
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2334
            $this->assertEquals(<<<EOF
 
2335
custom message
 
2336
Failed asserting that object of class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute".
 
2337
 
 
2338
EOF
 
2339
              ,
 
2340
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2341
            );
 
2342
 
 
2343
            return;
 
2344
        }
 
2345
 
 
2346
        $this->fail();
 
2347
    }
 
2348
 
 
2349
    /**
 
2350
     * @covers PHPUnit_Framework_Constraint_PCREMatch
 
2351
     * @covers PHPUnit_Framework_Assert::matchesRegularExpression
 
2352
     * @covers PHPUnit_Framework_Constraint::count
 
2353
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2354
     */
 
2355
    public function testConstraintPCREMatch()
 
2356
    {
 
2357
        $constraint = PHPUnit_Framework_Assert::matchesRegularExpression('/foo/');
 
2358
 
 
2359
        $this->assertFalse($constraint->evaluate('barbazbar', '', true));
 
2360
        $this->assertTrue($constraint->evaluate('barfoobar', '', true));
 
2361
        $this->assertEquals('matches PCRE pattern "/foo/"', $constraint->toString());
 
2362
        $this->assertEquals(1, count($constraint));
 
2363
 
 
2364
        try {
 
2365
            $constraint->evaluate('barbazbar');
 
2366
        }
 
2367
 
 
2368
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2369
            $this->assertEquals(
 
2370
              <<<EOF
 
2371
Failed asserting that 'barbazbar' matches PCRE pattern "/foo/".
 
2372
 
 
2373
EOF
 
2374
              ,
 
2375
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2376
            );
 
2377
 
 
2378
            return;
 
2379
        }
 
2380
 
 
2381
        $this->fail();
 
2382
    }
 
2383
 
 
2384
    /**
 
2385
     * @covers PHPUnit_Framework_Constraint_PCREMatch
 
2386
     * @covers PHPUnit_Framework_Assert::matchesRegularExpression
 
2387
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2388
     */
 
2389
    public function testConstraintPCREMatch2()
 
2390
    {
 
2391
        $constraint = PHPUnit_Framework_Assert::matchesRegularExpression('/foo/');
 
2392
 
 
2393
        try {
 
2394
            $constraint->evaluate('barbazbar', 'custom message');
 
2395
        }
 
2396
 
 
2397
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2398
            $this->assertEquals(<<<EOF
 
2399
custom message
 
2400
Failed asserting that 'barbazbar' matches PCRE pattern "/foo/".
 
2401
 
 
2402
EOF
 
2403
              ,
 
2404
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2405
            );
 
2406
 
 
2407
            return;
 
2408
        }
 
2409
 
 
2410
        $this->fail();
 
2411
    }
 
2412
 
 
2413
    /**
 
2414
     * @covers PHPUnit_Framework_Constraint_PCREMatch
 
2415
     * @covers PHPUnit_Framework_Constraint_Not
 
2416
     * @covers PHPUnit_Framework_Assert::matchesRegularExpression
 
2417
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2418
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2419
     */
 
2420
    public function testConstraintPCRENotMatch()
 
2421
    {
 
2422
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2423
          PHPUnit_Framework_Assert::matchesRegularExpression('/foo/')
 
2424
        );
 
2425
 
 
2426
        $this->assertTrue($constraint->evaluate('barbazbar', '', true));
 
2427
        $this->assertFalse($constraint->evaluate('barfoobar', '', true));
 
2428
        $this->assertEquals('does not match PCRE pattern "/foo/"', $constraint->toString());
 
2429
        $this->assertEquals(1, count($constraint));
 
2430
 
 
2431
        try {
 
2432
            $constraint->evaluate('barfoobar');
 
2433
        }
 
2434
 
 
2435
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2436
            $this->assertEquals(
 
2437
              <<<EOF
 
2438
Failed asserting that 'barfoobar' does not match PCRE pattern "/foo/".
 
2439
 
 
2440
EOF
 
2441
              ,
 
2442
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2443
            );
 
2444
 
 
2445
            return;
 
2446
        }
 
2447
 
 
2448
        $this->fail();
 
2449
    }
 
2450
 
 
2451
    /**
 
2452
     * @covers PHPUnit_Framework_Constraint_PCREMatch
 
2453
     * @covers PHPUnit_Framework_Constraint_Not
 
2454
     * @covers PHPUnit_Framework_Assert::matchesRegularExpression
 
2455
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2456
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2457
     */
 
2458
    public function testConstraintPCRENotMatch2()
 
2459
    {
 
2460
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2461
          PHPUnit_Framework_Assert::matchesRegularExpression('/foo/')
 
2462
        );
 
2463
 
 
2464
        try {
 
2465
            $constraint->evaluate('barfoobar', 'custom message');
 
2466
        }
 
2467
 
 
2468
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2469
            $this->assertEquals(<<<EOF
 
2470
custom message
 
2471
Failed asserting that 'barfoobar' does not match PCRE pattern "/foo/".
 
2472
 
 
2473
EOF
 
2474
              ,
 
2475
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2476
            );
 
2477
 
 
2478
            return;
 
2479
        }
 
2480
 
 
2481
        $this->fail();
 
2482
    }
 
2483
 
 
2484
    /**
 
2485
     * @covers PHPUnit_Framework_Constraint_StringMatches
 
2486
     * @covers PHPUnit_Framework_Assert::matches
 
2487
     * @covers PHPUnit_Framework_Constraint::count
 
2488
     */
 
2489
    public function testConstraintStringMatches()
 
2490
    {
 
2491
        $constraint = PHPUnit_Framework_Assert::matches('*%c*');
 
2492
        $this->assertFalse($constraint->evaluate('**', '', true));
 
2493
        $this->assertTrue($constraint->evaluate('***', '', true));
 
2494
        $this->assertEquals('matches PCRE pattern "/^\*.\*$/s"', $constraint->toString());
 
2495
        $this->assertEquals(1, count($constraint));
 
2496
    }
 
2497
 
 
2498
    /**
 
2499
     * @covers PHPUnit_Framework_Constraint_StringMatches
 
2500
     * @covers PHPUnit_Framework_Assert::matches
 
2501
     * @covers PHPUnit_Framework_Constraint::count
 
2502
     */
 
2503
    public function testConstraintStringMatches2()
 
2504
    {
 
2505
        $constraint = PHPUnit_Framework_Assert::matches('*%s*');
 
2506
        $this->assertFalse($constraint->evaluate('**', '', true));
 
2507
        $this->assertTrue($constraint->evaluate('***', '', true));
 
2508
        $this->assertEquals('matches PCRE pattern "/^\*[^\r\n]+\*$/s"', $constraint->toString());
 
2509
        $this->assertEquals(1, count($constraint));
 
2510
    }
 
2511
 
 
2512
    /**
 
2513
     * @covers PHPUnit_Framework_Constraint_StringMatches
 
2514
     * @covers PHPUnit_Framework_Assert::matches
 
2515
     * @covers PHPUnit_Framework_Constraint::count
 
2516
     */
 
2517
    public function testConstraintStringMatches3()
 
2518
    {
 
2519
        $constraint = PHPUnit_Framework_Assert::matches('*%i*');
 
2520
        $this->assertFalse($constraint->evaluate('**', '', true));
 
2521
        $this->assertTrue($constraint->evaluate('*0*', '', true));
 
2522
        $this->assertEquals('matches PCRE pattern "/^\*[+-]?\d+\*$/s"', $constraint->toString());
 
2523
        $this->assertEquals(1, count($constraint));
 
2524
    }
 
2525
 
 
2526
    /**
 
2527
     * @covers PHPUnit_Framework_Constraint_StringMatches
 
2528
     * @covers PHPUnit_Framework_Assert::matches
 
2529
     * @covers PHPUnit_Framework_Constraint::count
 
2530
     */
 
2531
    public function testConstraintStringMatches4()
 
2532
    {
 
2533
        $constraint = PHPUnit_Framework_Assert::matches('*%d*');
 
2534
        $this->assertFalse($constraint->evaluate('**', '', true));
 
2535
        $this->assertTrue($constraint->evaluate('*0*', '', true));
 
2536
        $this->assertEquals('matches PCRE pattern "/^\*\d+\*$/s"', $constraint->toString());
 
2537
        $this->assertEquals(1, count($constraint));
 
2538
    }
 
2539
 
 
2540
    /**
 
2541
     * @covers PHPUnit_Framework_Constraint_StringMatches
 
2542
     * @covers PHPUnit_Framework_Assert::matches
 
2543
     * @covers PHPUnit_Framework_Constraint::count
 
2544
     */
 
2545
    public function testConstraintStringMatches5()
 
2546
    {
 
2547
        $constraint = PHPUnit_Framework_Assert::matches('*%x*');
 
2548
        $this->assertFalse($constraint->evaluate('**', '', true));
 
2549
        $this->assertTrue($constraint->evaluate('*0f0f0f*', '', true));
 
2550
        $this->assertEquals('matches PCRE pattern "/^\*[0-9a-fA-F]+\*$/s"', $constraint->toString());
 
2551
        $this->assertEquals(1, count($constraint));
 
2552
    }
 
2553
 
 
2554
    /**
 
2555
     * @covers PHPUnit_Framework_Constraint_StringMatches
 
2556
     * @covers PHPUnit_Framework_Assert::matches
 
2557
     * @covers PHPUnit_Framework_Constraint::count
 
2558
     */
 
2559
    public function testConstraintStringMatches6()
 
2560
    {
 
2561
        $constraint = PHPUnit_Framework_Assert::matches('*%f*');
 
2562
        $this->assertFalse($constraint->evaluate('**', '', true));
 
2563
        $this->assertTrue($constraint->evaluate('*1.0*', '', true));
 
2564
        $this->assertEquals('matches PCRE pattern "/^\*[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?\*$/s"', $constraint->toString());
 
2565
        $this->assertEquals(1, count($constraint));
 
2566
    }
 
2567
 
 
2568
    /**
 
2569
     * @covers PHPUnit_Framework_Constraint_StringStartsWith
 
2570
     * @covers PHPUnit_Framework_Assert::stringStartsWith
 
2571
     * @covers PHPUnit_Framework_Constraint::count
 
2572
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2573
     */
 
2574
    public function testConstraintStringStartsWith()
 
2575
    {
 
2576
        $constraint = PHPUnit_Framework_Assert::stringStartsWith('prefix');
 
2577
 
 
2578
        $this->assertFalse($constraint->evaluate('foo', '', true));
 
2579
        $this->assertTrue($constraint->evaluate('prefixfoo', '', true));
 
2580
        $this->assertEquals('starts with "prefix"', $constraint->toString());
 
2581
        $this->assertEquals(1, count($constraint));
 
2582
 
 
2583
        try {
 
2584
            $constraint->evaluate('foo');
 
2585
        }
 
2586
 
 
2587
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2588
            $this->assertEquals(
 
2589
              <<<EOF
 
2590
Failed asserting that 'foo' starts with "prefix".
 
2591
 
 
2592
EOF
 
2593
              ,
 
2594
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2595
            );
 
2596
 
 
2597
            return;
 
2598
        }
 
2599
 
 
2600
        $this->fail();
 
2601
    }
 
2602
 
 
2603
    /**
 
2604
     * @covers PHPUnit_Framework_Constraint_StringStartsWith
 
2605
     * @covers PHPUnit_Framework_Assert::stringStartsWith
 
2606
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2607
     */
 
2608
    public function testConstraintStringStartsWith2()
 
2609
    {
 
2610
        $constraint = PHPUnit_Framework_Assert::stringStartsWith('prefix');
 
2611
 
 
2612
        try {
 
2613
            $constraint->evaluate('foo', 'custom message');
 
2614
        }
 
2615
 
 
2616
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2617
            $this->assertEquals(
 
2618
              <<<EOF
 
2619
custom message\nFailed asserting that 'foo' starts with "prefix".
 
2620
 
 
2621
EOF
 
2622
              ,
 
2623
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2624
            );
 
2625
 
 
2626
            return;
 
2627
        }
 
2628
 
 
2629
        $this->fail();
 
2630
    }
 
2631
 
 
2632
    /**
 
2633
     * @covers PHPUnit_Framework_Constraint_StringStartsWith
 
2634
     * @covers PHPUnit_Framework_Constraint_Not
 
2635
     * @covers PHPUnit_Framework_Assert::stringStartsWith
 
2636
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2637
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2638
     */
 
2639
    public function testConstraintStringStartsNotWith()
 
2640
    {
 
2641
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2642
          PHPUnit_Framework_Assert::stringStartsWith('prefix')
 
2643
        );
 
2644
 
 
2645
        $this->assertTrue($constraint->evaluate('foo', '', true));
 
2646
        $this->assertFalse($constraint->evaluate('prefixfoo', '', true));
 
2647
        $this->assertEquals('starts not with "prefix"', $constraint->toString());
 
2648
        $this->assertEquals(1, count($constraint));
 
2649
 
 
2650
        try {
 
2651
            $constraint->evaluate('prefixfoo');
 
2652
        }
 
2653
 
 
2654
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2655
            $this->assertEquals(
 
2656
              <<<EOF
 
2657
Failed asserting that 'prefixfoo' starts not with "prefix".
 
2658
 
 
2659
EOF
 
2660
              ,
 
2661
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2662
            );
 
2663
 
 
2664
            return;
 
2665
        }
 
2666
 
 
2667
        $this->fail();
 
2668
    }
 
2669
 
 
2670
    /**
 
2671
     * @covers PHPUnit_Framework_Constraint_StringStartsWith
 
2672
     * @covers PHPUnit_Framework_Assert::stringStartsWith
 
2673
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2674
     */
 
2675
    public function testConstraintStringStartsNotWith2()
 
2676
    {
 
2677
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2678
          PHPUnit_Framework_Assert::stringStartsWith('prefix')
 
2679
        );
 
2680
 
 
2681
        try {
 
2682
            $constraint->evaluate('prefixfoo', 'custom message');
 
2683
        }
 
2684
 
 
2685
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2686
            $this->assertEquals(
 
2687
              <<<EOF
 
2688
custom message
 
2689
Failed asserting that 'prefixfoo' starts not with "prefix".
 
2690
 
 
2691
EOF
 
2692
              ,
 
2693
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2694
            );
 
2695
 
 
2696
            return;
 
2697
        }
 
2698
 
 
2699
        $this->fail();
 
2700
    }
 
2701
 
 
2702
    /**
 
2703
     * @covers PHPUnit_Framework_Constraint_StringContains
 
2704
     * @covers PHPUnit_Framework_Assert::stringContains
 
2705
     * @covers PHPUnit_Framework_Constraint::count
 
2706
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2707
     */
 
2708
    public function testConstraintStringContains()
 
2709
    {
 
2710
        $constraint = PHPUnit_Framework_Assert::stringContains('foo');
 
2711
 
 
2712
        $this->assertFalse($constraint->evaluate('barbazbar', '', true));
 
2713
        $this->assertTrue($constraint->evaluate('barfoobar', '', true));
 
2714
        $this->assertEquals('contains "foo"', $constraint->toString());
 
2715
        $this->assertEquals(1, count($constraint));
 
2716
 
 
2717
        try {
 
2718
            $constraint->evaluate('barbazbar');
 
2719
        }
 
2720
 
 
2721
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2722
            $this->assertEquals(
 
2723
              <<<EOF
 
2724
Failed asserting that 'barbazbar' contains "foo".
 
2725
 
 
2726
EOF
 
2727
              ,
 
2728
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2729
            );
 
2730
 
 
2731
            return;
 
2732
        }
 
2733
 
 
2734
        $this->fail();
 
2735
    }
 
2736
 
 
2737
    /**
 
2738
     * @covers PHPUnit_Framework_Constraint_StringContains
 
2739
     * @covers PHPUnit_Framework_Assert::stringContains
 
2740
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2741
     */
 
2742
    public function testConstraintStringContains2()
 
2743
    {
 
2744
        $constraint = PHPUnit_Framework_Assert::stringContains('foo');
 
2745
 
 
2746
        try {
 
2747
            $constraint->evaluate('barbazbar', 'custom message');
 
2748
        }
 
2749
 
 
2750
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2751
            $this->assertEquals(
 
2752
              <<<EOF
 
2753
custom message
 
2754
Failed asserting that 'barbazbar' contains "foo".
 
2755
 
 
2756
EOF
 
2757
              ,
 
2758
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2759
            );
 
2760
 
 
2761
            return;
 
2762
        }
 
2763
 
 
2764
        $this->fail();
 
2765
    }
 
2766
 
 
2767
    /**
 
2768
     * @covers PHPUnit_Framework_Constraint_StringContains
 
2769
     * @covers PHPUnit_Framework_Constraint_Not
 
2770
     * @covers PHPUnit_Framework_Assert::stringContains
 
2771
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2772
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2773
     */
 
2774
    public function testConstraintStringNotContains()
 
2775
    {
 
2776
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2777
          PHPUnit_Framework_Assert::stringContains('foo')
 
2778
        );
 
2779
 
 
2780
        $this->assertTrue($constraint->evaluate('barbazbar', '', true));
 
2781
        $this->assertFalse($constraint->evaluate('barfoobar', '', true));
 
2782
        $this->assertEquals('does not contain "foo"', $constraint->toString());
 
2783
        $this->assertEquals(1, count($constraint));
 
2784
 
 
2785
        try {
 
2786
            $constraint->evaluate('barfoobar');
 
2787
        }
 
2788
 
 
2789
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2790
            $this->assertEquals(
 
2791
              <<<EOF
 
2792
Failed asserting that 'barfoobar' does not contain "foo".
 
2793
 
 
2794
EOF
 
2795
              ,
 
2796
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2797
            );
 
2798
 
 
2799
            return;
 
2800
        }
 
2801
 
 
2802
        $this->fail();
 
2803
    }
 
2804
 
 
2805
    /**
 
2806
     * @covers PHPUnit_Framework_Constraint_StringContains
 
2807
     * @covers PHPUnit_Framework_Constraint_Not
 
2808
     * @covers PHPUnit_Framework_Assert::stringContains
 
2809
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2810
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2811
     */
 
2812
    public function testConstraintStringNotContains2()
 
2813
    {
 
2814
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2815
          PHPUnit_Framework_Assert::stringContains('foo')
 
2816
        );
 
2817
 
 
2818
        try {
 
2819
            $constraint->evaluate('barfoobar', 'custom message');
 
2820
        }
 
2821
 
 
2822
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2823
            $this->assertEquals(
 
2824
              <<<EOF
 
2825
custom message
 
2826
Failed asserting that 'barfoobar' does not contain "foo".
 
2827
 
 
2828
EOF
 
2829
              ,
 
2830
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2831
            );
 
2832
 
 
2833
            return;
 
2834
        }
 
2835
 
 
2836
        $this->fail();
 
2837
    }
 
2838
 
 
2839
    /**
 
2840
     * @covers PHPUnit_Framework_Constraint_StringEndsWith
 
2841
     * @covers PHPUnit_Framework_Assert::stringEndsWith
 
2842
     * @covers PHPUnit_Framework_Constraint::count
 
2843
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2844
     */
 
2845
    public function testConstraintStringEndsWith()
 
2846
    {
 
2847
        $constraint = PHPUnit_Framework_Assert::stringEndsWith('suffix');
 
2848
 
 
2849
        $this->assertFalse($constraint->evaluate('foo', '', true));
 
2850
        $this->assertTrue($constraint->evaluate('foosuffix', '', true));
 
2851
        $this->assertEquals('ends with "suffix"', $constraint->toString());
 
2852
        $this->assertEquals(1, count($constraint));
 
2853
 
 
2854
        try {
 
2855
            $constraint->evaluate('foo');
 
2856
        }
 
2857
 
 
2858
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2859
            $this->assertEquals(
 
2860
              <<<EOF
 
2861
Failed asserting that 'foo' ends with "suffix".
 
2862
 
 
2863
EOF
 
2864
              ,
 
2865
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2866
            );
 
2867
 
 
2868
            return;
 
2869
        }
 
2870
 
 
2871
        $this->fail();
 
2872
    }
 
2873
 
 
2874
    /**
 
2875
     * @covers PHPUnit_Framework_Constraint_StringEndsWith
 
2876
     * @covers PHPUnit_Framework_Assert::stringEndsWith
 
2877
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2878
     */
 
2879
    public function testConstraintStringEndsWith2()
 
2880
    {
 
2881
        $constraint = PHPUnit_Framework_Assert::stringEndsWith('suffix');
 
2882
 
 
2883
        try {
 
2884
            $constraint->evaluate('foo', 'custom message');
 
2885
        }
 
2886
 
 
2887
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2888
            $this->assertEquals(
 
2889
              <<<EOF
 
2890
custom message
 
2891
Failed asserting that 'foo' ends with "suffix".
 
2892
 
 
2893
EOF
 
2894
              ,
 
2895
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2896
            );
 
2897
 
 
2898
            return;
 
2899
        }
 
2900
 
 
2901
        $this->fail();
 
2902
    }
 
2903
 
 
2904
    /**
 
2905
     * @covers PHPUnit_Framework_Constraint_StringEndsWith
 
2906
     * @covers PHPUnit_Framework_Constraint_Not
 
2907
     * @covers PHPUnit_Framework_Assert::stringEndsWith
 
2908
     * @covers PHPUnit_Framework_Assert::logicalNot
 
2909
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2910
     */
 
2911
    public function testConstraintStringEndsNotWith()
 
2912
    {
 
2913
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2914
          PHPUnit_Framework_Assert::stringEndsWith('suffix')
 
2915
        );
 
2916
 
 
2917
        $this->assertTrue($constraint->evaluate('foo', '', true));
 
2918
        $this->assertFalse($constraint->evaluate('foosuffix', '', true));
 
2919
        $this->assertEquals('ends not with "suffix"', $constraint->toString());
 
2920
        $this->assertEquals(1, count($constraint));
 
2921
 
 
2922
        try {
 
2923
            $constraint->evaluate('foosuffix');
 
2924
        }
 
2925
 
 
2926
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2927
            $this->assertEquals(
 
2928
              <<<EOF
 
2929
Failed asserting that 'foosuffix' ends not with "suffix".
 
2930
 
 
2931
EOF
 
2932
              ,
 
2933
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2934
            );
 
2935
 
 
2936
            return;
 
2937
        }
 
2938
 
 
2939
        $this->fail();
 
2940
    }
 
2941
 
 
2942
    /**
 
2943
     * @covers PHPUnit_Framework_Constraint_StringEndsWith
 
2944
     * @covers PHPUnit_Framework_Assert::stringEndsWith
 
2945
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2946
     */
 
2947
    public function testConstraintStringEndsNotWith2()
 
2948
    {
 
2949
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
2950
          PHPUnit_Framework_Assert::stringEndsWith('suffix')
 
2951
        );
 
2952
 
 
2953
        try {
 
2954
            $constraint->evaluate('foosuffix', 'custom message');
 
2955
        }
 
2956
 
 
2957
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
2958
            $this->assertEquals(
 
2959
              <<<EOF
 
2960
custom message
 
2961
Failed asserting that 'foosuffix' ends not with "suffix".
 
2962
 
 
2963
EOF
 
2964
              ,
 
2965
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
2966
            );
 
2967
 
 
2968
            return;
 
2969
        }
 
2970
 
 
2971
        $this->fail();
 
2972
    }
 
2973
 
 
2974
    /**
 
2975
     * @covers PHPUnit_Framework_Constraint_TraversableContains
 
2976
     */
 
2977
    public function testConstraintArrayContainsCheckForObjectIdentity()
 
2978
    {
 
2979
        // Check for primitive type.
 
2980
        $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo', true, true);
 
2981
 
 
2982
        $this->assertFalse($constraint->evaluate(array(0), '', true));
 
2983
        $this->assertFalse($constraint->evaluate(array(true), '', true));
 
2984
 
 
2985
        // Default case.
 
2986
        $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo');
 
2987
 
 
2988
        $this->assertTrue($constraint->evaluate(array(0), '', true));
 
2989
        $this->assertTrue($constraint->evaluate(array(true), '', true));
 
2990
    }
 
2991
 
 
2992
    /**
 
2993
     * @covers PHPUnit_Framework_Constraint_TraversableContains
 
2994
     * @covers PHPUnit_Framework_Constraint::count
 
2995
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
2996
     */
 
2997
    public function testConstraintArrayContains()
 
2998
    {
 
2999
        $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo');
 
3000
 
 
3001
        $this->assertFalse($constraint->evaluate(array('bar'), '', true));
 
3002
        $this->assertTrue($constraint->evaluate(array('foo'), '', true));
 
3003
        $this->assertEquals("contains 'foo'", $constraint->toString());
 
3004
        $this->assertEquals(1, count($constraint));
 
3005
 
 
3006
        try {
 
3007
            $constraint->evaluate(array('bar'));
 
3008
        }
 
3009
 
 
3010
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3011
            $this->assertEquals(
 
3012
              <<<EOF
 
3013
Failed asserting that an array contains 'foo'.
 
3014
 
 
3015
EOF
 
3016
              ,
 
3017
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3018
            );
 
3019
 
 
3020
            return;
 
3021
        }
 
3022
 
 
3023
        $this->fail();
 
3024
    }
 
3025
 
 
3026
    /**
 
3027
     * @covers PHPUnit_Framework_Constraint_TraversableContains
 
3028
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3029
     */
 
3030
    public function testConstraintArrayContains2()
 
3031
    {
 
3032
        $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo');
 
3033
 
 
3034
        try {
 
3035
            $constraint->evaluate(array('bar'), 'custom message');
 
3036
        }
 
3037
 
 
3038
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3039
            $this->assertEquals(
 
3040
              <<<EOF
 
3041
custom message
 
3042
Failed asserting that an array contains 'foo'.
 
3043
 
 
3044
EOF
 
3045
              ,
 
3046
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3047
            );
 
3048
 
 
3049
            return;
 
3050
        }
 
3051
 
 
3052
        $this->fail();
 
3053
    }
 
3054
 
 
3055
    /**
 
3056
     * @covers PHPUnit_Framework_Constraint_TraversableContains
 
3057
     * @covers PHPUnit_Framework_Constraint_Not
 
3058
     * @covers PHPUnit_Framework_Assert::logicalNot
 
3059
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3060
     */
 
3061
    public function testConstraintArrayNotContains()
 
3062
    {
 
3063
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
3064
          new PHPUnit_Framework_Constraint_TraversableContains('foo')
 
3065
        );
 
3066
 
 
3067
        $this->assertTrue($constraint->evaluate(array('bar'), '', true));
 
3068
        $this->assertFalse($constraint->evaluate(array('foo'), '', true));
 
3069
        $this->assertEquals("does not contain 'foo'", $constraint->toString());
 
3070
        $this->assertEquals(1, count($constraint));
 
3071
 
 
3072
        try {
 
3073
            $constraint->evaluate(array('foo'));
 
3074
        }
 
3075
 
 
3076
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3077
            $this->assertEquals(
 
3078
              <<<EOF
 
3079
Failed asserting that an array does not contain 'foo'.
 
3080
 
 
3081
EOF
 
3082
              ,
 
3083
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3084
            );
 
3085
 
 
3086
            return;
 
3087
        }
 
3088
 
 
3089
        $this->fail();
 
3090
    }
 
3091
 
 
3092
    /**
 
3093
     * @covers PHPUnit_Framework_Constraint_TraversableContains
 
3094
     * @covers PHPUnit_Framework_Constraint_Not
 
3095
     * @covers PHPUnit_Framework_Assert::logicalNot
 
3096
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3097
     */
 
3098
    public function testConstraintArrayNotContains2()
 
3099
    {
 
3100
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
3101
          new PHPUnit_Framework_Constraint_TraversableContains('foo')
 
3102
        );
 
3103
 
 
3104
        try {
 
3105
            $constraint->evaluate(array('foo'), 'custom message');
 
3106
        }
 
3107
 
 
3108
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3109
            $this->assertEquals(
 
3110
              <<<EOF
 
3111
custom message
 
3112
Failed asserting that an array does not contain 'foo'.
 
3113
 
 
3114
EOF
 
3115
              ,
 
3116
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3117
            );
 
3118
 
 
3119
            return;
 
3120
        }
 
3121
 
 
3122
        $this->fail();
 
3123
    }
 
3124
 
 
3125
    /**
 
3126
     * @covers PHPUnit_Framework_Constraint_TraversableContains
 
3127
     * @covers PHPUnit_Framework_Constraint::count
 
3128
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3129
     */
 
3130
    public function testConstraintSplObjectStorageContains()
 
3131
    {
 
3132
        $object     = new StdClass;
 
3133
        $constraint = new PHPUnit_Framework_Constraint_TraversableContains($object);
 
3134
        $this->assertStringMatchesFormat("contains stdClass Object &%s ()", $constraint->toString());
 
3135
 
 
3136
        $storage = new SplObjectStorage;
 
3137
        $this->assertFalse($constraint->evaluate($storage, '', true));
 
3138
 
 
3139
        $storage->attach($object);
 
3140
        $this->assertTrue($constraint->evaluate($storage, '', true));
 
3141
 
 
3142
        try {
 
3143
            $constraint->evaluate(new SplObjectStorage);
 
3144
        }
 
3145
 
 
3146
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3147
            $this->assertStringMatchesFormat(
 
3148
              <<<EOF
 
3149
Failed asserting that a traversable contains stdClass Object &%x ().
 
3150
 
 
3151
EOF
 
3152
              ,
 
3153
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3154
            );
 
3155
 
 
3156
            return;
 
3157
        }
 
3158
 
 
3159
        $this->fail();
 
3160
    }
 
3161
 
 
3162
    /**
 
3163
     * @covers PHPUnit_Framework_Constraint_TraversableContains
 
3164
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3165
     */
 
3166
    public function testConstraintSplObjectStorageContains2()
 
3167
    {
 
3168
        $object     = new StdClass;
 
3169
        $constraint = new PHPUnit_Framework_Constraint_TraversableContains($object);
 
3170
 
 
3171
        try {
 
3172
            $constraint->evaluate(new SplObjectStorage, 'custom message');
 
3173
        }
 
3174
 
 
3175
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3176
            $this->assertStringMatchesFormat(
 
3177
              <<<EOF
 
3178
custom message
 
3179
Failed asserting that a traversable contains stdClass Object &%x ().
 
3180
 
 
3181
EOF
 
3182
              ,
 
3183
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3184
            );
 
3185
 
 
3186
            return;
 
3187
        }
 
3188
 
 
3189
        $this->fail();
 
3190
    }
 
3191
 
 
3192
    /**
 
3193
     * @covers PHPUnit_Framework_Assert::attributeEqualTo
 
3194
     * @covers PHPUnit_Framework_Constraint_Attribute
 
3195
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3196
     */
 
3197
    public function testAttributeEqualTo()
 
3198
    {
 
3199
        $object     = new ClassWithNonPublicAttributes;
 
3200
        $constraint = PHPUnit_Framework_Assert::attributeEqualTo('foo', 1);
 
3201
 
 
3202
        $this->assertTrue($constraint->evaluate($object, '', true));
 
3203
        $this->assertEquals('attribute "foo" is equal to 1', $constraint->toString());
 
3204
        $this->assertEquals(1, count($constraint));
 
3205
 
 
3206
        $constraint = PHPUnit_Framework_Assert::attributeEqualTo('foo', 2);
 
3207
 
 
3208
        $this->assertFalse($constraint->evaluate($object, '', true));
 
3209
 
 
3210
        try {
 
3211
            $constraint->evaluate($object);
 
3212
        }
 
3213
 
 
3214
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3215
            $this->assertEquals(
 
3216
              <<<EOF
 
3217
Failed asserting that attribute "foo" is equal to 2.
 
3218
 
 
3219
EOF
 
3220
              ,
 
3221
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3222
            );
 
3223
 
 
3224
            return;
 
3225
        }
 
3226
 
 
3227
        $this->fail();
 
3228
    }
 
3229
 
 
3230
    /**
 
3231
     * @covers PHPUnit_Framework_Assert::attributeEqualTo
 
3232
     * @covers PHPUnit_Framework_Constraint_Attribute
 
3233
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3234
     */
 
3235
    public function testAttributeEqualTo2()
 
3236
    {
 
3237
        $object     = new ClassWithNonPublicAttributes;
 
3238
        $constraint = PHPUnit_Framework_Assert::attributeEqualTo('foo', 2);
 
3239
 
 
3240
        try {
 
3241
            $constraint->evaluate($object, 'custom message');
 
3242
        }
 
3243
 
 
3244
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3245
            $this->assertEquals(
 
3246
              <<<EOF
 
3247
custom message\nFailed asserting that attribute "foo" is equal to 2.
 
3248
 
 
3249
EOF
 
3250
              ,
 
3251
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3252
            );
 
3253
 
 
3254
            return;
 
3255
        }
 
3256
 
 
3257
        $this->fail();
 
3258
    }
 
3259
 
 
3260
    /**
 
3261
     * @covers PHPUnit_Framework_Assert::attributeEqualTo
 
3262
     * @covers PHPUnit_Framework_Assert::logicalNot
 
3263
     * @covers PHPUnit_Framework_Constraint_Attribute
 
3264
     * @covers PHPUnit_Framework_Constraint_Not
 
3265
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3266
     */
 
3267
    public function testAttributeNotEqualTo()
 
3268
    {
 
3269
        $object     = new ClassWithNonPublicAttributes;
 
3270
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
3271
          PHPUnit_Framework_Assert::attributeEqualTo('foo', 2)
 
3272
        );
 
3273
 
 
3274
        $this->assertTrue($constraint->evaluate($object, '', true));
 
3275
        $this->assertEquals('attribute "foo" is not equal to 2', $constraint->toString());
 
3276
        $this->assertEquals(1, count($constraint));
 
3277
 
 
3278
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
3279
          PHPUnit_Framework_Assert::attributeEqualTo('foo', 1)
 
3280
        );
 
3281
 
 
3282
        $this->assertFalse($constraint->evaluate($object, '', true));
 
3283
 
 
3284
        try {
 
3285
            $constraint->evaluate($object);
 
3286
        }
 
3287
 
 
3288
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3289
            $this->assertEquals(
 
3290
              <<<EOF
 
3291
Failed asserting that attribute "foo" is not equal to 1.
 
3292
 
 
3293
EOF
 
3294
              ,
 
3295
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3296
            );
 
3297
 
 
3298
            return;
 
3299
        }
 
3300
 
 
3301
        $this->fail();
 
3302
    }
 
3303
 
 
3304
    /**
 
3305
     * @covers PHPUnit_Framework_Assert::attributeEqualTo
 
3306
     * @covers PHPUnit_Framework_Assert::logicalNot
 
3307
     * @covers PHPUnit_Framework_Constraint_Attribute
 
3308
     * @covers PHPUnit_Framework_Constraint_Not
 
3309
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3310
     */
 
3311
    public function testAttributeNotEqualTo2()
 
3312
    {
 
3313
        $object     = new ClassWithNonPublicAttributes;
 
3314
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
3315
          PHPUnit_Framework_Assert::attributeEqualTo('foo', 1)
 
3316
        );
 
3317
 
 
3318
        try {
 
3319
            $constraint->evaluate($object, 'custom message');
 
3320
        }
 
3321
 
 
3322
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3323
            $this->assertEquals(
 
3324
              <<<EOF
 
3325
custom message\nFailed asserting that attribute "foo" is not equal to 1.
 
3326
 
 
3327
EOF
 
3328
              ,
 
3329
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3330
            );
 
3331
 
 
3332
            return;
 
3333
        }
 
3334
 
 
3335
        $this->fail();
 
3336
    }
 
3337
 
 
3338
    /**
 
3339
     * @covers PHPUnit_Framework_Constraint_IsEmpty
 
3340
     * @covers PHPUnit_Framework_Constraint::count
 
3341
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3342
     */
 
3343
    public function testConstraintIsEmpty()
 
3344
    {
 
3345
        $constraint = new PHPUnit_Framework_Constraint_IsEmpty;
 
3346
 
 
3347
        $this->assertFalse($constraint->evaluate(array('foo'), '', true));
 
3348
        $this->assertTrue($constraint->evaluate(array(), '', true));
 
3349
        $this->assertFalse($constraint->evaluate(new ArrayObject(array('foo')), '', true));
 
3350
        $this->assertTrue($constraint->evaluate(new ArrayObject(array()), '', true));
 
3351
        $this->assertEquals('is empty', $constraint->toString());
 
3352
        $this->assertEquals(1, count($constraint));
 
3353
 
 
3354
        try {
 
3355
            $constraint->evaluate(array('foo'));
 
3356
        }
 
3357
 
 
3358
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3359
            $this->assertEquals(
 
3360
              <<<EOF
 
3361
Failed asserting that an array is empty.
 
3362
 
 
3363
EOF
 
3364
              ,
 
3365
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3366
            );
 
3367
 
 
3368
            return;
 
3369
        }
 
3370
 
 
3371
        $this->fail();
 
3372
    }
 
3373
 
 
3374
    /**
 
3375
     * @covers PHPUnit_Framework_Constraint_IsEmpty
 
3376
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3377
     */
 
3378
    public function testConstraintIsEmpty2()
 
3379
    {
 
3380
        $constraint = new PHPUnit_Framework_Constraint_IsEmpty;
 
3381
 
 
3382
        try {
 
3383
            $constraint->evaluate(array('foo'), 'custom message');
 
3384
        }
 
3385
 
 
3386
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3387
            $this->assertEquals(
 
3388
              <<<EOF
 
3389
custom message\nFailed asserting that an array is empty.
 
3390
 
 
3391
EOF
 
3392
              ,
 
3393
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3394
            );
 
3395
 
 
3396
            return;
 
3397
        }
 
3398
 
 
3399
        $this->fail();
 
3400
    }
 
3401
 
 
3402
    /**
 
3403
     * @covers PHPUnit_Framework_Constraint_Count
 
3404
     */
 
3405
    public function testConstraintCountWithAnArray()
 
3406
    {
 
3407
        $constraint = new PHPUnit_Framework_Constraint_Count(5);
 
3408
 
 
3409
        $this->assertTrue($constraint->evaluate(array(1,2,3,4,5), '', true));
 
3410
        $this->assertFalse($constraint->evaluate(array(1,2,3,4), '', true));
 
3411
    }
 
3412
 
 
3413
    /**
 
3414
     * @covers PHPUnit_Framework_Constraint_Count
 
3415
     */
 
3416
    public function testConstraintCountWithAnIteratorWhichDoesNotImplementCountable()
 
3417
    {
 
3418
        $constraint = new PHPUnit_Framework_Constraint_Count(5);
 
3419
 
 
3420
        $this->assertTrue($constraint->evaluate(new TestIterator(array(1,2,3,4,5)), '', true));
 
3421
        $this->assertFalse($constraint->evaluate(new TestIterator(array(1,2,3,4)), '', true));
 
3422
    }
 
3423
 
 
3424
    /**
 
3425
     * @covers PHPUnit_Framework_Constraint_Count
 
3426
     */
 
3427
    public function testConstraintCountWithAnObjectImplementingCountable()
 
3428
    {
 
3429
        $constraint = new PHPUnit_Framework_Constraint_Count(5);
 
3430
 
 
3431
        $this->assertTrue($constraint->evaluate(new ArrayObject(array(1,2,3,4,5)), '', true));
 
3432
        $this->assertFalse($constraint->evaluate(new ArrayObject(array(1,2,3,4)), '', true));
 
3433
    }
 
3434
 
 
3435
    /**
 
3436
     * @covers PHPUnit_Framework_Constraint_Count
 
3437
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3438
     */
 
3439
    public function testConstraintCountFailing()
 
3440
    {
 
3441
        $constraint = new PHPUnit_Framework_Constraint_Count(5);
 
3442
 
 
3443
        try {
 
3444
            $constraint->evaluate(array(1,2));
 
3445
        }
 
3446
 
 
3447
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3448
            $this->assertEquals(
 
3449
              <<<EOF
 
3450
Failed asserting that actual size 2 matches expected size 5.
 
3451
 
 
3452
EOF
 
3453
              ,
 
3454
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3455
            );
 
3456
 
 
3457
            return;
 
3458
        }
 
3459
 
 
3460
        $this->fail();
 
3461
    }
 
3462
 
 
3463
    /**
 
3464
     * @covers PHPUnit_Framework_Constraint_Count
 
3465
     * @covers PHPUnit_Framework_Constraint_Not
 
3466
     * @covers PHPUnit_Framework_Assert::logicalNot
 
3467
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3468
     */
 
3469
    public function testConstraintNotCountFailing()
 
3470
    {
 
3471
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
3472
          new PHPUnit_Framework_Constraint_Count(2)
 
3473
        );
 
3474
 
 
3475
        try {
 
3476
            $constraint->evaluate(array(1,2));
 
3477
        }
 
3478
 
 
3479
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3480
            $this->assertEquals(
 
3481
              <<<EOF
 
3482
Failed asserting that actual size 2 does not match expected size 2.
 
3483
 
 
3484
EOF
 
3485
              ,
 
3486
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3487
            );
 
3488
 
 
3489
            return;
 
3490
        }
 
3491
 
 
3492
        $this->fail();
 
3493
    }
 
3494
 
 
3495
    /**
 
3496
     * @covers PHPUnit_Framework_Constraint_SameSize
 
3497
     */
 
3498
    public function testConstraintSameSizeWithAnArray()
 
3499
    {
 
3500
        $constraint = new PHPUnit_Framework_Constraint_SameSize(array(1,2,3,4,5));
 
3501
 
 
3502
        $this->assertTrue($constraint->evaluate(array(6,7,8,9,10), '', true));
 
3503
        $this->assertFalse($constraint->evaluate(array(1,2,3,4), '', true));
 
3504
    }
 
3505
 
 
3506
    /**
 
3507
     * @covers PHPUnit_Framework_Constraint_SameSize
 
3508
     */
 
3509
    public function testConstraintSameSizeWithAnIteratorWhichDoesNotImplementCountable()
 
3510
    {
 
3511
        $constraint = new PHPUnit_Framework_Constraint_SameSize(new TestIterator(array(1,2,3,4,5)));
 
3512
 
 
3513
        $this->assertTrue($constraint->evaluate(new TestIterator(array(6,7,8,9,10)), '', true));
 
3514
        $this->assertFalse($constraint->evaluate(new TestIterator(array(1,2,3,4)), '', true));
 
3515
    }
 
3516
 
 
3517
    /**
 
3518
     * @covers PHPUnit_Framework_Constraint_SameSize
 
3519
     */
 
3520
    public function testConstraintSameSizeWithAnObjectImplementingCountable()
 
3521
    {
 
3522
        $constraint = new PHPUnit_Framework_Constraint_SameSize(new ArrayObject(array(1,2,3,4,5)));
 
3523
 
 
3524
        $this->assertTrue($constraint->evaluate(new ArrayObject(array(6,7,8,9,10)), '', true));
 
3525
        $this->assertFalse($constraint->evaluate(new ArrayObject(array(1,2,3,4)), '', true));
 
3526
    }
 
3527
 
 
3528
    /**
 
3529
     * @covers PHPUnit_Framework_Constraint_SameSize
 
3530
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3531
     */
 
3532
    public function testConstraintSameSizeFailing()
 
3533
    {
 
3534
        $constraint = new PHPUnit_Framework_Constraint_SameSize(array(1,2,3,4,5));
 
3535
 
 
3536
        try {
 
3537
            $constraint->evaluate(array(1,2));
 
3538
        }
 
3539
 
 
3540
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3541
            $this->assertEquals(
 
3542
              <<<EOF
 
3543
Failed asserting that actual size 2 matches expected size 5.
 
3544
 
 
3545
EOF
 
3546
              ,
 
3547
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3548
            );
 
3549
 
 
3550
            return;
 
3551
        }
 
3552
 
 
3553
        $this->fail();
 
3554
    }
 
3555
 
 
3556
    /**
 
3557
     * @covers PHPUnit_Framework_Constraint_SameSize
 
3558
     * @covers PHPUnit_Framework_Constraint_Not
 
3559
     * @covers PHPUnit_Framework_Assert::logicalNot
 
3560
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3561
     */
 
3562
    public function testConstraintNotSameSizeFailing()
 
3563
    {
 
3564
        $constraint = PHPUnit_Framework_Assert::logicalNot(
 
3565
          new PHPUnit_Framework_Constraint_SameSize(array(1,2))
 
3566
        );
 
3567
 
 
3568
        try {
 
3569
            $constraint->evaluate(array(3,4));
 
3570
        }
 
3571
 
 
3572
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3573
            $this->assertEquals(
 
3574
              <<<EOF
 
3575
Failed asserting that actual size 2 does not match expected size 2.
 
3576
 
 
3577
EOF
 
3578
              ,
 
3579
              PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3580
            );
 
3581
 
 
3582
            return;
 
3583
        }
 
3584
 
 
3585
        $this->fail();
 
3586
    }
 
3587
 
 
3588
    /**
 
3589
     * @covers PHPUnit_Framework_Constraint_Exception
 
3590
     * @covers PHPUnit_Framework_TestFailure::exceptionToString
 
3591
     */
 
3592
    public function testConstraintException()
 
3593
    {
 
3594
        $constraint = new PHPUnit_Framework_Constraint_Exception('FoobarException');
 
3595
        $exception = new DummyException('Test');
 
3596
        $stackTrace = $exception->getTraceAsString();
 
3597
 
 
3598
        try {
 
3599
            $constraint->evaluate($exception);
 
3600
        }
 
3601
 
 
3602
        catch (PHPUnit_Framework_ExpectationFailedException $e) {
 
3603
            $this->assertEquals(
 
3604
              <<<EOF
 
3605
Failed asserting that exception of type "DummyException" matches expected exception "FoobarException". Message was: "Test" at
 
3606
$stackTrace.
 
3607
 
 
3608
EOF
 
3609
                ,
 
3610
                PHPUnit_Framework_TestFailure::exceptionToString($e)
 
3611
            );
 
3612
 
 
3613
            return;
 
3614
        }
 
3615
 
 
3616
        $this->fail();
 
3617
    }
 
3618
 
 
3619
    /**
 
3620
     * Removes spaces in front of newlines
 
3621
     *
 
3622
     * @param  string $string
 
3623
     * @return string
 
3624
     */
 
3625
    private function trimnl($string)
 
3626
    {
 
3627
        return preg_replace('/[ ]*\n/', "\n", $string);
 
3628
    }
 
3629
}