@@ -125,6 +125,10 @@  | 
                                                    ||
| 125 | 125 | return $this->resultSet;  | 
                                                        
| 126 | 126 | }  | 
                                                        
| 127 | 127 | |
| 128 | + /**  | 
                                                        |
| 129 | + * @param integer|null $start  | 
                                                        |
| 130 | + * @param integer|null $rows  | 
                                                        |
| 131 | + */  | 
                                                        |
| 128 | 132 | private function resultSetStartAndRowsAreNotNullAndChange($start, $rows)  | 
                                                        
| 129 | 133 |      { | 
                                                        
| 130 | 134 | return $this->resultSetStartAndRowsAreNotNull($start, $rows) &&  | 
                                                        
@@ -105,6 +105,9 @@ discard block  | 
                                                    ||
| 105 | 105 | return $this->normalizeOutOfRangePages;  | 
                                                        
| 106 | 106 | }  | 
                                                        
| 107 | 107 | |
| 108 | + /**  | 
                                                        |
| 109 | + * @param boolean $value  | 
                                                        |
| 110 | + */  | 
                                                        |
| 108 | 111 | private function filterBoolean($value)  | 
                                                        
| 109 | 112 |      { | 
                                                        
| 110 | 113 |          if (!is_bool($value)) { | 
                                                        
@@ -134,6 +137,9 @@ discard block  | 
                                                    ||
| 134 | 137 | return $this;  | 
                                                        
| 135 | 138 | }  | 
                                                        
| 136 | 139 | |
| 140 | + /**  | 
                                                        |
| 141 | + * @param integer $maxPerPage  | 
                                                        |
| 142 | + */  | 
                                                        |
| 137 | 143 | private function filterMaxPerPage($maxPerPage)  | 
                                                        
| 138 | 144 |      { | 
                                                        
| 139 | 145 | $maxPerPage = $this->toInteger($maxPerPage);  | 
                                                        
@@ -214,6 +220,10 @@ discard block  | 
                                                    ||
| 214 | 220 | $this->useDeprecatedBooleanArgument($arguments, $index, $method);  | 
                                                        
| 215 | 221 | }  | 
                                                        
| 216 | 222 | |
| 223 | + /**  | 
                                                        |
| 224 | + * @param integer $index  | 
                                                        |
| 225 | + * @param string $method  | 
                                                        |
| 226 | + */  | 
                                                        |
| 217 | 227 | private function useDeprecatedBooleanArgument($arguments, $index, $method)  | 
                                                        
| 218 | 228 |      { | 
                                                        
| 219 | 229 |          if (isset($arguments[$index])) { | 
                                                        
@@ -221,6 +231,9 @@ discard block  | 
                                                    ||
| 221 | 231 | }  | 
                                                        
| 222 | 232 | }  | 
                                                        
| 223 | 233 | |
| 234 | + /**  | 
                                                        |
| 235 | + * @param integer $currentPage  | 
                                                        |
| 236 | + */  | 
                                                        |
| 224 | 237 | private function filterCurrentPage($currentPage)  | 
                                                        
| 225 | 238 |      { | 
                                                        
| 226 | 239 | $currentPage = $this->toInteger($currentPage);  | 
                                                        
@@ -43,6 +43,9 @@ discard block  | 
                                                    ||
| 43 | 43 | return DriverManager::getConnection($params);  | 
                                                        
| 44 | 44 | }  | 
                                                        
| 45 | 45 | |
| 46 | + /**  | 
                                                        |
| 47 | + * @param \Doctrine\DBAL\Connection $conn  | 
                                                        |
| 48 | + */  | 
                                                        |
| 46 | 49 | private function createSchema($conn)  | 
                                                        
| 47 | 50 |      { | 
                                                        
| 48 | 51 | $schema = new Schema();  | 
                                                        
@@ -66,6 +69,9 @@ discard block  | 
                                                    ||
| 66 | 69 | }  | 
                                                        
| 67 | 70 | }  | 
                                                        
| 68 | 71 | |
| 72 | + /**  | 
                                                        |
| 73 | + * @param \Doctrine\DBAL\Connection $conn  | 
                                                        |
| 74 | + */  | 
                                                        |
| 69 | 75 | private function insertData($conn)  | 
                                                        
