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
11class Framework_AssertTest extends PHPUnit_Framework_TestCase
12{
13    /**
14     * @var string
15     */
16    private $filesDirectory;
17
18    protected function setUp()
19    {
20        $this->filesDirectory = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR;
21    }
22
23    public function testFail()
24    {
25        try {
26            $this->fail();
27        } catch (PHPUnit_Framework_AssertionFailedError $e) {
28            return;
29        }
30
31        throw new PHPUnit_Framework_AssertionFailedError('Fail did not throw fail exception');
32    }
33
34    public function testAssertSplObjectStorageContainsObject()
35    {
36        $a = new stdClass;
37        $b = new stdClass;
38        $c = new SplObjectStorage;
39        $c->attach($a);
40
41        $this->assertContains($a, $c);
42
43        try {
44            $this->assertContains($b, $c);
45        } catch (PHPUnit_Framework_AssertionFailedError $e) {
46            return;
47        }
48
49        $this->fail();
50    }
51
52    public function testAssertArrayContainsObject()
53    {
54        $a = new stdClass;
55        $b = new stdClass;
56
57        $this->assertContains($a, [$a]);
58
59        try {
60            $this->assertContains($a, [$b]);
61        } catch (PHPUnit_Framework_AssertionFailedError $e) {
62            return;
63        }
64
65        $this->fail();
66    }
67
68    public function testAssertArrayContainsString()
69    {
70        $this->assertContains('foo', ['foo']);
71
72        try {
73            $this->assertContains('foo', ['bar']);
74        } catch (PHPUnit_Framework_AssertionFailedError $e) {
75            return;
76        }
77
78        $this->fail();
79    }
80
81    public function testAssertArrayContainsNonObject()
82    {
83        $this->assertContains('foo', [true]);
84
85        try {
86            $this->assertContains('foo', [true], '', false, true, true);
87        } catch (PHPUnit_Framework_AssertionFailedError $e) {
88            return;
89        }
90
91        $this->fail();
92    }
93
94    public function testAssertContainsOnlyInstancesOf()
95    {
96        $test = [
97            new Book(),
98            new Book
99        ];
100        $this->assertContainsOnlyInstancesOf('Book', $test);
101        $this->assertContainsOnlyInstancesOf('stdClass', [new stdClass()]);
102
103        $test2 = [
104            new Author('Test')
105        ];
106        try {
107            $this->assertContainsOnlyInstancesOf('Book', $test2);
108        } catch (PHPUnit_Framework_AssertionFailedError $e) {
109            return;
110        }
111        $this->fail();
112    }
113
114    /**
115     * @expectedException PHPUnit_Framework_Exception
116     */
117    public function testAssertArrayHasKeyThrowsExceptionForInvalidFirstArgument()
118    {
119        $this->assertArrayHasKey(null, []);
120    }
121
122    /**
123     * @expectedException PHPUnit_Framework_Exception
124     */
125    public function testAssertArrayHasKeyThrowsExceptionForInvalidSecondArgument()
126    {
127        $this->assertArrayHasKey(0, null);
128    }
129
130    public function testAssertArrayHasIntegerKey()
131    {
132        $this->assertArrayHasKey(0, ['foo']);
133
134        try {
135            $this->assertArrayHasKey(1, ['foo']);
136        } catch (PHPUnit_Framework_AssertionFailedError $e) {
137            return;
138        }
139
140        $this->fail();
141    }
142
143    public function testAssertArraySubset()
144    {
145        $array = [
146            'a' => 'item a',
147            'b' => 'item b',
148            'c' => ['a2' => 'item a2', 'b2' => 'item b2'],
149            'd' => ['a2' => ['a3' => 'item a3', 'b3' => 'item b3']]
150        ];
151
152        $this->assertArraySubset(['a' => 'item a', 'c' => ['a2' => 'item a2']], $array);
153        $this->assertArraySubset(['a' => 'item a', 'd' => ['a2' => ['b3' => 'item b3']]], $array);
154
155        $arrayAccessData = new ArrayObject($array);
156
157        $this->assertArraySubset(['a' => 'item a', 'c' => ['a2' => 'item a2']], $arrayAccessData);
158        $this->assertArraySubset(['a' => 'item a', 'd' => ['a2' => ['b3' => 'item b3']]], $arrayAccessData);
159
160        try {
161            $this->assertArraySubset(['a' => 'bad value'], $array);
162        } catch (PHPUnit_Framework_AssertionFailedError $e) {
163        }
164
165        try {
166            $this->assertArraySubset(['d' => ['a2' => ['bad index' => 'item b3']]], $array);
167        } catch (PHPUnit_Framework_AssertionFailedError $e) {
168            return;
169        }
170
171        $this->fail();
172    }
173
174    public function testAssertArraySubsetWithDeepNestedArrays()
175    {
176        $array = [
177            'path' => [
178                'to' => [
179                    'the' => [
180                        'cake' => 'is a lie'
181                    ]
182                ]
183            ]
184        ];
185
186        $this->assertArraySubset(['path' => []], $array);
187        $this->assertArraySubset(['path' => ['to' => []]], $array);
188        $this->assertArraySubset(['path' => ['to' => ['the' => []]]], $array);
189        $this->assertArraySubset(['path' => ['to' => ['the' => ['cake' => 'is a lie']]]], $array);
190
191        try {
192            $this->assertArraySubset(['path' => ['to' => ['the' => ['cake' => 'is not a lie']]]], $array);
193        } catch (PHPUnit_Framework_AssertionFailedError $e) {
194            return;
195        }
196
197        $this->fail();
198    }
199
200    public function testAssertArraySubsetWithNoStrictCheckAndObjects()
201    {
202        $obj       = new \stdClass;
203        $reference = &$obj;
204        $array     = ['a' => $obj];
205
206        $this->assertArraySubset(['a' => $reference], $array);
207        $this->assertArraySubset(['a' => new \stdClass], $array);
208    }
209
210    public function testAssertArraySubsetWithStrictCheckAndObjects()
211    {
212        $obj       = new \stdClass;
213        $reference = &$obj;
214        $array     = ['a' => $obj];
215
216        $this->assertArraySubset(['a' => $reference], $array, true);
217
218        try {
219            $this->assertArraySubset(['a' => new \stdClass], $array, true);
220        } catch (PHPUnit_Framework_AssertionFailedError $e) {
221            return;
222        }
223
224        $this->fail('Strict recursive array check fail.');
225    }
226
227    /**
228     * @expectedException PHPUnit_Framework_Exception
229     * @expectedExceptionMessage array or ArrayAccess
230     * @dataProvider assertArraySubsetInvalidArgumentProvider
231     */
232    public function testAssertArraySubsetRaisesExceptionForInvalidArguments($partial, $subject)
233    {
234        $this->assertArraySubset($partial, $subject);
235    }
236
237    /**
238     * @return array
239     */
240    public function assertArraySubsetInvalidArgumentProvider()
241    {
242        return [
243            [false, []],
244            [[], false],
245        ];
246    }
247
248    /**
249     * @expectedException PHPUnit_Framework_Exception
250     */
251    public function testAssertArrayNotHasKeyThrowsExceptionForInvalidFirstArgument()
252    {
253        $this->assertArrayNotHasKey(null, []);
254    }
255
256    /**
257     * @expectedException PHPUnit_Framework_Exception
258     */
259    public function testAssertArrayNotHasKeyThrowsExceptionForInvalidSecondArgument()
260    {
261        $this->assertArrayNotHasKey(0, null);
262    }
263
264    public function testAssertArrayNotHasIntegerKey()
265    {
266        $this->assertArrayNotHasKey(1, ['foo']);
267
268        try {
269            $this->assertArrayNotHasKey(0, ['foo']);
270        } catch (PHPUnit_Framework_AssertionFailedError $e) {
271            return;
272        }
273
274        $this->fail();
275    }
276
277    public function testAssertArrayHasStringKey()
278    {
279        $this->assertArrayHasKey('foo', ['foo' => 'bar']);
280
281        try {
282            $this->assertArrayHasKey('bar', ['foo' => 'bar']);
283        } catch (PHPUnit_Framework_AssertionFailedError $e) {
284            return;
285        }
286
287        $this->fail();
288    }
289
290    public function testAssertArrayNotHasStringKey()
291    {
292        $this->assertArrayNotHasKey('bar', ['foo' => 'bar']);
293
294        try {
295            $this->assertArrayNotHasKey('foo', ['foo' => 'bar']);
296        } catch (PHPUnit_Framework_AssertionFailedError $e) {
297            return;
298        }
299
300        $this->fail();
301    }
302
303    public function testAssertArrayHasKeyAcceptsArrayObjectValue()
304    {
305        $array        = new ArrayObject();
306        $array['foo'] = 'bar';
307        $this->assertArrayHasKey('foo', $array);
308    }
309
310    /**
311     * @expectedException PHPUnit_Framework_AssertionFailedError
312     */
313    public function testAssertArrayHasKeyProperlyFailsWithArrayObjectValue()
314    {
315        $array        = new ArrayObject();
316        $array['bar'] = 'bar';
317        $this->assertArrayHasKey('foo', $array);
318    }
319
320    public function testAssertArrayHasKeyAcceptsArrayAccessValue()
321    {
322        $array        = new SampleArrayAccess();
323        $array['foo'] = 'bar';
324        $this->assertArrayHasKey('foo', $array);
325    }
326
327    /**
328     * @expectedException PHPUnit_Framework_AssertionFailedError
329     */
330    public function testAssertArrayHasKeyProperlyFailsWithArrayAccessValue()
331    {
332        $array        = new SampleArrayAccess();
333        $array['bar'] = 'bar';
334        $this->assertArrayHasKey('foo', $array);
335    }
336
337    public function testAssertArrayNotHasKeyAcceptsArrayAccessValue()
338    {
339        $array        = new ArrayObject();
340        $array['foo'] = 'bar';
341        $this->assertArrayNotHasKey('bar', $array);
342    }
343
344    /**
345     * @expectedException PHPUnit_Framework_AssertionFailedError
346     */
347    public function testAssertArrayNotHasKeyPropertlyFailsWithArrayAccessValue()
348    {
349        $array        = new ArrayObject();
350        $array['bar'] = 'bar';
351        $this->assertArrayNotHasKey('bar', $array);
352    }
353
354    /**
355     * @expectedException PHPUnit_Framework_Exception
356     */
357    public function testAssertContainsThrowsException()
358    {
359        $this->assertContains(null, null);
360    }
361
362    public function testAssertIteratorContainsObject()
363    {
364        $foo = new stdClass;
365
366        $this->assertContains($foo, new TestIterator([$foo]));
367
368        try {
369            $this->assertContains($foo, new TestIterator([new stdClass]));
370        } catch (PHPUnit_Framework_AssertionFailedError $e) {
371            return;
372        }
373
374        $this->fail();
375    }
376
377    public function testAssertIteratorContainsString()
378    {
379        $this->assertContains('foo', new TestIterator(['foo']));
380
381        try {
382            $this->assertContains('foo', new TestIterator(['bar']));
383        } catch (PHPUnit_Framework_AssertionFailedError $e) {
384            return;
385        }
386
387        $this->fail();
388    }
389
390    public function testAssertStringContainsString()
391    {
392        $this->assertContains('foo', 'foobar');
393
394        try {
395            $this->assertContains('foo', 'bar');
396        } catch (PHPUnit_Framework_AssertionFailedError $e) {
397            return;
398        }
399
400        $this->fail();
401    }
402
403    public function testAssertStringContainsStringForUtf8()
404    {
405        $this->assertContains('oryginał', 'oryginał');
406
407        try {
408            $this->assertContains('ORYGINAŁ', 'oryginał');
409        } catch (PHPUnit_Framework_AssertionFailedError $e) {
410            return;
411        }
412
413        $this->fail();
414    }
415
416    public function testAssertStringContainsStringForUtf8WhenIgnoreCase()
417    {
418        $this->assertContains('oryginał', 'oryginał', '', true);
419        $this->assertContains('ORYGINAŁ', 'oryginał', '', true);
420
421        try {
422            $this->assertContains('foo', 'oryginał', '', true);
423        } catch (PHPUnit_Framework_AssertionFailedError $e) {
424            return;
425        }
426
427        $this->fail();
428    }
429
430    /**
431     * @expectedException PHPUnit_Framework_Exception
432     */
433    public function testAssertNotContainsThrowsException()
434    {
435        $this->assertNotContains(null, null);
436    }
437
438    public function testAssertSplObjectStorageNotContainsObject()
439    {
440        $a = new stdClass;
441        $b = new stdClass;
442        $c = new SplObjectStorage;
443        $c->attach($a);
444
445        $this->assertNotContains($b, $c);
446
447        try {
448            $this->assertNotContains($a, $c);
449        } catch (PHPUnit_Framework_AssertionFailedError $e) {
450            return;
451        }
452
453        $this->fail();
454    }
455
456    public function testAssertArrayNotContainsObject()
457    {
458        $a = new stdClass;
459        $b = new stdClass;
460
461        $this->assertNotContains($a, [$b]);
462
463        try {
464            $this->assertNotContains($a, [$a]);
465        } catch (PHPUnit_Framework_AssertionFailedError $e) {
466            return;
467        }
468
469        $this->fail();
470    }
471
472    public function testAssertArrayNotContainsString()
473    {
474        $this->assertNotContains('foo', ['bar']);
475
476        try {
477            $this->assertNotContains('foo', ['foo']);
478        } catch (PHPUnit_Framework_AssertionFailedError $e) {
479            return;
480        }
481
482        $this->fail();
483    }
484
485    public function testAssertArrayNotContainsNonObject()
486    {
487        $this->assertNotContains('foo', [true], '', false, true, true);
488
489        try {
490            $this->assertNotContains('foo', [true]);
491        } catch (PHPUnit_Framework_AssertionFailedError $e) {
492            return;
493        }
494
495        $this->fail();
496    }
497
498    public function testAssertStringNotContainsString()
499    {
500        $this->assertNotContains('foo', 'bar');
501
502        try {
503            $this->assertNotContains('foo', 'foo');
504        } catch (PHPUnit_Framework_AssertionFailedError $e) {
505            return;
506        }
507
508        $this->fail();
509    }
510
511    public function testAssertStringNotContainsStringForUtf8()
512    {
513        $this->assertNotContains('ORYGINAŁ', 'oryginał');
514
515        try {
516            $this->assertNotContains('oryginał', 'oryginał');
517        } catch (PHPUnit_Framework_AssertionFailedError $e) {
518            return;
519        }
520
521        $this->fail();
522    }
523
524    public function testAssertStringNotContainsStringForUtf8WhenIgnoreCase()
525    {
526        try {
527            $this->assertNotContains('ORYGINAŁ', 'oryginał', '', true);
528        } catch (PHPUnit_Framework_AssertionFailedError $e) {
529            return;
530        }
531
532        $this->fail();
533    }
534
535    /**
536     * @expectedException PHPUnit_Framework_Exception
537     */
538    public function testAssertContainsOnlyThrowsException()
539    {
540        $this->assertContainsOnly(null, null);
541    }
542
543    /**
544     * @expectedException PHPUnit_Framework_Exception
545     */
546    public function testAssertNotContainsOnlyThrowsException()
547    {
548        $this->assertNotContainsOnly(null, null);
549    }
550
551    /**
552     * @expectedException PHPUnit_Framework_Exception
553     */
554    public function testAssertContainsOnlyInstancesOfThrowsException()
555    {
556        $this->assertContainsOnlyInstancesOf(null, null);
557    }
558
559    public function testAssertArrayContainsOnlyIntegers()
560    {
561        $this->assertContainsOnly('integer', [1, 2, 3]);
562
563        try {
564            $this->assertContainsOnly('integer', ['1', 2, 3]);
565        } catch (PHPUnit_Framework_AssertionFailedError $e) {
566            return;
567        }
568
569        $this->fail();
570    }
571
572    public function testAssertArrayNotContainsOnlyIntegers()
573    {
574        $this->assertNotContainsOnly('integer', ['1', 2, 3]);
575
576        try {
577            $this->assertNotContainsOnly('integer', [1, 2, 3]);
578        } catch (PHPUnit_Framework_AssertionFailedError $e) {
579            return;
580        }
581
582        $this->fail();
583    }
584
585    public function testAssertArrayContainsOnlyStdClass()
586    {
587        $this->assertContainsOnly('StdClass', [new stdClass]);
588
589        try {
590            $this->assertContainsOnly('StdClass', ['StdClass']);
591        } catch (PHPUnit_Framework_AssertionFailedError $e) {
592            return;
593        }
594
595        $this->fail();
596    }
597
598    public function testAssertArrayNotContainsOnlyStdClass()
599    {
600        $this->assertNotContainsOnly('StdClass', ['StdClass']);
601
602        try {
603            $this->assertNotContainsOnly('StdClass', [new stdClass]);
604        } catch (PHPUnit_Framework_AssertionFailedError $e) {
605            return;
606        }
607
608        $this->fail();
609    }
610
611    protected function sameValues()
612    {
613        $object = new SampleClass(4, 8, 15);
614        // cannot use $filesDirectory, because neither setUp() nor
615        // setUpBeforeClass() are executed before the data providers
616        $file     = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml';
617        $resource = fopen($file, 'r');
618
619        return [
620            // null
621            [null, null],
622            // strings
623            ['a', 'a'],
624            // integers
625            [0, 0],
626            // floats
627            [2.3, 2.3],
628            [1 / 3, 1 - 2 / 3],
629            [log(0), log(0)],
630            // arrays
631            [[], []],
632            [[0 => 1], [0 => 1]],
633            [[0 => null], [0 => null]],
634            [['a', 'b' => [1, 2]], ['a', 'b' => [1, 2]]],
635            // objects
636            [$object, $object],
637            // resources
638            [$resource, $resource],
639        ];
640    }
641
642    protected function notEqualValues()
643    {
644        // cyclic dependencies
645        $book1                  = new Book;
646        $book1->author          = new Author('Terry Pratchett');
647        $book1->author->books[] = $book1;
648        $book2                  = new Book;
649        $book2->author          = new Author('Terry Pratch');
650        $book2->author->books[] = $book2;
651
652        $book3         = new Book;
653        $book3->author = 'Terry Pratchett';
654        $book4         = new stdClass;
655        $book4->author = 'Terry Pratchett';
656
657        $object1  = new SampleClass(4, 8, 15);
658        $object2  = new SampleClass(16, 23, 42);
659        $object3  = new SampleClass(4, 8, 15);
660        $storage1 = new SplObjectStorage;
661        $storage1->attach($object1);
662        $storage2 = new SplObjectStorage;
663        $storage2->attach($object3); // same content, different object
664
665        // cannot use $filesDirectory, because neither setUp() nor
666        // setUpBeforeClass() are executed before the data providers
667        $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml';
668
669        return [
670            // strings
671            ['a', 'b'],
672            ['a', 'A'],
673            // https://github.com/sebastianbergmann/phpunit/issues/1023
674            ['9E6666666','9E7777777'],
675            // integers
676            [1, 2],
677            [2, 1],
678            // floats
679            [2.3, 4.2],
680            [2.3, 4.2, 0.5],
681            [[2.3], [4.2], 0.5],
682            [[[2.3]], [[4.2]], 0.5],
683            [new Struct(2.3), new Struct(4.2), 0.5],
684            [[new Struct(2.3)], [new Struct(4.2)], 0.5],
685            // NAN
686            [NAN, NAN],
687            // arrays
688            [[], [0 => 1]],
689            [[0     => 1], []],
690            [[0     => null], []],
691            [[0     => 1, 1 => 2], [0     => 1, 1 => 3]],
692            [['a', 'b' => [1, 2]], ['a', 'b' => [2, 1]]],
693            // objects
694            [new SampleClass(4, 8, 15), new SampleClass(16, 23, 42)],
695            [$object1, $object2],
696            [$book1, $book2],
697            [$book3, $book4], // same content, different class
698            // resources
699            [fopen($file, 'r'), fopen($file, 'r')],
700            // SplObjectStorage
701            [$storage1, $storage2],
702            // DOMDocument
703            [
704                PHPUnit_Util_XML::load('<root></root>'),
705                PHPUnit_Util_XML::load('<bar/>'),
706            ],
707            [
708                PHPUnit_Util_XML::load('<foo attr1="bar"/>'),
709                PHPUnit_Util_XML::load('<foo attr1="foobar"/>'),
710            ],
711            [
712                PHPUnit_Util_XML::load('<foo> bar </foo>'),
713                PHPUnit_Util_XML::load('<foo />'),
714            ],
715            [
716                PHPUnit_Util_XML::load('<foo xmlns="urn:myns:bar"/>'),
717                PHPUnit_Util_XML::load('<foo xmlns="urn:notmyns:bar"/>'),
718            ],
719            [
720                PHPUnit_Util_XML::load('<foo> bar </foo>'),
721                PHPUnit_Util_XML::load('<foo> bir </foo>'),
722            ],
723            [
724                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
725                new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')),
726            ],
727            [
728                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
729                new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')),
730                3500
731            ],
732            [
733                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
734                new DateTime('2013-03-29 05:13:35', new DateTimeZone('America/New_York')),
735                3500
736            ],
737            [
738                new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
739                new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
740            ],
741            [
742                new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
743                new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
744                43200
745            ],
746            [
747                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
748                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')),
749            ],
750            [
751                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
752                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')),
753                3500
754            ],
755            [
756                new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
757                new DateTime('2013-03-30', new DateTimeZone('America/Chicago')),
758            ],
759            [
760                new DateTime('2013-03-29T05:13:35-0600'),
761                new DateTime('2013-03-29T04:13:35-0600'),
762            ],
763            [
764                new DateTime('2013-03-29T05:13:35-0600'),
765                new DateTime('2013-03-29T05:13:35-0500'),
766            ],
767            // Exception
768            //array(new Exception('Exception 1'), new Exception('Exception 2')),
769            // different types
770            [new SampleClass(4, 8, 15), false],
771            [false, new SampleClass(4, 8, 15)],
772            [[0        => 1, 1 => 2], false],
773            [false, [0 => 1, 1 => 2]],
774            [[], new stdClass],
775            [new stdClass, []],
776            // PHP: 0 == 'Foobar' => true!
777            // We want these values to differ
778            [0, 'Foobar'],
779            ['Foobar', 0],
780            [3, acos(8)],
781            [acos(8), 3]
782        ];
783    }
784
785    protected function equalValues()
786    {
787        // cyclic dependencies
788        $book1                  = new Book;
789        $book1->author          = new Author('Terry Pratchett');
790        $book1->author->books[] = $book1;
791        $book2                  = new Book;
792        $book2->author          = new Author('Terry Pratchett');
793        $book2->author->books[] = $book2;
794
795        $object1  = new SampleClass(4, 8, 15);
796        $object2  = new SampleClass(4, 8, 15);
797        $storage1 = new SplObjectStorage;
798        $storage1->attach($object1);
799        $storage2 = new SplObjectStorage;
800        $storage2->attach($object1);
801
802        return [
803            // strings
804            ['a', 'A', 0, false, true], // ignore case
805            // arrays
806            [['a' => 1, 'b' => 2], ['b' => 2, 'a' => 1]],
807            [[1], ['1']],
808            [[3, 2, 1], [2, 3, 1], 0, true], // canonicalized comparison
809            // floats
810            [2.3, 2.5, 0.5],
811            [[2.3], [2.5], 0.5],
812            [[[2.3]], [[2.5]], 0.5],
813            [new Struct(2.3), new Struct(2.5), 0.5],
814            [[new Struct(2.3)], [new Struct(2.5)], 0.5],
815            // numeric with delta
816            [1, 2, 1],
817            // objects
818            [$object1, $object2],
819            [$book1, $book2],
820            // SplObjectStorage
821            [$storage1, $storage2],
822            // DOMDocument
823            [
824                PHPUnit_Util_XML::load('<root></root>'),
825                PHPUnit_Util_XML::load('<root/>'),
826            ],
827            [
828                PHPUnit_Util_XML::load('<root attr="bar"></root>'),
829                PHPUnit_Util_XML::load('<root attr="bar"/>'),
830            ],
831            [
832                PHPUnit_Util_XML::load('<root><foo attr="bar"></foo></root>'),
833                PHPUnit_Util_XML::load('<root><foo attr="bar"/></root>'),
834            ],
835            [
836                PHPUnit_Util_XML::load("<root>\n  <child/>\n</root>"),
837                PHPUnit_Util_XML::load('<root><child/></root>'),
838            ],
839            [
840                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
841                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
842            ],
843            [
844                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
845                new DateTime('2013-03-29 04:13:25', new DateTimeZone('America/New_York')),
846                10
847            ],
848            [
849                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
850                new DateTime('2013-03-29 04:14:40', new DateTimeZone('America/New_York')),
851                65
852            ],
853            [
854                new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
855                new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
856            ],
857            [
858                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
859                new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/Chicago')),
860            ],
861            [
862                new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
863                new DateTime('2013-03-29 03:13:49', new DateTimeZone('America/Chicago')),
864                15
865            ],
866            [
867                new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
868                new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')),
869            ],
870            [
871                new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
872                new DateTime('2013-03-29 23:01:30', new DateTimeZone('America/Chicago')),
873                100
874            ],
875            [
876                new DateTime('@1364616000'),
877                new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')),
878            ],
879            [
880                new DateTime('2013-03-29T05:13:35-0500'),
881                new DateTime('2013-03-29T04:13:35-0600'),
882            ],
883            // Exception
884            //array(new Exception('Exception 1'), new Exception('Exception 1')),
885            // mixed types
886            [0, '0'],
887            ['0', 0],
888            [2.3, '2.3'],
889            ['2.3', 2.3],
890            [(string) (1 / 3), 1 - 2 / 3],
891            [1 / 3, (string) (1 - 2 / 3)],
892            ['string representation', new ClassWithToString],
893            [new ClassWithToString, 'string representation'],
894        ];
895    }
896
897    public function equalProvider()
898    {
899        // same |= equal
900        return array_merge($this->equalValues(), $this->sameValues());
901    }
902
903    public function notEqualProvider()
904    {
905        return $this->notEqualValues();
906    }
907
908    public function sameProvider()
909    {
910        return $this->sameValues();
911    }
912
913    public function notSameProvider()
914    {
915        // not equal |= not same
916        // equal, ¬same |= not same
917        return array_merge($this->notEqualValues(), $this->equalValues());
918    }
919
920    /**
921     * @dataProvider equalProvider
922     */
923    public function testAssertEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
924    {
925        $this->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
926    }
927
928    /**
929     * @dataProvider notEqualProvider
930     */
931    public function testAssertEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
932    {
933        try {
934            $this->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
935        } catch (PHPUnit_Framework_AssertionFailedError $e) {
936            return;
937        }
938
939        $this->fail();
940    }
941
942    /**
943     * @dataProvider notEqualProvider
944     */
945    public function testAssertNotEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
946    {
947        $this->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
948    }
949
950    /**
951     * @dataProvider equalProvider
952     */
953    public function testAssertNotEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
954    {
955        try {
956            $this->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
957        } catch (PHPUnit_Framework_AssertionFailedError $e) {
958            return;
959        }
960
961        $this->fail();
962    }
963
964    /**
965     * @dataProvider sameProvider
966     */
967    public function testAssertSameSucceeds($a, $b)
968    {
969        $this->assertSame($a, $b);
970    }
971
972    /**
973     * @dataProvider notSameProvider
974     */
975    public function testAssertSameFails($a, $b)
976    {
977        try {
978            $this->assertSame($a, $b);
979        } catch (PHPUnit_Framework_AssertionFailedError $e) {
980            return;
981        }
982
983        $this->fail();
984    }
985
986    /**
987     * @dataProvider notSameProvider
988     */
989    public function testAssertNotSameSucceeds($a, $b)
990    {
991        $this->assertNotSame($a, $b);
992    }
993
994    /**
995     * @dataProvider sameProvider
996     */
997    public function testAssertNotSameFails($a, $b)
998    {
999        try {
1000            $this->assertNotSame($a, $b);
1001        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1002            return;
1003        }
1004
1005        $this->fail();
1006    }
1007
1008    public function testAssertXmlFileEqualsXmlFile()
1009    {
1010        $this->assertXmlFileEqualsXmlFile(
1011            $this->filesDirectory . 'foo.xml',
1012            $this->filesDirectory . 'foo.xml'
1013        );
1014
1015        try {
1016            $this->assertXmlFileEqualsXmlFile(
1017                $this->filesDirectory . 'foo.xml',
1018                $this->filesDirectory . 'bar.xml'
1019            );
1020        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1021            return;
1022        }
1023
1024        $this->fail();
1025    }
1026
1027    public function testAssertXmlFileNotEqualsXmlFile()
1028    {
1029        $this->assertXmlFileNotEqualsXmlFile(
1030            $this->filesDirectory . 'foo.xml',
1031            $this->filesDirectory . 'bar.xml'
1032        );
1033
1034        try {
1035            $this->assertXmlFileNotEqualsXmlFile(
1036                $this->filesDirectory . 'foo.xml',
1037                $this->filesDirectory . 'foo.xml'
1038            );
1039        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1040            return;
1041        }
1042
1043        $this->fail();
1044    }
1045
1046    public function testAssertXmlStringEqualsXmlFile()
1047    {
1048        $this->assertXmlStringEqualsXmlFile(
1049            $this->filesDirectory . 'foo.xml',
1050            file_get_contents($this->filesDirectory . 'foo.xml')
1051        );
1052
1053        try {
1054            $this->assertXmlStringEqualsXmlFile(
1055                $this->filesDirectory . 'foo.xml',
1056                file_get_contents($this->filesDirectory . 'bar.xml')
1057            );
1058        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1059            return;
1060        }
1061
1062        $this->fail();
1063    }
1064
1065    public function testXmlStringNotEqualsXmlFile()
1066    {
1067        $this->assertXmlStringNotEqualsXmlFile(
1068            $this->filesDirectory . 'foo.xml',
1069            file_get_contents($this->filesDirectory . 'bar.xml')
1070        );
1071
1072        try {
1073            $this->assertXmlStringNotEqualsXmlFile(
1074                $this->filesDirectory . 'foo.xml',
1075                file_get_contents($this->filesDirectory . 'foo.xml')
1076            );
1077        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1078            return;
1079        }
1080
1081        $this->fail();
1082    }
1083
1084    public function testAssertXmlStringEqualsXmlString()
1085    {
1086        $this->assertXmlStringEqualsXmlString('<root/>', '<root/>');
1087
1088        try {
1089            $this->assertXmlStringEqualsXmlString('<foo/>', '<bar/>');
1090        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1091            return;
1092        }
1093
1094        $this->fail();
1095    }
1096
1097    /**
1098     * @expectedException PHPUnit_Framework_Exception
1099     * @ticket            1860
1100     */
1101    public function testAssertXmlStringEqualsXmlString2()
1102    {
1103        $this->assertXmlStringEqualsXmlString('<a></b>', '<c></d>');
1104    }
1105
1106    /**
1107     * @ticket 1860
1108     */
1109    public function testAssertXmlStringEqualsXmlString3()
1110    {
1111        $expected = <<<XML
1112<?xml version="1.0"?>
1113<root>
1114    <node />
1115</root>
1116XML;
1117
1118        $actual = <<<XML
1119<?xml version="1.0"?>
1120<root>
1121<node />
1122</root>
1123XML;
1124
1125        $this->assertXmlStringEqualsXmlString($expected, $actual);
1126    }
1127
1128    public function testAssertXmlStringNotEqualsXmlString()
1129    {
1130        $this->assertXmlStringNotEqualsXmlString('<foo/>', '<bar/>');
1131
1132        try {
1133            $this->assertXmlStringNotEqualsXmlString('<root/>', '<root/>');
1134        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1135            return;
1136        }
1137
1138        $this->fail();
1139    }
1140
1141    public function testXMLStructureIsSame()
1142    {
1143        $expected = new DOMDocument;
1144        $expected->load($this->filesDirectory . 'structureExpected.xml');
1145
1146        $actual = new DOMDocument;
1147        $actual->load($this->filesDirectory . 'structureExpected.xml');
1148
1149        $this->assertEqualXMLStructure(
1150            $expected->firstChild, $actual->firstChild, true
1151        );
1152    }
1153
1154    /**
1155     * @expectedException PHPUnit_Framework_ExpectationFailedException
1156     */
1157    public function testXMLStructureWrongNumberOfAttributes()
1158    {
1159        $expected = new DOMDocument;
1160        $expected->load($this->filesDirectory . 'structureExpected.xml');
1161
1162        $actual = new DOMDocument;
1163        $actual->load($this->filesDirectory . 'structureWrongNumberOfAttributes.xml');
1164
1165        $this->assertEqualXMLStructure(
1166            $expected->firstChild, $actual->firstChild, true
1167        );
1168    }
1169
1170    /**
1171     * @expectedException PHPUnit_Framework_ExpectationFailedException
1172     */
1173    public function testXMLStructureWrongNumberOfNodes()
1174    {
1175        $expected = new DOMDocument;
1176        $expected->load($this->filesDirectory . 'structureExpected.xml');
1177
1178        $actual = new DOMDocument;
1179        $actual->load($this->filesDirectory . 'structureWrongNumberOfNodes.xml');
1180
1181        $this->assertEqualXMLStructure(
1182            $expected->firstChild, $actual->firstChild, true
1183        );
1184    }
1185
1186    public function testXMLStructureIsSameButDataIsNot()
1187    {
1188        $expected = new DOMDocument;
1189        $expected->load($this->filesDirectory . 'structureExpected.xml');
1190
1191        $actual = new DOMDocument;
1192        $actual->load($this->filesDirectory . 'structureIsSameButDataIsNot.xml');
1193
1194        $this->assertEqualXMLStructure(
1195            $expected->firstChild, $actual->firstChild, true
1196        );
1197    }
1198
1199    public function testXMLStructureAttributesAreSameButValuesAreNot()
1200    {
1201        $expected = new DOMDocument;
1202        $expected->load($this->filesDirectory . 'structureExpected.xml');
1203
1204        $actual = new DOMDocument;
1205        $actual->load($this->filesDirectory . 'structureAttributesAreSameButValuesAreNot.xml');
1206
1207        $this->assertEqualXMLStructure(
1208            $expected->firstChild, $actual->firstChild, true
1209        );
1210    }
1211
1212    public function testXMLStructureIgnoreTextNodes()
1213    {
1214        $expected = new DOMDocument;
1215        $expected->load($this->filesDirectory . 'structureExpected.xml');
1216
1217        $actual = new DOMDocument;
1218        $actual->load($this->filesDirectory . 'structureIgnoreTextNodes.xml');
1219
1220        $this->assertEqualXMLStructure(
1221            $expected->firstChild, $actual->firstChild, true
1222        );
1223    }
1224
1225    public function testAssertStringEqualsNumeric()
1226    {
1227        $this->assertEquals('0', 0);
1228
1229        try {
1230            $this->assertEquals('0', 1);
1231        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1232            return;
1233        }
1234
1235        $this->fail();
1236    }
1237
1238    public function testAssertStringEqualsNumeric2()
1239    {
1240        $this->assertNotEquals('A', 0);
1241    }
1242
1243    /**
1244     * @expectedException PHPUnit_Framework_Exception
1245     */
1246    public function testAssertIsReadableThrowsException()
1247    {
1248        $this->assertIsReadable(null);
1249    }
1250
1251    public function testAssertIsReadable()
1252    {
1253        $this->assertIsReadable(__FILE__);
1254
1255        try {
1256            $this->assertIsReadable(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1257        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1258            return;
1259        }
1260
1261        $this->fail();
1262    }
1263
1264    /**
1265     * @expectedException PHPUnit_Framework_Exception
1266     */
1267    public function testAssertNotIsReadableThrowsException()
1268    {
1269        $this->assertNotIsReadable(null);
1270    }
1271
1272    public function testAssertNotIsReadable()
1273    {
1274        try {
1275            $this->assertNotIsReadable(__FILE__);
1276        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1277            return;
1278        }
1279
1280        $this->fail();
1281    }
1282
1283    /**
1284     * @expectedException PHPUnit_Framework_Exception
1285     */
1286    public function testAssertIsWritableThrowsException()
1287    {
1288        $this->assertIsWritable(null);
1289    }
1290
1291    public function testAssertIsWritable()
1292    {
1293        $this->assertIsWritable(__FILE__);
1294
1295        try {
1296            $this->assertIsWritable(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1297        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1298            return;
1299        }
1300
1301        $this->fail();
1302    }
1303
1304    /**
1305     * @expectedException PHPUnit_Framework_Exception
1306     */
1307    public function testAssertNotIsWritableThrowsException()
1308    {
1309        $this->assertNotIsWritable(null);
1310    }
1311
1312    public function testAssertNotIsWritable()
1313    {
1314        try {
1315            $this->assertNotIsWritable(__FILE__);
1316        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1317            return;
1318        }
1319
1320        $this->fail();
1321    }
1322
1323    /**
1324     * @expectedException PHPUnit_Framework_Exception
1325     */
1326    public function testAssertDirectoryExistsThrowsException()
1327    {
1328        $this->assertDirectoryExists(null);
1329    }
1330
1331    public function testAssertDirectoryExists()
1332    {
1333        $this->assertDirectoryExists(__DIR__);
1334
1335        try {
1336            $this->assertDirectoryExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1337        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1338            return;
1339        }
1340
1341        $this->fail();
1342    }
1343
1344    /**
1345     * @expectedException PHPUnit_Framework_Exception
1346     */
1347    public function testAssertDirectoryNotExistsThrowsException()
1348    {
1349        $this->assertDirectoryNotExists(null);
1350    }
1351
1352    public function testAssertDirectoryNotExists()
1353    {
1354        $this->assertDirectoryNotExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1355
1356        try {
1357            $this->assertDirectoryNotExists(__DIR__);
1358        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1359            return;
1360        }
1361
1362        $this->fail();
1363    }
1364
1365    /**
1366     * @expectedException PHPUnit_Framework_Exception
1367     */
1368    public function testAssertDirectoryIsReadableThrowsException()
1369    {
1370        $this->assertDirectoryIsReadable(null);
1371    }
1372
1373    public function testAssertDirectoryIsReadable()
1374    {
1375        $this->assertDirectoryIsReadable(__DIR__);
1376
1377        try {
1378            $this->assertDirectoryIsReadable(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1379        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1380            return;
1381        }
1382
1383        $this->fail();
1384    }
1385
1386    /**
1387     * @expectedException PHPUnit_Framework_Exception
1388     */
1389    public function testAssertDirectoryNotIsReadableThrowsException()
1390    {
1391        $this->assertDirectoryNotIsReadable(null);
1392    }
1393
1394    /**
1395     * @expectedException PHPUnit_Framework_Exception
1396     */
1397    public function testAssertDirectoryIsWritableThrowsException()
1398    {
1399        $this->assertDirectoryIsWritable(null);
1400    }
1401
1402    public function testAssertDirectoryIsWritable()
1403    {
1404        $this->assertDirectoryIsWritable(__DIR__);
1405
1406        try {
1407            $this->assertDirectoryIsWritable(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1408        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1409            return;
1410        }
1411
1412        $this->fail();
1413    }
1414
1415    /**
1416     * @expectedException PHPUnit_Framework_Exception
1417     */
1418    public function testAssertDirectoryNotIsWritableThrowsException()
1419    {
1420        $this->assertDirectoryNotIsWritable(null);
1421    }
1422
1423    /**
1424     * @expectedException PHPUnit_Framework_Exception
1425     */
1426    public function testAssertFileExistsThrowsException()
1427    {
1428        $this->assertFileExists(null);
1429    }
1430
1431    public function testAssertFileExists()
1432    {
1433        $this->assertFileExists(__FILE__);
1434
1435        try {
1436            $this->assertFileExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1437        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1438            return;
1439        }
1440
1441        $this->fail();
1442    }
1443
1444    /**
1445     * @expectedException PHPUnit_Framework_Exception
1446     */
1447    public function testAssertFileNotExistsThrowsException()
1448    {
1449        $this->assertFileNotExists(null);
1450    }
1451
1452    public function testAssertFileNotExists()
1453    {
1454        $this->assertFileNotExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1455
1456        try {
1457            $this->assertFileNotExists(__FILE__);
1458        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1459            return;
1460        }
1461
1462        $this->fail();
1463    }
1464
1465    /**
1466     * @expectedException PHPUnit_Framework_Exception
1467     */
1468    public function testAssertFileIsReadableThrowsException()
1469    {
1470        $this->assertFileIsReadable(null);
1471    }
1472
1473    public function testAssertFileIsReadable()
1474    {
1475        $this->assertFileIsReadable(__FILE__);
1476
1477        try {
1478            $this->assertFileIsReadable(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1479        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1480            return;
1481        }
1482
1483        $this->fail();
1484    }
1485
1486    /**
1487     * @expectedException PHPUnit_Framework_Exception
1488     */
1489    public function testAssertFileNotIsReadableThrowsException()
1490    {
1491        $this->assertFileNotIsReadable(null);
1492    }
1493
1494    /**
1495     * @expectedException PHPUnit_Framework_Exception
1496     */
1497    public function testAssertFileIsWritableThrowsException()
1498    {
1499        $this->assertFileIsWritable(null);
1500    }
1501
1502    public function testAssertFileIsWritable()
1503    {
1504        $this->assertFileIsWritable(__FILE__);
1505
1506        try {
1507            $this->assertFileIsWritable(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1508        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1509            return;
1510        }
1511
1512        $this->fail();
1513    }
1514
1515    /**
1516     * @expectedException PHPUnit_Framework_Exception
1517     */
1518    public function testAssertFileNotIsWritableThrowsException()
1519    {
1520        $this->assertFileNotIsWritable(null);
1521    }
1522
1523    public function testAssertObjectHasAttribute()
1524    {
1525        $o = new Author('Terry Pratchett');
1526
1527        $this->assertObjectHasAttribute('name', $o);
1528
1529        try {
1530            $this->assertObjectHasAttribute('foo', $o);
1531        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1532            return;
1533        }
1534
1535        $this->fail();
1536    }
1537
1538    public function testAssertObjectNotHasAttribute()
1539    {
1540        $o = new Author('Terry Pratchett');
1541
1542        $this->assertObjectNotHasAttribute('foo', $o);
1543
1544        try {
1545            $this->assertObjectNotHasAttribute('name', $o);
1546        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1547            return;
1548        }
1549
1550        $this->fail();
1551    }
1552
1553    public function testAssertFinite()
1554    {
1555        $this->assertFinite(1);
1556
1557        try {
1558            $this->assertFinite(INF);
1559        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1560            return;
1561        }
1562
1563        $this->fail();
1564    }
1565
1566    public function testAssertInfinite()
1567    {
1568        $this->assertInfinite(INF);
1569
1570        try {
1571            $this->assertInfinite(1);
1572        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1573            return;
1574        }
1575
1576        $this->fail();
1577    }
1578
1579    public function testAssertNan()
1580    {
1581        $this->assertNan(NAN);
1582
1583        try {
1584            $this->assertNan(1);
1585        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1586            return;
1587        }
1588
1589        $this->fail();
1590    }
1591
1592    public function testAssertNull()
1593    {
1594        $this->assertNull(null);
1595
1596        try {
1597            $this->assertNull(new stdClass);
1598        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1599            return;
1600        }
1601
1602        $this->fail();
1603    }
1604
1605    public function testAssertNotNull()
1606    {
1607        $this->assertNotNull(new stdClass);
1608
1609        try {
1610            $this->assertNotNull(null);
1611        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1612            return;
1613        }
1614
1615        $this->fail();
1616    }
1617
1618    public function testAssertTrue()
1619    {
1620        $this->assertTrue(true);
1621
1622        try {
1623            $this->assertTrue(false);
1624        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1625            return;
1626        }
1627
1628        $this->fail();
1629    }
1630
1631    public function testAssertNotTrue()
1632    {
1633        $this->assertNotTrue(false);
1634        $this->assertNotTrue(1);
1635        $this->assertNotTrue('true');
1636
1637        try {
1638            $this->assertNotTrue(true);
1639        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1640            return;
1641        }
1642
1643        $this->fail();
1644    }
1645
1646    public function testAssertFalse()
1647    {
1648        $this->assertFalse(false);
1649
1650        try {
1651            $this->assertFalse(true);
1652        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1653            return;
1654        }
1655
1656        $this->fail();
1657    }
1658
1659    public function testAssertNotFalse()
1660    {
1661        $this->assertNotFalse(true);
1662        $this->assertNotFalse(0);
1663        $this->assertNotFalse('');
1664
1665        try {
1666            $this->assertNotFalse(false);
1667        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1668            return;
1669        }
1670
1671        $this->fail();
1672    }
1673
1674    /**
1675     * @expectedException PHPUnit_Framework_Exception
1676     */
1677    public function testAssertRegExpThrowsException()
1678    {
1679        $this->assertRegExp(null, null);
1680    }
1681
1682    /**
1683     * @expectedException PHPUnit_Framework_Exception
1684     */
1685    public function testAssertRegExpThrowsException2()
1686    {
1687        $this->assertRegExp('', null);
1688    }
1689
1690    /**
1691     * @expectedException PHPUnit_Framework_Exception
1692     */
1693    public function testAssertNotRegExpThrowsException()
1694    {
1695        $this->assertNotRegExp(null, null);
1696    }
1697
1698    /**
1699     * @expectedException PHPUnit_Framework_Exception
1700     */
1701    public function testAssertNotRegExpThrowsException2()
1702    {
1703        $this->assertNotRegExp('', null);
1704    }
1705
1706    public function testAssertRegExp()
1707    {
1708        $this->assertRegExp('/foo/', 'foobar');
1709
1710        try {
1711            $this->assertRegExp('/foo/', 'bar');
1712        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1713            return;
1714        }
1715
1716        $this->fail();
1717    }
1718
1719    public function testAssertNotRegExp()
1720    {
1721        $this->assertNotRegExp('/foo/', 'bar');
1722
1723        try {
1724            $this->assertNotRegExp('/foo/', 'foobar');
1725        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1726            return;
1727        }
1728
1729        $this->fail();
1730    }
1731
1732    public function testAssertSame()
1733    {
1734        $o = new stdClass;
1735
1736        $this->assertSame($o, $o);
1737
1738        try {
1739            $this->assertSame(
1740                new stdClass,
1741                new stdClass
1742            );
1743        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1744            return;
1745        }
1746
1747        $this->fail();
1748    }
1749
1750    public function testAssertSame2()
1751    {
1752        $this->assertSame(true, true);
1753        $this->assertSame(false, false);
1754
1755        try {
1756            $this->assertSame(true, false);
1757        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1758            return;
1759        }
1760
1761        $this->fail();
1762    }
1763
1764    public function testAssertNotSame()
1765    {
1766        $this->assertNotSame(
1767            new stdClass,
1768            null
1769        );
1770
1771        $this->assertNotSame(
1772            null,
1773            new stdClass
1774        );
1775
1776        $this->assertNotSame(
1777            new stdClass,
1778            new stdClass
1779        );
1780
1781        $o = new stdClass;
1782
1783        try {
1784            $this->assertNotSame($o, $o);
1785        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1786            return;
1787        }
1788
1789        $this->fail();
1790    }
1791
1792    public function testAssertNotSame2()
1793    {
1794        $this->assertNotSame(true, false);
1795        $this->assertNotSame(false, true);
1796
1797        try {
1798            $this->assertNotSame(true, true);
1799        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1800            return;
1801        }
1802
1803        $this->fail();
1804    }
1805
1806    public function testAssertNotSameFailsNull()
1807    {
1808        try {
1809            $this->assertNotSame(null, null);
1810        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1811            return;
1812        }
1813
1814        $this->fail();
1815    }
1816
1817    public function testGreaterThan()
1818    {
1819        $this->assertGreaterThan(1, 2);
1820
1821        try {
1822            $this->assertGreaterThan(2, 1);
1823        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1824            return;
1825        }
1826
1827        $this->fail();
1828    }
1829
1830    public function testAttributeGreaterThan()
1831    {
1832        $this->assertAttributeGreaterThan(
1833            1, 'bar', new ClassWithNonPublicAttributes
1834        );
1835
1836        try {
1837            $this->assertAttributeGreaterThan(
1838                1, 'foo', new ClassWithNonPublicAttributes
1839            );
1840        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1841            return;
1842        }
1843
1844        $this->fail();
1845    }
1846
1847    public function testGreaterThanOrEqual()
1848    {
1849        $this->assertGreaterThanOrEqual(1, 2);
1850
1851        try {
1852            $this->assertGreaterThanOrEqual(2, 1);
1853        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1854            return;
1855        }
1856
1857        $this->fail();
1858    }
1859
1860    public function testAttributeGreaterThanOrEqual()
1861    {
1862        $this->assertAttributeGreaterThanOrEqual(
1863            1, 'bar', new ClassWithNonPublicAttributes
1864        );
1865
1866        try {
1867            $this->assertAttributeGreaterThanOrEqual(
1868                2, 'foo', new ClassWithNonPublicAttributes
1869            );
1870        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1871            return;
1872        }
1873
1874        $this->fail();
1875    }
1876
1877    public function testLessThan()
1878    {
1879        $this->assertLessThan(2, 1);
1880
1881        try {
1882            $this->assertLessThan(1, 2);
1883        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1884            return;
1885        }
1886
1887        $this->fail();
1888    }
1889
1890    public function testAttributeLessThan()
1891    {
1892        $this->assertAttributeLessThan(
1893            2, 'foo', new ClassWithNonPublicAttributes
1894        );
1895
1896        try {
1897            $this->assertAttributeLessThan(
1898                1, 'bar', new ClassWithNonPublicAttributes
1899            );
1900        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1901            return;
1902        }
1903
1904        $this->fail();
1905    }
1906
1907    public function testLessThanOrEqual()
1908    {
1909        $this->assertLessThanOrEqual(2, 1);
1910
1911        try {
1912            $this->assertLessThanOrEqual(1, 2);
1913        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1914            return;
1915        }
1916
1917        $this->fail();
1918    }
1919
1920    public function testAttributeLessThanOrEqual()
1921    {
1922        $this->assertAttributeLessThanOrEqual(
1923            2, 'foo', new ClassWithNonPublicAttributes
1924        );
1925
1926        try {
1927            $this->assertAttributeLessThanOrEqual(
1928                1, 'bar', new ClassWithNonPublicAttributes
1929            );
1930        } catch (PHPUnit_Framework_AssertionFailedError $e) {
1931            return;
1932        }
1933
1934        $this->fail();
1935    }
1936
1937    public function testReadAttribute()
1938    {
1939        $obj = new ClassWithNonPublicAttributes;
1940
1941        $this->assertEquals('foo', $this->readAttribute($obj, 'publicAttribute'));
1942        $this->assertEquals('bar', $this->readAttribute($obj, 'protectedAttribute'));
1943        $this->assertEquals('baz', $this->readAttribute($obj, 'privateAttribute'));
1944        $this->assertEquals('bar', $this->readAttribute($obj, 'protectedParentAttribute'));
1945        //$this->assertEquals('bar', $this->readAttribute($obj, 'privateParentAttribute'));
1946    }
1947
1948    public function testReadAttribute2()
1949    {
1950        $this->assertEquals('foo', $this->readAttribute('ClassWithNonPublicAttributes', 'publicStaticAttribute'));
1951        $this->assertEquals('bar', $this->readAttribute('ClassWithNonPublicAttributes', 'protectedStaticAttribute'));
1952        $this->assertEquals('baz', $this->readAttribute('ClassWithNonPublicAttributes', 'privateStaticAttribute'));
1953        $this->assertEquals('foo', $this->readAttribute('ClassWithNonPublicAttributes', 'protectedStaticParentAttribute'));
1954        $this->assertEquals('foo', $this->readAttribute('ClassWithNonPublicAttributes', 'privateStaticParentAttribute'));
1955    }
1956
1957    /**
1958     * @expectedException PHPUnit_Framework_Exception
1959     */
1960    public function testReadAttribute3()
1961    {
1962        $this->readAttribute('StdClass', null);
1963    }
1964
1965    /**
1966     * @expectedException PHPUnit_Framework_Exception
1967     */
1968    public function testReadAttribute4()
1969    {
1970        $this->readAttribute('NotExistingClass', 'foo');
1971    }
1972
1973    /**
1974     * @expectedException PHPUnit_Framework_Exception
1975     */
1976    public function testReadAttribute5()
1977    {
1978        $this->readAttribute(null, 'foo');
1979    }
1980
1981    /**
1982     * @expectedException PHPUnit_Framework_Exception
1983     */
1984    public function testReadAttributeIfAttributeNameIsNotValid()
1985    {
1986        $this->readAttribute('StdClass', '2');
1987    }
1988
1989    /**
1990     * @expectedException PHPUnit_Framework_Exception
1991     */
1992    public function testGetStaticAttributeRaisesExceptionForInvalidFirstArgument()
1993    {
1994        $this->getStaticAttribute(null, 'foo');
1995    }
1996
1997    /**
1998     * @expectedException PHPUnit_Framework_Exception
1999     */
2000    public function testGetStaticAttributeRaisesExceptionForInvalidFirstArgument2()
2001    {
2002        $this->getStaticAttribute('NotExistingClass', 'foo');
2003    }
2004
2005    /**
2006     * @expectedException PHPUnit_Framework_Exception
2007     */
2008    public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument()
2009    {
2010        $this->getStaticAttribute('stdClass', null);
2011    }
2012
2013    /**
2014     * @expectedException PHPUnit_Framework_Exception
2015     */
2016    public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument2()
2017    {
2018        $this->getStaticAttribute('stdClass', '0');
2019    }
2020
2021    /**
2022     * @expectedException PHPUnit_Framework_Exception
2023     */
2024    public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument3()
2025    {
2026        $this->getStaticAttribute('stdClass', 'foo');
2027    }
2028
2029    /**
2030     * @expectedException PHPUnit_Framework_Exception
2031     */
2032    public function testGetObjectAttributeRaisesExceptionForInvalidFirstArgument()
2033    {
2034        $this->getObjectAttribute(null, 'foo');
2035    }
2036
2037    /**
2038     * @expectedException PHPUnit_Framework_Exception
2039     */
2040    public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument()
2041    {
2042        $this->getObjectAttribute(new stdClass, null);
2043    }
2044
2045    /**
2046     * @expectedException PHPUnit_Framework_Exception
2047     */
2048    public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument2()
2049    {
2050        $this->getObjectAttribute(new stdClass, '0');
2051    }
2052
2053    /**
2054     * @expectedException PHPUnit_Framework_Exception
2055     */
2056    public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument3()
2057    {
2058        $this->getObjectAttribute(new stdClass, 'foo');
2059    }
2060
2061    public function testGetObjectAttributeWorksForInheritedAttributes()
2062    {
2063        $this->assertEquals(
2064            'bar',
2065            $this->getObjectAttribute(new ClassWithNonPublicAttributes, 'privateParentAttribute')
2066        );
2067    }
2068
2069    public function testAssertPublicAttributeContains()
2070    {
2071        $obj = new ClassWithNonPublicAttributes;
2072
2073        $this->assertAttributeContains('foo', 'publicArray', $obj);
2074
2075        try {
2076            $this->assertAttributeContains('bar', 'publicArray', $obj);
2077        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2078            return;
2079        }
2080
2081        $this->fail();
2082    }
2083
2084    public function testAssertPublicAttributeContainsOnly()
2085    {
2086        $obj = new ClassWithNonPublicAttributes;
2087
2088        $this->assertAttributeContainsOnly('string', 'publicArray', $obj);
2089
2090        try {
2091            $this->assertAttributeContainsOnly('integer', 'publicArray', $obj);
2092        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2093            return;
2094        }
2095
2096        $this->fail();
2097    }
2098
2099    public function testAssertPublicAttributeNotContains()
2100    {
2101        $obj = new ClassWithNonPublicAttributes;
2102
2103        $this->assertAttributeNotContains('bar', 'publicArray', $obj);
2104
2105        try {
2106            $this->assertAttributeNotContains('foo', 'publicArray', $obj);
2107        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2108            return;
2109        }
2110
2111        $this->fail();
2112    }
2113
2114    public function testAssertPublicAttributeNotContainsOnly()
2115    {
2116        $obj = new ClassWithNonPublicAttributes;
2117
2118        $this->assertAttributeNotContainsOnly('integer', 'publicArray', $obj);
2119
2120        try {
2121            $this->assertAttributeNotContainsOnly('string', 'publicArray', $obj);
2122        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2123            return;
2124        }
2125
2126        $this->fail();
2127    }
2128
2129    public function testAssertProtectedAttributeContains()
2130    {
2131        $obj = new ClassWithNonPublicAttributes;
2132
2133        $this->assertAttributeContains('bar', 'protectedArray', $obj);
2134
2135        try {
2136            $this->assertAttributeContains('foo', 'protectedArray', $obj);
2137        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2138            return;
2139        }
2140
2141        $this->fail();
2142    }
2143
2144    public function testAssertProtectedAttributeNotContains()
2145    {
2146        $obj = new ClassWithNonPublicAttributes;
2147
2148        $this->assertAttributeNotContains('foo', 'protectedArray', $obj);
2149
2150        try {
2151            $this->assertAttributeNotContains('bar', 'protectedArray', $obj);
2152        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2153            return;
2154        }
2155
2156        $this->fail();
2157    }
2158
2159    public function testAssertPrivateAttributeContains()
2160    {
2161        $obj = new ClassWithNonPublicAttributes;
2162
2163        $this->assertAttributeContains('baz', 'privateArray', $obj);
2164
2165        try {
2166            $this->assertAttributeContains('foo', 'privateArray', $obj);
2167        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2168            return;
2169        }
2170
2171        $this->fail();
2172    }
2173
2174    public function testAssertPrivateAttributeNotContains()
2175    {
2176        $obj = new ClassWithNonPublicAttributes;
2177
2178        $this->assertAttributeNotContains('foo', 'privateArray', $obj);
2179
2180        try {
2181            $this->assertAttributeNotContains('baz', 'privateArray', $obj);
2182        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2183            return;
2184        }
2185
2186        $this->fail();
2187    }
2188
2189    public function testAssertAttributeContainsNonObject()
2190    {
2191        $obj = new ClassWithNonPublicAttributes;
2192
2193        $this->assertAttributeContains(true, 'privateArray', $obj);
2194
2195        try {
2196            $this->assertAttributeContains(true, 'privateArray', $obj, '', false, true, true);
2197        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2198            return;
2199        }
2200
2201        $this->fail();
2202    }
2203
2204    public function testAssertAttributeNotContainsNonObject()
2205    {
2206        $obj = new ClassWithNonPublicAttributes;
2207
2208        $this->assertAttributeNotContains(true, 'privateArray', $obj, '', false, true, true);
2209
2210        try {
2211            $this->assertAttributeNotContains(true, 'privateArray', $obj);
2212        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2213            return;
2214        }
2215
2216        $this->fail();
2217    }
2218
2219    public function testAssertPublicAttributeEquals()
2220    {
2221        $obj = new ClassWithNonPublicAttributes;
2222
2223        $this->assertAttributeEquals('foo', 'publicAttribute', $obj);
2224
2225        try {
2226            $this->assertAttributeEquals('bar', 'publicAttribute', $obj);
2227        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2228            return;
2229        }
2230
2231        $this->fail();
2232    }
2233
2234    public function testAssertPublicAttributeNotEquals()
2235    {
2236        $obj = new ClassWithNonPublicAttributes;
2237
2238        $this->assertAttributeNotEquals('bar', 'publicAttribute', $obj);
2239
2240        try {
2241            $this->assertAttributeNotEquals('foo', 'publicAttribute', $obj);
2242        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2243            return;
2244        }
2245
2246        $this->fail();
2247    }
2248
2249    public function testAssertPublicAttributeSame()
2250    {
2251        $obj = new ClassWithNonPublicAttributes;
2252
2253        $this->assertAttributeSame('foo', 'publicAttribute', $obj);
2254
2255        try {
2256            $this->assertAttributeSame('bar', 'publicAttribute', $obj);
2257        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2258            return;
2259        }
2260
2261        $this->fail();
2262    }
2263
2264    public function testAssertPublicAttributeNotSame()
2265    {
2266        $obj = new ClassWithNonPublicAttributes;
2267
2268        $this->assertAttributeNotSame('bar', 'publicAttribute', $obj);
2269
2270        try {
2271            $this->assertAttributeNotSame('foo', 'publicAttribute', $obj);
2272        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2273            return;
2274        }
2275
2276        $this->fail();
2277    }
2278
2279    public function testAssertProtectedAttributeEquals()
2280    {
2281        $obj = new ClassWithNonPublicAttributes;
2282
2283        $this->assertAttributeEquals('bar', 'protectedAttribute', $obj);
2284
2285        try {
2286            $this->assertAttributeEquals('foo', 'protectedAttribute', $obj);
2287        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2288            return;
2289        }
2290
2291        $this->fail();
2292    }
2293
2294    public function testAssertProtectedAttributeNotEquals()
2295    {
2296        $obj = new ClassWithNonPublicAttributes;
2297
2298        $this->assertAttributeNotEquals('foo', 'protectedAttribute', $obj);
2299
2300        try {
2301            $this->assertAttributeNotEquals('bar', 'protectedAttribute', $obj);
2302        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2303            return;
2304        }
2305
2306        $this->fail();
2307    }
2308
2309    public function testAssertPrivateAttributeEquals()
2310    {
2311        $obj = new ClassWithNonPublicAttributes;
2312
2313        $this->assertAttributeEquals('baz', 'privateAttribute', $obj);
2314
2315        try {
2316            $this->assertAttributeEquals('foo', 'privateAttribute', $obj);
2317        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2318            return;
2319        }
2320
2321        $this->fail();
2322    }
2323
2324    public function testAssertPrivateAttributeNotEquals()
2325    {
2326        $obj = new ClassWithNonPublicAttributes;
2327
2328        $this->assertAttributeNotEquals('foo', 'privateAttribute', $obj);
2329
2330        try {
2331            $this->assertAttributeNotEquals('baz', 'privateAttribute', $obj);
2332        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2333            return;
2334        }
2335
2336        $this->fail();
2337    }
2338
2339    public function testAssertPublicStaticAttributeEquals()
2340    {
2341        $this->assertAttributeEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2342
2343        try {
2344            $this->assertAttributeEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2345        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2346            return;
2347        }
2348
2349        $this->fail();
2350    }
2351
2352    public function testAssertPublicStaticAttributeNotEquals()
2353    {
2354        $this->assertAttributeNotEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2355
2356        try {
2357            $this->assertAttributeNotEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2358        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2359            return;
2360        }
2361
2362        $this->fail();
2363    }
2364
2365    public function testAssertProtectedStaticAttributeEquals()
2366    {
2367        $this->assertAttributeEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2368
2369        try {
2370            $this->assertAttributeEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2371        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2372            return;
2373        }
2374
2375        $this->fail();
2376    }
2377
2378    public function testAssertProtectedStaticAttributeNotEquals()
2379    {
2380        $this->assertAttributeNotEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2381
2382        try {
2383            $this->assertAttributeNotEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2384        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2385            return;
2386        }
2387
2388        $this->fail();
2389    }
2390
2391    public function testAssertPrivateStaticAttributeEquals()
2392    {
2393        $this->assertAttributeEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2394
2395        try {
2396            $this->assertAttributeEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2397        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2398            return;
2399        }
2400
2401        $this->fail();
2402    }
2403
2404    public function testAssertPrivateStaticAttributeNotEquals()
2405    {
2406        $this->assertAttributeNotEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2407
2408        try {
2409            $this->assertAttributeNotEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2410        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2411            return;
2412        }
2413
2414        $this->fail();
2415    }
2416
2417    /**
2418     * @expectedException PHPUnit_Framework_Exception
2419     */
2420    public function testAssertClassHasAttributeThrowsException()
2421    {
2422        $this->assertClassHasAttribute(null, null);
2423    }
2424
2425    /**
2426     * @expectedException PHPUnit_Framework_Exception
2427     */
2428    public function testAssertClassHasAttributeThrowsException2()
2429    {
2430        $this->assertClassHasAttribute('foo', null);
2431    }
2432
2433    /**
2434     * @expectedException PHPUnit_Framework_Exception
2435     */
2436    public function testAssertClassHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2437    {
2438        $this->assertClassHasAttribute('1', 'ClassWithNonPublicAttributes');
2439    }
2440
2441    /**
2442     * @expectedException PHPUnit_Framework_Exception
2443     */
2444    public function testAssertClassNotHasAttributeThrowsException()
2445    {
2446        $this->assertClassNotHasAttribute(null, null);
2447    }
2448
2449    /**
2450     * @expectedException PHPUnit_Framework_Exception
2451     */
2452    public function testAssertClassNotHasAttributeThrowsException2()
2453    {
2454        $this->assertClassNotHasAttribute('foo', null);
2455    }
2456
2457    /**
2458     * @expectedException PHPUnit_Framework_Exception
2459     */
2460    public function testAssertClassNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2461    {
2462        $this->assertClassNotHasAttribute('1', 'ClassWithNonPublicAttributes');
2463    }
2464
2465    /**
2466     * @expectedException PHPUnit_Framework_Exception
2467     */
2468    public function testAssertClassHasStaticAttributeThrowsException()
2469    {
2470        $this->assertClassHasStaticAttribute(null, null);
2471    }
2472
2473    /**
2474     * @expectedException PHPUnit_Framework_Exception
2475     */
2476    public function testAssertClassHasStaticAttributeThrowsException2()
2477    {
2478        $this->assertClassHasStaticAttribute('foo', null);
2479    }
2480
2481    /**
2482     * @expectedException PHPUnit_Framework_Exception
2483     */
2484    public function testAssertClassHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid()
2485    {
2486        $this->assertClassHasStaticAttribute('1', 'ClassWithNonPublicAttributes');
2487    }
2488
2489    /**
2490     * @expectedException PHPUnit_Framework_Exception
2491     */
2492    public function testAssertClassNotHasStaticAttributeThrowsException()
2493    {
2494        $this->assertClassNotHasStaticAttribute(null, null);
2495    }
2496
2497    /**
2498     * @expectedException PHPUnit_Framework_Exception
2499     */
2500    public function testAssertClassNotHasStaticAttributeThrowsException2()
2501    {
2502        $this->assertClassNotHasStaticAttribute('foo', null);
2503    }
2504
2505    /**
2506     * @expectedException PHPUnit_Framework_Exception
2507     */
2508    public function testAssertClassNotHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid()
2509    {
2510        $this->assertClassNotHasStaticAttribute('1', 'ClassWithNonPublicAttributes');
2511    }
2512
2513    /**
2514     * @expectedException PHPUnit_Framework_Exception
2515     */
2516    public function testAssertObjectHasAttributeThrowsException()
2517    {
2518        $this->assertObjectHasAttribute(null, null);
2519    }
2520
2521    /**
2522     * @expectedException PHPUnit_Framework_Exception
2523     */
2524    public function testAssertObjectHasAttributeThrowsException2()
2525    {
2526        $this->assertObjectHasAttribute('foo', null);
2527    }
2528
2529    /**
2530     * @expectedException PHPUnit_Framework_Exception
2531     */
2532    public function testAssertObjectHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2533    {
2534        $this->assertObjectHasAttribute('1', 'ClassWithNonPublicAttributes');
2535    }
2536
2537    /**
2538     * @expectedException PHPUnit_Framework_Exception
2539     */
2540    public function testAssertObjectNotHasAttributeThrowsException()
2541    {
2542        $this->assertObjectNotHasAttribute(null, null);
2543    }
2544
2545    /**
2546     * @expectedException PHPUnit_Framework_Exception
2547     */
2548    public function testAssertObjectNotHasAttributeThrowsException2()
2549    {
2550        $this->assertObjectNotHasAttribute('foo', null);
2551    }
2552
2553    /**
2554     * @expectedException PHPUnit_Framework_Exception
2555     */
2556    public function testAssertObjectNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2557    {
2558        $this->assertObjectNotHasAttribute('1', 'ClassWithNonPublicAttributes');
2559    }
2560
2561    public function testClassHasPublicAttribute()
2562    {
2563        $this->assertClassHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
2564
2565        try {
2566            $this->assertClassHasAttribute('attribute', 'ClassWithNonPublicAttributes');
2567        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2568            return;
2569        }
2570
2571        $this->fail();
2572    }
2573
2574    public function testClassNotHasPublicAttribute()
2575    {
2576        $this->assertClassNotHasAttribute('attribute', 'ClassWithNonPublicAttributes');
2577
2578        try {
2579            $this->assertClassNotHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
2580        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2581            return;
2582        }
2583
2584        $this->fail();
2585    }
2586
2587    public function testClassHasPublicStaticAttribute()
2588    {
2589        $this->assertClassHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
2590
2591        try {
2592            $this->assertClassHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
2593        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2594            return;
2595        }
2596
2597        $this->fail();
2598    }
2599
2600    public function testClassNotHasPublicStaticAttribute()
2601    {
2602        $this->assertClassNotHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
2603
2604        try {
2605            $this->assertClassNotHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
2606        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2607            return;
2608        }
2609
2610        $this->fail();
2611    }
2612
2613    public function testObjectHasPublicAttribute()
2614    {
2615        $obj = new ClassWithNonPublicAttributes;
2616
2617        $this->assertObjectHasAttribute('publicAttribute', $obj);
2618
2619        try {
2620            $this->assertObjectHasAttribute('attribute', $obj);
2621        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2622            return;
2623        }
2624
2625        $this->fail();
2626    }
2627
2628    public function testObjectNotHasPublicAttribute()
2629    {
2630        $obj = new ClassWithNonPublicAttributes;
2631
2632        $this->assertObjectNotHasAttribute('attribute', $obj);
2633
2634        try {
2635            $this->assertObjectNotHasAttribute('publicAttribute', $obj);
2636        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2637            return;
2638        }
2639
2640        $this->fail();
2641    }
2642
2643    public function testObjectHasOnTheFlyAttribute()
2644    {
2645        $obj      = new stdClass;
2646        $obj->foo = 'bar';
2647
2648        $this->assertObjectHasAttribute('foo', $obj);
2649
2650        try {
2651            $this->assertObjectHasAttribute('bar', $obj);
2652        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2653            return;
2654        }
2655
2656        $this->fail();
2657    }
2658
2659    public function testObjectNotHasOnTheFlyAttribute()
2660    {
2661        $obj      = new stdClass;
2662        $obj->foo = 'bar';
2663
2664        $this->assertObjectNotHasAttribute('bar', $obj);
2665
2666        try {
2667            $this->assertObjectNotHasAttribute('foo', $obj);
2668        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2669            return;
2670        }
2671
2672        $this->fail();
2673    }
2674
2675    public function testObjectHasProtectedAttribute()
2676    {
2677        $obj = new ClassWithNonPublicAttributes;
2678
2679        $this->assertObjectHasAttribute('protectedAttribute', $obj);
2680
2681        try {
2682            $this->assertObjectHasAttribute('attribute', $obj);
2683        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2684            return;
2685        }
2686
2687        $this->fail();
2688    }
2689
2690    public function testObjectNotHasProtectedAttribute()
2691    {
2692        $obj = new ClassWithNonPublicAttributes;
2693
2694        $this->assertObjectNotHasAttribute('attribute', $obj);
2695
2696        try {
2697            $this->assertObjectNotHasAttribute('protectedAttribute', $obj);
2698        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2699            return;
2700        }
2701
2702        $this->fail();
2703    }
2704
2705    public function testObjectHasPrivateAttribute()
2706    {
2707        $obj = new ClassWithNonPublicAttributes;
2708
2709        $this->assertObjectHasAttribute('privateAttribute', $obj);
2710
2711        try {
2712            $this->assertObjectHasAttribute('attribute', $obj);
2713        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2714            return;
2715        }
2716
2717        $this->fail();
2718    }
2719
2720    public function testObjectNotHasPrivateAttribute()
2721    {
2722        $obj = new ClassWithNonPublicAttributes;
2723
2724        $this->assertObjectNotHasAttribute('attribute', $obj);
2725
2726        try {
2727            $this->assertObjectNotHasAttribute('privateAttribute', $obj);
2728        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2729            return;
2730        }
2731
2732        $this->fail();
2733    }
2734
2735    public function testAssertThatAttributeEquals()
2736    {
2737        $this->assertThat(
2738            new ClassWithNonPublicAttributes,
2739            $this->attribute(
2740                $this->equalTo('foo'),
2741                'publicAttribute'
2742            )
2743        );
2744    }
2745
2746    /**
2747     * @expectedException PHPUnit_Framework_AssertionFailedError
2748     */
2749    public function testAssertThatAttributeEquals2()
2750    {
2751        $this->assertThat(
2752            new ClassWithNonPublicAttributes,
2753            $this->attribute(
2754                $this->equalTo('bar'),
2755                'publicAttribute'
2756            )
2757        );
2758    }
2759
2760    public function testAssertThatAttributeEqualTo()
2761    {
2762        $this->assertThat(
2763            new ClassWithNonPublicAttributes,
2764            $this->attributeEqualTo('publicAttribute', 'foo')
2765        );
2766    }
2767
2768    public function testAssertThatAnything()
2769    {
2770        $this->assertThat('anything', $this->anything());
2771    }
2772
2773    public function testAssertThatIsTrue()
2774    {
2775        $this->assertThat(true, $this->isTrue());
2776    }
2777
2778    public function testAssertThatIsFalse()
2779    {
2780        $this->assertThat(false, $this->isFalse());
2781    }
2782
2783    public function testAssertThatIsJson()
2784    {
2785        $this->assertThat('{}', $this->isJson());
2786    }
2787
2788    public function testAssertThatAnythingAndAnything()
2789    {
2790        $this->assertThat(
2791            'anything',
2792            $this->logicalAnd(
2793                $this->anything(), $this->anything()
2794            )
2795        );
2796    }
2797
2798    public function testAssertThatAnythingOrAnything()
2799    {
2800        $this->assertThat(
2801            'anything',
2802            $this->logicalOr(
2803                $this->anything(), $this->anything()
2804            )
2805        );
2806    }
2807
2808    public function testAssertThatAnythingXorNotAnything()
2809    {
2810        $this->assertThat(
2811            'anything',
2812            $this->logicalXor(
2813                $this->anything(),
2814                $this->logicalNot($this->anything())
2815            )
2816        );
2817    }
2818
2819    public function testAssertThatContains()
2820    {
2821        $this->assertThat(['foo'], $this->contains('foo'));
2822    }
2823
2824    public function testAssertThatStringContains()
2825    {
2826        $this->assertThat('barfoobar', $this->stringContains('foo'));
2827    }
2828
2829    public function testAssertThatContainsOnly()
2830    {
2831        $this->assertThat(['foo'], $this->containsOnly('string'));
2832    }
2833
2834    public function testAssertThatContainsOnlyInstancesOf()
2835    {
2836        $this->assertThat([new Book], $this->containsOnlyInstancesOf('Book'));
2837    }
2838
2839    public function testAssertThatArrayHasKey()
2840    {
2841        $this->assertThat(['foo' => 'bar'], $this->arrayHasKey('foo'));
2842    }
2843
2844    public function testAssertThatClassHasAttribute()
2845    {
2846        $this->assertThat(
2847            new ClassWithNonPublicAttributes,
2848            $this->classHasAttribute('publicAttribute')
2849        );
2850    }
2851
2852    public function testAssertThatClassHasStaticAttribute()
2853    {
2854        $this->assertThat(
2855            new ClassWithNonPublicAttributes,
2856            $this->classHasStaticAttribute('publicStaticAttribute')
2857        );
2858    }
2859
2860    public function testAssertThatObjectHasAttribute()
2861    {
2862        $this->assertThat(
2863            new ClassWithNonPublicAttributes,
2864            $this->objectHasAttribute('publicAttribute')
2865        );
2866    }
2867
2868    public function testAssertThatEqualTo()
2869    {
2870        $this->assertThat('foo', $this->equalTo('foo'));
2871    }
2872
2873    public function testAssertThatIdenticalTo()
2874    {
2875        $value      = new stdClass;
2876        $constraint = $this->identicalTo($value);
2877
2878        $this->assertThat($value, $constraint);
2879    }
2880
2881    public function testAssertThatIsInstanceOf()
2882    {
2883        $this->assertThat(new stdClass, $this->isInstanceOf('StdClass'));
2884    }
2885
2886    public function testAssertThatIsType()
2887    {
2888        $this->assertThat('string', $this->isType('string'));
2889    }
2890
2891    public function testAssertThatIsEmpty()
2892    {
2893        $this->assertThat([], $this->isEmpty());
2894    }
2895
2896    public function testAssertThatFileExists()
2897    {
2898        $this->assertThat(__FILE__, $this->fileExists());
2899    }
2900
2901    public function testAssertThatGreaterThan()
2902    {
2903        $this->assertThat(2, $this->greaterThan(1));
2904    }
2905
2906    public function testAssertThatGreaterThanOrEqual()
2907    {
2908        $this->assertThat(2, $this->greaterThanOrEqual(1));
2909    }
2910
2911    public function testAssertThatLessThan()
2912    {
2913        $this->assertThat(1, $this->lessThan(2));
2914    }
2915
2916    public function testAssertThatLessThanOrEqual()
2917    {
2918        $this->assertThat(1, $this->lessThanOrEqual(2));
2919    }
2920
2921    public function testAssertThatMatchesRegularExpression()
2922    {
2923        $this->assertThat('foobar', $this->matchesRegularExpression('/foo/'));
2924    }
2925
2926    public function testAssertThatCallback()
2927    {
2928        $this->assertThat(
2929            null,
2930            $this->callback(function ($other) {
2931                return true;
2932            })
2933        );
2934    }
2935
2936    public function testAssertThatCountOf()
2937    {
2938        $this->assertThat([1], $this->countOf(1));
2939    }
2940
2941    public function testAssertFileEquals()
2942    {
2943        $this->assertFileEquals(
2944            $this->filesDirectory . 'foo.xml',
2945            $this->filesDirectory . 'foo.xml'
2946        );
2947
2948        try {
2949            $this->assertFileEquals(
2950                $this->filesDirectory . 'foo.xml',
2951                $this->filesDirectory . 'bar.xml'
2952            );
2953        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2954            return;
2955        }
2956
2957        $this->fail();
2958    }
2959
2960    public function testAssertFileNotEquals()
2961    {
2962        $this->assertFileNotEquals(
2963            $this->filesDirectory . 'foo.xml',
2964            $this->filesDirectory . 'bar.xml'
2965        );
2966
2967        try {
2968            $this->assertFileNotEquals(
2969                $this->filesDirectory . 'foo.xml',
2970                $this->filesDirectory . 'foo.xml'
2971            );
2972        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2973            return;
2974        }
2975
2976        $this->fail();
2977    }
2978
2979    public function testAssertStringEqualsFile()
2980    {
2981        $this->assertStringEqualsFile(
2982            $this->filesDirectory . 'foo.xml',
2983            file_get_contents($this->filesDirectory . 'foo.xml')
2984        );
2985
2986        try {
2987            $this->assertStringEqualsFile(
2988                $this->filesDirectory . 'foo.xml',
2989                file_get_contents($this->filesDirectory . 'bar.xml')
2990            );
2991        } catch (PHPUnit_Framework_AssertionFailedError $e) {
2992            return;
2993        }
2994
2995        $this->fail();
2996    }
2997
2998    public function testAssertStringNotEqualsFile()
2999    {
3000        $this->assertStringNotEqualsFile(
3001            $this->filesDirectory . 'foo.xml',
3002            file_get_contents($this->filesDirectory . 'bar.xml')
3003        );
3004
3005        try {
3006            $this->assertStringNotEqualsFile(
3007                $this->filesDirectory . 'foo.xml',
3008                file_get_contents($this->filesDirectory . 'foo.xml')
3009            );
3010        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3011            return;
3012        }
3013
3014        $this->fail();
3015    }
3016
3017    /**
3018     * @expectedException PHPUnit_Framework_Exception
3019     */
3020    public function testAssertStringStartsWithThrowsException()
3021    {
3022        $this->assertStringStartsWith(null, null);
3023    }
3024
3025    /**
3026     * @expectedException PHPUnit_Framework_Exception
3027     */
3028    public function testAssertStringStartsWithThrowsException2()
3029    {
3030        $this->assertStringStartsWith('', null);
3031    }
3032
3033    /**
3034     * @expectedException PHPUnit_Framework_Exception
3035     */
3036    public function testAssertStringStartsNotWithThrowsException()
3037    {
3038        $this->assertStringStartsNotWith(null, null);
3039    }
3040
3041    /**
3042     * @expectedException PHPUnit_Framework_Exception
3043     */
3044    public function testAssertStringStartsNotWithThrowsException2()
3045    {
3046        $this->assertStringStartsNotWith('', null);
3047    }
3048
3049    /**
3050     * @expectedException PHPUnit_Framework_Exception
3051     */
3052    public function testAssertStringEndsWithThrowsException()
3053    {
3054        $this->assertStringEndsWith(null, null);
3055    }
3056
3057    /**
3058     * @expectedException PHPUnit_Framework_Exception
3059     */
3060    public function testAssertStringEndsWithThrowsException2()
3061    {
3062        $this->assertStringEndsWith('', null);
3063    }
3064
3065    /**
3066     * @expectedException PHPUnit_Framework_Exception
3067     */
3068    public function testAssertStringEndsNotWithThrowsException()
3069    {
3070        $this->assertStringEndsNotWith(null, null);
3071    }
3072
3073    /**
3074     * @expectedException PHPUnit_Framework_Exception
3075     */
3076    public function testAssertStringEndsNotWithThrowsException2()
3077    {
3078        $this->assertStringEndsNotWith('', null);
3079    }
3080
3081    public function testAssertStringStartsWith()
3082    {
3083        $this->assertStringStartsWith('prefix', 'prefixfoo');
3084
3085        try {
3086            $this->assertStringStartsWith('prefix', 'foo');
3087        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3088            return;
3089        }
3090
3091        $this->fail();
3092    }
3093
3094    public function testAssertStringStartsNotWith()
3095    {
3096        $this->assertStringStartsNotWith('prefix', 'foo');
3097
3098        try {
3099            $this->assertStringStartsNotWith('prefix', 'prefixfoo');
3100        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3101            return;
3102        }
3103
3104        $this->fail();
3105    }
3106
3107    public function testAssertStringEndsWith()
3108    {
3109        $this->assertStringEndsWith('suffix', 'foosuffix');
3110
3111        try {
3112            $this->assertStringEndsWith('suffix', 'foo');
3113        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3114            return;
3115        }
3116
3117        $this->fail();
3118    }
3119
3120    public function testAssertStringEndsNotWith()
3121    {
3122        $this->assertStringEndsNotWith('suffix', 'foo');
3123
3124        try {
3125            $this->assertStringEndsNotWith('suffix', 'foosuffix');
3126        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3127            return;
3128        }
3129
3130        $this->fail();
3131    }
3132
3133    /**
3134     * @expectedException PHPUnit_Framework_Exception
3135     */
3136    public function testAssertStringMatchesFormatRaisesExceptionForInvalidFirstArgument()
3137    {
3138        $this->assertStringMatchesFormat(null, '');
3139    }
3140
3141    /**
3142     * @expectedException PHPUnit_Framework_Exception
3143     */
3144    public function testAssertStringMatchesFormatRaisesExceptionForInvalidSecondArgument()
3145    {
3146        $this->assertStringMatchesFormat('', null);
3147    }
3148
3149    public function testAssertStringMatchesFormat()
3150    {
3151        $this->assertStringMatchesFormat('*%s*', '***');
3152    }
3153
3154    /**
3155     * @expectedException PHPUnit_Framework_AssertionFailedError
3156     */
3157    public function testAssertStringMatchesFormatFailure()
3158    {
3159        $this->assertStringMatchesFormat('*%s*', '**');
3160    }
3161
3162    /**
3163     * @expectedException PHPUnit_Framework_Exception
3164     */
3165    public function testAssertStringNotMatchesFormatRaisesExceptionForInvalidFirstArgument()
3166    {
3167        $this->assertStringNotMatchesFormat(null, '');
3168    }
3169
3170    /**
3171     * @expectedException PHPUnit_Framework_Exception
3172     */
3173    public function testAssertStringNotMatchesFormatRaisesExceptionForInvalidSecondArgument()
3174    {
3175        $this->assertStringNotMatchesFormat('', null);
3176    }
3177
3178    public function testAssertStringNotMatchesFormat()
3179    {
3180        $this->assertStringNotMatchesFormat('*%s*', '**');
3181
3182        try {
3183            $this->assertStringMatchesFormat('*%s*', '**');
3184        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3185            return;
3186        }
3187
3188        $this->fail();
3189    }
3190
3191    public function testAssertEmpty()
3192    {
3193        $this->assertEmpty([]);
3194
3195        try {
3196            $this->assertEmpty(['foo']);
3197        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3198            return;
3199        }
3200
3201        $this->fail();
3202    }
3203
3204    public function testAssertNotEmpty()
3205    {
3206        $this->assertNotEmpty(['foo']);
3207
3208        try {
3209            $this->assertNotEmpty([]);
3210        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3211            return;
3212        }
3213
3214        $this->fail();
3215    }
3216
3217    public function testAssertAttributeEmpty()
3218    {
3219        $o    = new stdClass;
3220        $o->a = [];
3221
3222        $this->assertAttributeEmpty('a', $o);
3223
3224        try {
3225            $o->a = ['b'];
3226            $this->assertAttributeEmpty('a', $o);
3227        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3228            return;
3229        }
3230
3231        $this->fail();
3232    }
3233
3234    public function testAssertAttributeNotEmpty()
3235    {
3236        $o    = new stdClass;
3237        $o->a = ['b'];
3238
3239        $this->assertAttributeNotEmpty('a', $o);
3240
3241        try {
3242            $o->a = [];
3243            $this->assertAttributeNotEmpty('a', $o);
3244        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3245            return;
3246        }
3247
3248        $this->fail();
3249    }
3250
3251    public function testMarkTestIncomplete()
3252    {
3253        try {
3254            $this->markTestIncomplete('incomplete');
3255        } catch (PHPUnit_Framework_IncompleteTestError $e) {
3256            $this->assertEquals('incomplete', $e->getMessage());
3257
3258            return;
3259        }
3260
3261        $this->fail();
3262    }
3263
3264    public function testMarkTestSkipped()
3265    {
3266        try {
3267            $this->markTestSkipped('skipped');
3268        } catch (PHPUnit_Framework_SkippedTestError $e) {
3269            $this->assertEquals('skipped', $e->getMessage());
3270
3271            return;
3272        }
3273
3274        $this->fail();
3275    }
3276
3277    public function testAssertCount()
3278    {
3279        $this->assertCount(2, [1, 2]);
3280
3281        try {
3282            $this->assertCount(2, [1, 2, 3]);
3283        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3284            return;
3285        }
3286
3287        $this->fail();
3288    }
3289
3290    public function testAssertCountTraversable()
3291    {
3292        $this->assertCount(2, new ArrayIterator([1, 2]));
3293
3294        try {
3295            $this->assertCount(2, new ArrayIterator([1, 2, 3]));
3296        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3297            return;
3298        }
3299
3300        $this->fail();
3301    }
3302
3303    public function testAssertCountThrowsExceptionIfExpectedCountIsNoInteger()
3304    {
3305        try {
3306            $this->assertCount('a', []);
3307        } catch (PHPUnit_Framework_Exception $e) {
3308            $this->assertEquals('Argument #1 (No Value) of PHPUnit_Framework_Assert::assertCount() must be a integer', $e->getMessage());
3309
3310            return;
3311        }
3312
3313        $this->fail();
3314    }
3315
3316    public function testAssertCountThrowsExceptionIfElementIsNotCountable()
3317    {
3318        try {
3319            $this->assertCount(2, '');
3320        } catch (PHPUnit_Framework_Exception $e) {
3321            $this->assertEquals('Argument #2 (No Value) of PHPUnit_Framework_Assert::assertCount() must be a countable or traversable', $e->getMessage());
3322
3323            return;
3324        }
3325
3326        $this->fail();
3327    }
3328
3329    public function testAssertAttributeCount()
3330    {
3331        $o    = new stdClass;
3332        $o->a = [];
3333
3334        $this->assertAttributeCount(0, 'a', $o);
3335    }
3336
3337    public function testAssertNotCount()
3338    {
3339        $this->assertNotCount(2, [1, 2, 3]);
3340
3341        try {
3342            $this->assertNotCount(2, [1, 2]);
3343        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3344            return;
3345        }
3346
3347        $this->fail();
3348    }
3349
3350    /**
3351     * @expectedException PHPUnit_Framework_Exception
3352     */
3353    public function testAssertNotCountThrowsExceptionIfExpectedCountIsNoInteger()
3354    {
3355        $this->assertNotCount('a', []);
3356    }
3357
3358    /**
3359     * @expectedException PHPUnit_Framework_Exception
3360     */
3361    public function testAssertNotCountThrowsExceptionIfElementIsNotCountable()
3362    {
3363        $this->assertNotCount(2, '');
3364    }
3365
3366    public function testAssertAttributeNotCount()
3367    {
3368        $o    = new stdClass;
3369        $o->a = [];
3370
3371        $this->assertAttributeNotCount(1, 'a', $o);
3372    }
3373
3374    public function testAssertSameSize()
3375    {
3376        $this->assertSameSize([1, 2], [3, 4]);
3377
3378        try {
3379            $this->assertSameSize([1, 2], [1, 2, 3]);
3380        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3381            return;
3382        }
3383
3384        $this->fail();
3385    }
3386
3387    public function testAssertSameSizeThrowsExceptionIfExpectedIsNotCountable()
3388    {
3389        try {
3390            $this->assertSameSize('a', []);
3391        } catch (PHPUnit_Framework_Exception $e) {
3392            $this->assertEquals('Argument #1 (No Value) of PHPUnit_Framework_Assert::assertSameSize() must be a countable or traversable', $e->getMessage());
3393
3394            return;
3395        }
3396
3397        $this->fail();
3398    }
3399
3400    public function testAssertSameSizeThrowsExceptionIfActualIsNotCountable()
3401    {
3402        try {
3403            $this->assertSameSize([], '');
3404        } catch (PHPUnit_Framework_Exception $e) {
3405            $this->assertEquals('Argument #2 (No Value) of PHPUnit_Framework_Assert::assertSameSize() must be a countable or traversable', $e->getMessage());
3406
3407            return;
3408        }
3409
3410        $this->fail();
3411    }
3412
3413    public function testAssertNotSameSize()
3414    {
3415        $this->assertNotSameSize([1, 2], [1, 2, 3]);
3416
3417        try {
3418            $this->assertNotSameSize([1, 2], [3, 4]);
3419        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3420            return;
3421        }
3422
3423        $this->fail();
3424    }
3425
3426    /**
3427     * @expectedException PHPUnit_Framework_Exception
3428     */
3429    public function testAssertNotSameSizeThrowsExceptionIfExpectedIsNotCountable()
3430    {
3431        $this->assertNotSameSize('a', []);
3432    }
3433
3434    /**
3435     * @expectedException PHPUnit_Framework_Exception
3436     */
3437    public function testAssertNotSameSizeThrowsExceptionIfActualIsNotCountable()
3438    {
3439        $this->assertNotSameSize([], '');
3440    }
3441
3442    /**
3443     * @expectedException PHPUnit_Framework_Exception
3444     */
3445    public function testAssertJsonRaisesExceptionForInvalidArgument()
3446    {
3447        $this->assertJson(null);
3448    }
3449
3450    public function testAssertJson()
3451    {
3452        $this->assertJson('{}');
3453    }
3454
3455    public function testAssertJsonStringEqualsJsonString()
3456    {
3457        $expected = '{"Mascott" : "Tux"}';
3458        $actual   = '{"Mascott" : "Tux"}';
3459        $message  = 'Given Json strings do not match';
3460
3461        $this->assertJsonStringEqualsJsonString($expected, $actual, $message);
3462    }
3463
3464    /**
3465     * @dataProvider validInvalidJsonDataprovider
3466     */
3467    public function testAssertJsonStringEqualsJsonStringErrorRaised($expected, $actual)
3468    {
3469        try {
3470            $this->assertJsonStringEqualsJsonString($expected, $actual);
3471        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3472            return;
3473        }
3474        $this->fail('Expected exception not found');
3475    }
3476
3477    public function testAssertJsonStringNotEqualsJsonString()
3478    {
3479        $expected = '{"Mascott" : "Beastie"}';
3480        $actual   = '{"Mascott" : "Tux"}';
3481        $message  = 'Given Json strings do match';
3482
3483        $this->assertJsonStringNotEqualsJsonString($expected, $actual, $message);
3484    }
3485
3486    /**
3487     * @dataProvider validInvalidJsonDataprovider
3488     */
3489    public function testAssertJsonStringNotEqualsJsonStringErrorRaised($expected, $actual)
3490    {
3491        try {
3492            $this->assertJsonStringNotEqualsJsonString($expected, $actual);
3493        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3494            return;
3495        }
3496        $this->fail('Expected exception not found');
3497    }
3498
3499    public function testAssertJsonStringEqualsJsonFile()
3500    {
3501        $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3502        $actual  = json_encode(['Mascott' => 'Tux']);
3503        $message = '';
3504        $this->assertJsonStringEqualsJsonFile($file, $actual, $message);
3505    }
3506
3507    public function testAssertJsonStringEqualsJsonFileExpectingExpectationFailedException()
3508    {
3509        $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3510        $actual  = json_encode(['Mascott' => 'Beastie']);
3511        $message = '';
3512        try {
3513            $this->assertJsonStringEqualsJsonFile($file, $actual, $message);
3514        } catch (PHPUnit_Framework_ExpectationFailedException $e) {
3515            $this->assertEquals(
3516                'Failed asserting that \'{"Mascott":"Beastie"}\' matches JSON string "{"Mascott":"Tux"}".',
3517                $e->getMessage()
3518            );
3519
3520            return;
3521        }
3522
3523        $this->fail('Expected Exception not thrown.');
3524    }
3525
3526    public function testAssertJsonStringEqualsJsonFileExpectingException()
3527    {
3528        $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
3529        try {
3530            $this->assertJsonStringEqualsJsonFile($file, null);
3531        } catch (PHPUnit_Framework_Exception $e) {
3532            return;
3533        }
3534        $this->fail('Expected Exception not thrown.');
3535    }
3536
3537    public function testAssertJsonStringNotEqualsJsonFile()
3538    {
3539        $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3540        $actual  = json_encode(['Mascott' => 'Beastie']);
3541        $message = '';
3542        $this->assertJsonStringNotEqualsJsonFile($file, $actual, $message);
3543    }
3544
3545    public function testAssertJsonStringNotEqualsJsonFileExpectingException()
3546    {
3547        $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
3548        try {
3549            $this->assertJsonStringNotEqualsJsonFile($file, null);
3550        } catch (PHPUnit_Framework_Exception $e) {
3551            return;
3552        }
3553        $this->fail('Expected exception not found.');
3554    }
3555
3556    public function testAssertJsonFileNotEqualsJsonFile()
3557    {
3558        $fileExpected = __DIR__ . '/../_files/JsonData/simpleObject.json';
3559        $fileActual   = __DIR__ . '/../_files/JsonData/arrayObject.json';
3560        $message      = '';
3561        $this->assertJsonFileNotEqualsJsonFile($fileExpected, $fileActual, $message);
3562    }
3563
3564    public function testAssertJsonFileEqualsJsonFile()
3565    {
3566        $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3567        $message = '';
3568        $this->assertJsonFileEqualsJsonFile($file, $file, $message);
3569    }
3570
3571    public function testAssertInstanceOf()
3572    {
3573        $this->assertInstanceOf('stdClass', new stdClass);
3574
3575        try {
3576            $this->assertInstanceOf('Exception', new stdClass);
3577        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3578            return;
3579        }
3580
3581        $this->fail();
3582    }
3583
3584    /**
3585     * @expectedException PHPUnit_Framework_Exception
3586     */
3587    public function testAssertInstanceOfThrowsExceptionForInvalidArgument()
3588    {
3589        $this->assertInstanceOf(null, new stdClass);
3590    }
3591
3592    public function testAssertAttributeInstanceOf()
3593    {
3594        $o    = new stdClass;
3595        $o->a = new stdClass;
3596
3597        $this->assertAttributeInstanceOf('stdClass', 'a', $o);
3598    }
3599
3600    public function testAssertNotInstanceOf()
3601    {
3602        $this->assertNotInstanceOf('Exception', new stdClass);
3603
3604        try {
3605            $this->assertNotInstanceOf('stdClass', new stdClass);
3606        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3607            return;
3608        }
3609
3610        $this->fail();
3611    }
3612
3613    /**
3614     * @expectedException PHPUnit_Framework_Exception
3615     */
3616    public function testAssertNotInstanceOfThrowsExceptionForInvalidArgument()
3617    {
3618        $this->assertNotInstanceOf(null, new stdClass);
3619    }
3620
3621    public function testAssertAttributeNotInstanceOf()
3622    {
3623        $o    = new stdClass;
3624        $o->a = new stdClass;
3625
3626        $this->assertAttributeNotInstanceOf('Exception', 'a', $o);
3627    }
3628
3629    public function testAssertInternalType()
3630    {
3631        $this->assertInternalType('integer', 1);
3632
3633        try {
3634            $this->assertInternalType('string', 1);
3635        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3636            return;
3637        }
3638
3639        $this->fail();
3640    }
3641
3642    public function testAssertInternalTypeDouble()
3643    {
3644        $this->assertInternalType('double', 1.0);
3645
3646        try {
3647            $this->assertInternalType('double', 1);
3648        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3649            return;
3650        }
3651
3652        $this->fail();
3653    }
3654
3655    /**
3656     * @expectedException PHPUnit_Framework_Exception
3657     */
3658    public function testAssertInternalTypeThrowsExceptionForInvalidArgument()
3659    {
3660        $this->assertInternalType(null, 1);
3661    }
3662
3663    public function testAssertAttributeInternalType()
3664    {
3665        $o    = new stdClass;
3666        $o->a = 1;
3667
3668        $this->assertAttributeInternalType('integer', 'a', $o);
3669    }
3670
3671    public function testAssertNotInternalType()
3672    {
3673        $this->assertNotInternalType('string', 1);
3674
3675        try {
3676            $this->assertNotInternalType('integer', 1);
3677        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3678            return;
3679        }
3680
3681        $this->fail();
3682    }
3683
3684    /**
3685     * @expectedException PHPUnit_Framework_Exception
3686     */
3687    public function testAssertNotInternalTypeThrowsExceptionForInvalidArgument()
3688    {
3689        $this->assertNotInternalType(null, 1);
3690    }
3691
3692    public function testAssertAttributeNotInternalType()
3693    {
3694        $o    = new stdClass;
3695        $o->a = 1;
3696
3697        $this->assertAttributeNotInternalType('string', 'a', $o);
3698    }
3699
3700    /**
3701     * @expectedException PHPUnit_Framework_Exception
3702     */
3703    public function testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument()
3704    {
3705        $this->assertStringMatchesFormatFile('not_existing_file', '');
3706    }
3707
3708    /**
3709     * @expectedException PHPUnit_Framework_Exception
3710     */
3711    public function testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument2()
3712    {
3713        $this->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', null);
3714    }
3715
3716    public function testAssertStringMatchesFormatFile()
3717    {
3718        $this->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "FOO\n");
3719
3720        try {
3721            $this->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "BAR\n");
3722        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3723            return;
3724        }
3725
3726        $this->fail();
3727    }
3728
3729    /**
3730     * @expectedException PHPUnit_Framework_Exception
3731     */
3732    public function testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument()
3733    {
3734        $this->assertStringNotMatchesFormatFile('not_existing_file', '');
3735    }
3736
3737    /**
3738     * @expectedException PHPUnit_Framework_Exception
3739     */
3740    public function testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument2()
3741    {
3742        $this->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', null);
3743    }
3744
3745    public function testAssertStringNotMatchesFormatFile()
3746    {
3747        $this->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "BAR\n");
3748
3749        try {
3750            $this->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "FOO\n");
3751        } catch (PHPUnit_Framework_AssertionFailedError $e) {
3752            return;
3753        }
3754
3755        $this->fail();
3756    }
3757
3758    /**
3759     * @return array
3760     */
3761    public static function validInvalidJsonDataprovider()
3762    {
3763        return [
3764            'error syntax in expected JSON' => ['{"Mascott"::}', '{"Mascott" : "Tux"}'],
3765            'error UTF-8 in actual JSON'    => ['{"Mascott" : "Tux"}', '{"Mascott" : :}'],
3766        ];
3767    }
3768}
3769