@@ -5,25 +5,25 @@ discard block  | 
                                                    ||
| 5 | 5 | class ArrayDebuggerTest extends \PHPUnit_Framework_TestCase  | 
                                                        
| 6 | 6 |  { | 
                                                        
| 7 | 7 | |
| 8 | - public $base = array(  | 
                                                        |
| 8 | + public $base = array(  | 
                                                        |
| 9 | 9 | 'hum' => 1,  | 
                                                        
| 10 | 10 | 'dois' => 2,  | 
                                                        
| 11 | 11 | 'tres' => 3  | 
                                                        
| 12 | - );  | 
                                                        |
| 12 | + );  | 
                                                        |
| 13 | 13 | |
| 14 | -  public function testGetter() { | 
                                                        |
| 14 | +    public function testGetter() { | 
                                                        |
| 15 | 15 | |
| 16 | 16 | $array = new ArrayDebugger($this->base);  | 
                                                        
| 17 | 17 | $t = $this;  | 
                                                        
| 18 | 18 | |
| 19 | 19 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 20 | - $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_GET);  | 
                                                        |
| 20 | + $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_GET);  | 
                                                        |
| 21 | 21 | });  | 
                                                        
| 22 | 22 | |
| 23 | 23 | $teste = $array['hum'];  | 
                                                        
| 24 | 24 | |
| 25 | 25 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 26 | - $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_GET);  | 
                                                        |
| 26 | + $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_GET);  | 
                                                        |
| 27 | 27 | });  | 
                                                        
| 28 | 28 | |
| 29 | 29 | $array['quatro'] = 4;  | 
                                                        
@@ -36,21 +36,21 @@ discard block  | 
                                                    ||
| 36 | 36 | * offsetUnset  | 
                                                        
| 37 | 37 | */  | 
                                                        
| 38 | 38 | unset($array['quatro']);  | 
                                                        
| 39 | - }  | 
                                                        |
| 39 | + }  | 
                                                        |
| 40 | 40 | |
| 41 | -  public function testSetter() { | 
                                                        |
| 41 | +    public function testSetter() { | 
                                                        |
| 42 | 42 | |
| 43 | 43 | $array = new ArrayDebugger($this->base);  | 
                                                        
| 44 | 44 | |
| 45 | 45 | $t = $this;  | 
                                                        
| 46 | 46 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 47 | - $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_SET);  | 
                                                        |
| 47 | + $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_SET);  | 
                                                        |
| 48 | 48 | });  | 
                                                        
| 49 | 49 | |
| 50 | 50 | $array['quatro'] = 4;  | 
                                                        
| 51 | 51 | |
| 52 | 52 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 53 | - $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_SET);  | 
                                                        |
| 53 | + $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_SET);  | 
                                                        |
| 54 | 54 | });  | 
                                                        
| 55 | 55 | |
| 56 | 56 | $teste = $array['hum'];  | 
                                                        
@@ -63,15 +63,15 @@ discard block  | 
                                                    ||
| 63 | 63 | * offsetUnset  | 
                                                        
| 64 | 64 | */  | 
                                                        
| 65 | 65 | unset($array['quatro']);  | 
                                                        
| 66 | - }  | 
                                                        |
| 66 | + }  | 
                                                        |
| 67 | 67 | |
| 68 | -  public function testIsset() { | 
                                                        |
| 68 | +    public function testIsset() { | 
                                                        |
| 69 | 69 | |
| 70 | 70 | $array = new ArrayDebugger($this->base);  | 
                                                        
| 71 | 71 | |
| 72 | 72 | $t = $this;  | 
                                                        
| 73 | 73 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 74 | - $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_EXISTS);  | 
                                                        |
| 74 | + $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_EXISTS);  | 
                                                        |
| 75 | 75 | });  | 
                                                        
| 76 | 76 | |
| 77 | 77 | |
@@ -81,7 +81,7 @@ discard block  | 
                                                    ||
| 81 | 81 | isset($array['hum']);  | 
                                                        
| 82 | 82 | |
| 83 | 83 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 84 | - $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_EXISTS);  | 
                                                        |
| 84 | + $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_EXISTS);  | 
                                                        |
| 85 | 85 | });  | 
                                                        
| 86 | 86 | |
| 87 | 87 | $array['quatro'] = 4;  | 
                                                        
@@ -92,15 +92,15 @@ discard block  | 
                                                    ||
| 92 | 92 | * offsetUnset  | 
                                                        
| 93 | 93 | */  | 
                                                        
| 94 | 94 | unset($array['quatro']);  | 
                                                        
| 95 | - }  | 
                                                        |
| 95 | + }  | 
                                                        |
| 96 | 96 | |
| 97 | -  public function testUnset() { | 
                                                        |
| 97 | +    public function testUnset() { | 
                                                        |
| 98 | 98 | |
| 99 | 99 | $array = new ArrayDebugger($this->base);  | 
                                                        
| 100 | 100 | $t = $this;  | 
                                                        
| 101 | 101 | |
| 102 | 102 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 103 | - $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_UNSET);  | 
                                                        |
| 103 | + $t->assertEquals($retorno['type'], ArrayDebugger::TYPE_UNSET);  | 
                                                        |
| 104 | 104 | });  | 
                                                        
| 105 | 105 | |
| 106 | 106 | /**  | 
                                                        
@@ -109,7 +109,7 @@ discard block  | 
                                                    ||
| 109 | 109 | unset($array['dois']);  | 
                                                        
| 110 | 110 | |
| 111 | 111 |      $array->setLogger(function($retorno) use($t) { | 
                                                        
| 112 | - $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_UNSET);  | 
                                                        |
| 112 | + $t->assertNotEquals($retorno['type'], ArrayDebugger::TYPE_UNSET);  | 
                                                        |
| 113 | 113 | });  | 
                                                        
| 114 | 114 | /**  | 
                                                        
| 115 | 115 | * offsetExists  | 
                                                        
@@ -120,5 +120,5 @@ discard block  | 
                                                    ||
| 120 | 120 | |
| 121 | 121 | $teste = $array['hum'];  | 
                                                        
| 122 | 122 | |
| 123 | - }  | 
                                                        |
| 123 | + }  | 
                                                        |
| 124 | 124 | }  |