| 70 | 76 |      { | 
                                                        
| 71 | 77 |          for ($i = 1; $i <= 50; $i++) { | 
                                                        
@@ -65,6 +65,9 @@ discard block  | 
                                                    ||
| 65 | 65 | $this->assertSame($slice, $this->adapter->getSlice($offset, $length));  | 
                                                        
| 66 | 66 | }  | 
                                                        
| 67 | 67 | |
| 68 | + /**  | 
                                                        |
| 69 | + * @param integer $limit  | 
                                                        |
| 70 | + */  | 
                                                        |
| 68 | 71 | private function prepareQueryLimit($limit)  | 
                                                        
| 69 | 72 |      { | 
                                                        
| 70 | 73 | $this->query  | 
                                                        
@@ -74,6 +77,9 @@ discard block  | 
                                                    ||
| 74 | 77 | ->will($this->returnValue($this->query));  | 
                                                        
| 75 | 78 | }  | 
                                                        
| 76 | 79 | |
| 80 | + /**  | 
                                                        |
| 81 | + * @param integer $skip  | 
                                                        |
| 82 | + */  | 
                                                        |
| 77 | 83 | private function prepareQuerySkip($skip)  | 
                                                        
| 78 | 84 |      { | 
                                                        
| 79 | 85 | $this->query  | 
                                                        
@@ -83,6 +89,9 @@ discard block  | 
                                                    ||
| 83 | 89 | ->will($this->returnValue($this->query));  | 
                                                        
| 84 | 90 | }  | 
                                                        
| 85 | 91 | |
| 92 | + /**  | 
                                                        |
| 93 | + * @param \ArrayObject $all  | 
                                                        |
| 94 | + */  | 
                                                        |
| 86 | 95 | private function prepareQueryAll($all)  | 
                                                        
| 87 | 96 |      { | 
                                                        
| 88 | 97 | $this->query  | 
                                                        
@@ -189,6 +189,10 @@  | 
                                                    ||
| 189 | 189 | $this->doTestGetResultSet($query, $endPoint);  | 
                                                        
| 190 | 190 | }  | 
                                                        
| 191 | 191 | |
| 192 | + /**  | 
                                                        |
| 193 | + * @param \PHPUnit\Framework\MockObject\MockObject $query  | 
                                                        |
| 194 | + * @param null|string $endPoint  | 
                                                        |
| 195 | + */  | 
                                                        |
| 192 | 196 | private function doTestGetResultSet($query, $endPoint)  | 
                                                        
| 193 | 197 |      { | 
                                                        
| 194 | 198 | $client = $this->createClientMock();  | 
                                                        
@@ -34,11 +34,17 @@ discard block  | 
                                                    ||
| 34 | 34 | $this->pagerfanta = new Pagerfanta($this->adapter);  | 
                                                        
| 35 | 35 | }  | 
                                                        
| 36 | 36 | |
| 37 | + /**  | 
                                                        |
| 38 | + * @param integer $nbResults  | 
                                                        |
| 39 | + */  | 
                                                        |
| 37 | 40 | private function setAdapterNbResultsAny($nbResults)  | 
                                                        
| 38 | 41 |      { | 
                                                        
| 39 | 42 | $this->setAdapterNbResults($this->any(), $nbResults);  | 
                                                        
| 40 | 43 | }  | 
                                                        
| 41 | 44 | |
| 45 | + /**  | 
                                                        |
| 46 | + * @param integer $nbResults  | 
                                                        |
| 47 | + */  | 
                                                        |
| 42 | 48 | private function setAdapterNbResultsOnce($nbResults)  | 
                                                        
| 43 | 49 |      { | 
                                                        
| 44 | 50 | $this->setAdapterNbResults($this->once(), $nbResults);  | 
                                                        
@@ -672,6 +678,9 @@ discard block  | 
                                                    ||
| 672 | 678 |          $this->assertInstanceOf('IteratorAggregate', $this->pagerfanta); | 
                                                        
| 673 | 679 | }  | 
                                                        
| 674 | 680 | |
| 681 | + /**  | 
                                                        |
| 682 | + * @param \Closure $callback  | 
                                                        |
| 683 | + */  | 
                                                        |
| 675 | 684 | private function assertResetCurrentPageResults($callback)  | 
                                                        
| 676 | 685 |      { | 
                                                        
| 677 | 686 | $this->setAdapterNbResultsAny(100);  | 
                                                        
@@ -35,6 +35,9 @@ discard block  | 
                                                    ||
| 35 | 35 | */  | 
                                                        
| 36 | 36 | abstract protected function createView();  | 
                                                        
| 37 | 37 | |
| 38 | + /**  | 
                                                        |
| 39 | + * @param integer $nbPages  | 
                                                        |
| 40 | + */  | 
                                                        |
| 38 | 41 | protected function setNbPages($nbPages)  | 
                                                        
| 39 | 42 |      { | 
                                                        
| 40 | 43 | $nbResults = $this->calculateNbResults($nbPages);  | 
                                                        
@@ -50,6 +53,9 @@ discard block  | 
                                                    ||
| 50 | 53 | return $nbPages * $this->pagerfanta->getMaxPerPage();  | 
                                                        
| 51 | 54 | }  | 
                                                        
| 52 | 55 | |
| 56 | + /**  | 
                                                        |
| 57 | + * @param integer $currentPage  | 
                                                        |
| 58 | + */  | 
                                                        |
| 53 | 59 | protected function setCurrentPage($currentPage)  | 
                                                        
| 54 | 60 |      { | 
                                                        
| 55 | 61 | $this->pagerfanta->setCurrentPage($currentPage);  | 
                                                        
@@ -67,6 +73,9 @@ discard block  | 
                                                    ||
| 67 | 73 |          return function ($page) { return '|'.$page.'|'; }; | 
                                                        
| 68 | 74 | }  | 
                                                        
| 69 | 75 | |
| 76 | + /**  | 
                                                        |
| 77 | + * @param string $expected  | 
                                                        |
| 78 | + */  | 
                                                        |
| 70 | 79 | protected function assertRenderedView($expected, $result)  | 
                                                        
| 71 | 80 |      { | 
                                                        
| 72 | 81 | $this->assertSame($this->filterExpectedView($expected), $result);  |