WordPress.org

Make WordPress Core

Ticket #28559: absint.php

File absint.php, 14.7 KB (added by pbearne, 8 years ago)

ABSINT() unit tests test/functions/absint.php

Line 
1<?php
2/*
3 * Test absint().
4 *
5 * @group functions.php
6 *
7*/
8
9/**
10 * Converts value to nonnegative integer.
11 *
12 * @since 2.5.0
13 *
14 * @param mixed $maybeint Data you wish to have converted to a nonnegative integer
15 * @return int An nonnegative integer
16 */
17// function absint( $maybeint ) {
18//      return abs( intval( $maybeint ) );
19// }
20
21
22
23
24
25class Tests_Absint extends WP_UnitTestCase {
26        function setUp() {
27                parent::setUp();
28        }
29        /*
30        * helper funtion to switch tests for 64 bit systems
31        */
32        private function is_64_bit(){
33                if ( 8 === PHP_INT_SIZE ){
34                        return true;
35                }
36                return false;
37        }
38
39        /**
40         * ABSINT safe not saf to use yet
41         */
42        private function absints( $maybeint ) {
43                if ( (double)$maybeint  > (double)PHP_INT_MAX ){
44                        return 0;
45                }
46                return abs( intval( $maybeint ) );
47        }
48
49        /**
50         * testing numbers
51         * note the 4.9999999999999999 becomes 5 not 4
52         */
53        function test_absint() {
54                $this->assertEquals( absint( 1 ), 1, '1' );
55                $this->assertEquals( absint( -1 ), 1, '-1' );
56                $this->assertEquals( absint( 999 ), 999, '999' );
57                $this->assertEquals( absint( -999 ), 999, '-999');
58                $this->assertEquals( absint( 0 ), 0, '0');
59                $this->assertEquals( absint( 4.0000000000000000001 ), 4, '4.0000000000000000001' );
60                $this->assertEquals( absint( 4.4999999999999999999 ), 4, '4.4999999999999999999' );
61                $this->assertEquals( absint( 4.5 ), 4, '4.5' );
62                $this->assertEquals( absint( 4.5000000000000000001 ), 4, '4.5000000000000000001' );
63                $this->assertEquals( absint( 4.51 ), 4, '4.51' );
64                $this->assertEquals( absint( 4.6 ), 4, '4.6' );
65                $this->assertEquals( absint( 4.7 ), 4, '4.7' );
66                $this->assertEquals( absint( 4.8 ), 4, '4.8' );
67                $this->assertEquals( absint( 4.9 ), 4, '4.9' ); // double(4.9)
68                $this->assertEquals( absint( 4.99 ), 4, '4.99' );
69                $this->assertEquals( absint( 4.999 ), 4, '4.999' );
70                $this->assertEquals( absint( 4.9999 ), 4, '4.9999' );
71                $this->assertEquals( absint( 4.99999 ), 4, '4.99999' );
72                $this->assertEquals( absint( 4.999999 ), 4, '4.999999' );
73                $this->assertEquals( absint( 4.9999999 ), 4, '4.9999999' );
74                $this->assertEquals( absint( 4.99999999 ), 4, '4.99999999' );
75                $this->assertEquals( absint( 4.999999999 ), 4, '4.999999999' );
76                $this->assertEquals( absint( 4.9999999999 ), 4, '4.9999999999' );
77                $this->assertEquals( absint( 4.99999999999 ), 4, '4.99999999999' );
78                $this->assertEquals( absint( 4.999999999999 ), 4, '4.999999999999' );
79                $this->assertEquals( absint( 4.9999999999999 ), 4, '4.999999999999' );// double(4.999999999999)
80                $this->assertEquals( absint( 4.99999999999999 ), 4, '4.99999999999999' ); // double(5)
81                $this->assertEquals( absint( 4.999999999999999 ), 4, '4.999999999999999' );
82
83                 // why does it swap to 4 where does the round up not round down come from
84                $this->assertEquals( absint( 4.9999999999999999 ), 5, '4.9999999999999999' ); // 32bit
85                $this->assertEquals( absint( 4.99999999999999999 ), 5, '4.99999999999999999' );
86                $this->assertEquals( absint( 4.999999999999999999 ), 5, '4.999999999999999999' );
87                $this->assertEquals( absint( 4.9999999999999999999 ), 5, '4.9999999999999999999' );
88
89                $this->assertEquals( absint( 4.11111111111111111111 ), 4, '4.11111111111111111111' );
90                $this->assertEquals( absint( 4.555555555555555555555 ), 4, '4.555555555555555555555' );
91
92
93                $this->assertEquals( absint( 4.99999999999999 ), 4,             '4.99999999999999' );
94                $this->assertEquals( absint( 49.9999999999999 ), 49,            '49.9999999999999' );
95                $this->assertEquals( absint( 499.999999999999 ), 499,           '499.999999999999' );
96                $this->assertEquals( absint( 4999.99999999999 ), 4999,          '4999.99999999999' );
97                $this->assertEquals( absint( 49999.9999999999 ), 49999,         '49999.9999999999' );
98                $this->assertEquals( absint( 499999.999999999 ), 499999,        '499999.999999999' );
99                $this->assertEquals( absint( 4999999.99999999 ), 4999999,       '4999999.99999999' );
100                $this->assertEquals( absint( 49999999.9999999 ), 49999999,      '49999999.9999999' );
101                $this->assertEquals( absint( 499999999.999999 ), 499999999,     '499999999.999999' );
102
103                $this->assertEquals( absint( 4.9999999999999999999 ), 5,                '4.9999999999999999999' );
104                $this->assertEquals( absint( 49.999999999999999999 ), 50,               '49.999999999999999999' );
105                $this->assertEquals( absint( 499.99999999999999999 ), 500,              '499.99999999999999999' );
106                $this->assertEquals( absint( 4999.9999999999999999 ), 5000,             '4999.9999999999999999' );
107                $this->assertEquals( absint( 49999.999999999999999 ), 50000,    '49999.999999999999999' );
108                $this->assertEquals( absint( 499999.99999999999999 ), 500000,   '499999.99999999999999' );
109                $this->assertEquals( absint( 4999999.9999999999999 ), 5000000,  '4999999.9999999999999' );
110                $this->assertEquals( absint( 49999999.999999999999 ), 50000000,         '49999999.999999999999' );
111                $this->assertEquals( absint( 499999999.99999999999 ), 500000000,        '499999999.99999999999' );
112
113
114                if ( $this->is_64_bit() ){
115                        $this->assertEquals( absint( 4999999999.9999999999 ), 5000000000,                       '4999999999.9999999999' );
116                        $this->assertEquals( absint( 49999999999.999999999 ), 50000000000,              '49999999999.999999999' );
117                        $this->assertEquals( absint( 499999999999.99999999 ), 500000000000,             '499999999999.99999999' );
118                        $this->assertEquals( absint( 4999999999999.9999999 ), 5000000000000,            '4999999999999.9999999' );
119                        $this->assertEquals( absint( 49999999999999.999999 ), 50000000000000,           '49999999999999.999999' );
120                        $this->assertEquals( absint( 499999999999999.99999 ), 500000000000000,          '499999999999999.99999' );
121                        $this->assertEquals( absint( 4999999999999999.9999 ), 5000000000000000,                 '4999999999999999.9999' );
122                        $this->assertEquals( absint( 49999999999999999.999 ), 50000000000000000,        '49999999999999999.999' );
123                        $this->assertEquals( absint( 499999999999999999.99 ), 500000000000000000,       '499999999999999999.99' );
124                        $this->assertEquals( absint( 4999999999999999999.9 ), 5000000000000000000,      '4999999999999999999.9' );
125                        $this->assertEquals( absint( 49999999999999999999 ),  5340232221128654848,      '49999999999999999999' );
126                } else {
127                        $this->assertEquals( absint( 4999999999.9999999999 ), 705032704,        '4999999999.9999999999' );
128                        $this->assertEquals( absint( 49999999999.999999999 ), 1539607552,       '49999999999.999999999' );
129                        $this->assertEquals( absint( 499999999999.99999999 ), 1783793664,       '499999999999.99999999' );
130                        $this->assertEquals( absint( 4999999999999.9999999 ), 658067456,        '4999999999999.9999999' );
131                        $this->assertEquals( absint( 49999999999999.999999 ), 2009260032,       '49999999999999.999999' );
132                        $this->assertEquals( absint( 499999999999999.99999 ), 1382236160,       '499999999999999.99999' );
133                        $this->assertEquals( absint( 4999999999999999.9999 ), 937459712,        '4999999999999999.9999' );
134                        $this->assertEquals( absint( 49999999999999999.999 ), 784662528,        '49999999999999999.999' );
135                        $this->assertEquals( absint( 499999999999999999.99 ), 743309312,        '499999999999999999.99' );
136                }
137
138
139                $this->assertEquals( absint( 5 ), 5, '5' );
140                $this->assertEquals( absint( 5.0000000000000000001 ), 5, '5.0000000000000000001' );
141                $this->assertEquals( absint( -4.0000000000000000001 ), 4, '-4.0000000000000000001' );
142                $this->assertEquals( absint( -4.4999999999999999999 ), 4, '-4.4999999999999999999' );
143                $this->assertEquals( absint( -4.5 ), 4, '-4.5' );
144                $this->assertEquals( absint( -4.5000000000000000001 ), 4, '-4.5000000000000000001' );
145                $this->assertEquals( absint( -4.51 ), 4, '-4.51' );
146                $this->assertEquals( absint( -4.9999999999999999999 ), 5, '-4.9999999999999999999' );
147                $this->assertEquals( absint( -5 ), 5, '-5' );
148                $this->assertEquals( absint( -5.0000000000000000001 ), 5, '-5.0000000000000000001' );
149
150        }
151
152        /**
153         *  test passing in strings
154         */
155        function test_absint_strings() {
156
157                $this->assertEquals( absint( '1' ), 1, '1' );
158                $this->assertEquals( absint( '-1' ), 1, '-1');
159                $this->assertEquals( absint( '1_string' ), 1, '1_string' );
160                $this->assertEquals( absint( '1_this_a_very_extra_long_string_that_so_long_that_might_brack_or_might_not_but_we_need_to_test' ), 1, '1_very_long_string' );
161                $this->assertEquals( absint( '1 string with spaces' ), 1, '1 string with spaces' );
162                $this->assertEquals( absint( '1_1' ), 1, '1_1' );
163                $this->assertEquals( absint( '1 1 1 ' ), 1, '1 1 1 ' );
164                $this->assertEquals( absint( '1 . 1 1 ' ), 1, '1 . 1 1 ' );
165
166                $number = '1';
167                $this->assertEquals( absint( $number ), 1, '1$number' );
168                $this->assertEquals( absint( "1$number" ), 11, '1$number' );
169                $this->assertEquals( absint( "1".$number ), 11, '"1".$number' );
170                $this->assertEquals( absint( '1'.$number ), 11, "'1'.$number" );
171
172                $number = 1;
173                $this->assertEquals( absint( $number ), 1, '1$number' );
174                $this->assertEquals( absint( "1$number" ), 11, '1$number' );
175                $this->assertEquals( absint( "1".$number ), 11, '"1".$number' );
176                $this->assertEquals( absint( '1'.$number ), 11, "'1'.$number" );
177
178
179
180                $this->assertEquals( absint( '999_string' ), 999, '999_string' );
181                $this->assertEquals( absint( '0' ), 0, '0' );
182                $this->assertEquals( absint( 'zero' ), 0, 'zero' );
183                $this->assertEquals( absint( 'string_1' ), 0, 'string_1' );
184                $this->assertEquals( absint( 'one' ), 0 ,'one' );
185                $this->assertEquals( absint( 'two' ), 0 ,'two' );
186                $this->assertEquals( absint( '-one' ), 0 ,'-one' );
187                $this->assertEquals( absint( '-two' ), 0 ,'-two' );
188                $this->assertEquals( absint( 'misus one' ), 0 ,'misus one' );
189                $this->assertEquals( absint( 'misus two' ), 0 ,'misus two' );
190
191                // 1 to the power of 10
192                $this->assertEquals( absint( '1e10' ), 1 ,'(string)1e10' );
193                if ( $this->is_64_bit() ){
194                        $this->assertEquals( absint( 1e10 ), 10000000000 ,'1e10' );
195                        $this->assertEquals( absint( 1e20 ), 100000000000000000000 ,'1e20' );
196
197                } else{
198                        $this->assertEquals( absint( 1e10 ), 1410065408 ,'1e10' );
199                }
200
201                $this->assertEquals( absint( 0x1A ), 26 ,'0x1A' );
202                $this->assertEquals( absint( '0x1A' ), 0 ,'(string)0x1A' );
203
204
205        }
206        /*
207        *  PHP_INT_MAX
208        */
209        function test_absint_PHP_INT_MAX() {
210
211                $this->assertEquals( absint( PHP_INT_MAX ), PHP_INT_MAX, ' PHP_INT_MAX ');
212                $this->assertEquals( absint( -PHP_INT_MAX ), PHP_INT_MAX, ' -PHP_INT_MAX ' );
213
214                $this->assertEquals( absint( PHP_INT_MAX-1 ), PHP_INT_MAX-1, ' PHP_INT_MAX-1 ');
215
216        }
217
218
219        /**
220         * this fails in strange way as we have hit MAX Init
221         */
222        function test_absint_over_max_int() {
223                if ( $this->is_64_bit() ){
224                        $this->assertEquals( absint( PHP_INT_MAX +1 ), 2147483648, 'PHP_INT_MAX+1-64bit' );
225                        $this->assertEquals( absint( PHP_INT_MAX +11 ), 2147483638, 'PHP_INT_MAX+11-64bit' );
226                        $this->assertEquals( absint( PHP_INT_MAX +99 ), 2147483550, 'PHP_INT_MAX+99-64bit' );
227                        $this->assertEquals( absint( PHP_INT_MAX +999 ), 2147482650, 'PHP_INT_MAX+999-64bit' );
228                }else{
229                        $this->assertEquals( absint( PHP_INT_MAX +1 ), 2147483648, 'PHP_INT_MAX+1-32bit' );
230                        $this->assertEquals( absint( PHP_INT_MAX +11 ), 2147483638, 'PHP_INT_MAX+11-32bit' );
231                        $this->assertEquals( absint( PHP_INT_MAX +99 ), 2147483550, 'PHP_INT_MAX+99-32bit' );
232                        $this->assertEquals( absint( PHP_INT_MAX +999 ), 2147482650, 'PHP_INT_MAX+999-32bit' );
233                }
234
235        }
236
237        /**
238        *  this is what you should get but we have hit max int
239        * x@ticket 12345
240        */
241        function test_absint_that_fail_max_int(){
242
243                if ( $this->is_64_bit() ){
244                        $this->assertEquals( absint( PHP_INT_MAX +1 ), 0, 'PHP_INT_MAX+1-64bit' );// Failed asserting that false matches expected 2147483648.
245                        $this->assertEquals( absint( PHP_INT_MAX +11 ), 0, 'PHP_INT_MAX+11-64bit' );// Failed asserting that false matches expected 2147483638.
246                        $this->assertEquals( absint( PHP_INT_MAX +99 ), 0, 'PHP_INT_MAX+99-64bit' );// Failed asserting that false matches expected 2147483550.
247                        $this->assertEquals( absint( PHP_INT_MAX +999 ), 0, 'PHP_INT_MAX+999-64bit' );// Failed asserting that false matches expected 2147482650.
248                }else{
249                        $this->assertEquals( absint( PHP_INT_MAX +1 ), 0, 'PHP_INT_MAX+1-32bit' ); // Failed asserting that false matches expected 2147483648.
250                        $this->assertEquals( absint( PHP_INT_MAX +11 ), 0, 'PHP_INT_MAX+11-32bit' );  // Failed asserting that false matches expected 2147483638.
251                        $this->assertEquals( absint( PHP_INT_MAX +99 ), 0, 'PHP_INT_MAX+99-32bit' );  // Failed asserting that false matches expected 2147483550.
252                        $this->assertEquals( absint( PHP_INT_MAX +999 ), 0, 'PHP_INT_MAX+999-32bit' );  // Failed asserting that false matches expected 2147482650.
253                }
254        }
255
256        /**
257         *  experimentally test using the test version of absint
258         */
259        function test_absint_safe_max_int(){
260
261                if ( $this->is_64_bit() ){
262                        $this->assertEquals( $this->absints( PHP_INT_MAX +1 ), 0, 'PHP_INT_MAX+1-64bit' );// Failed asserting that false matches expected 2147483648.
263                        $this->assertEquals( $this->absints( PHP_INT_MAX +11 ), 0, 'PHP_INT_MAX+11-64bit' );// Failed asserting that false matches expected 2147483638.
264                        $this->assertEquals( $this->absints( PHP_INT_MAX +99 ), 0, 'PHP_INT_MAX+99-64bit' );// Failed asserting that false matches expected 2147483550.
265                        $this->assertEquals( $this->absints( PHP_INT_MAX +999 ), 0, 'PHP_INT_MAX+999-64bit' );// Failed asserting that false matches expected 2147482650.
266                }else{
267                        $this->assertEquals( $this->absints( PHP_INT_MAX +1 ), 0, 'PHP_INT_MAX+1-32bit' ); // Failed asserting that false matches expected 2147483648.
268                        $this->assertEquals( $this->absints( PHP_INT_MAX +11 ), 0, 'PHP_INT_MAX+11-32bit' );  // Failed asserting that false matches expected 2147483638.
269                        $this->assertEquals( $this->absints( PHP_INT_MAX +99 ), 0, 'PHP_INT_MAX+99-32bit' );  // Failed asserting that false matches expected 2147483550.
270                        $this->assertEquals( $this->absints( PHP_INT_MAX +999 ), 0, 'PHP_INT_MAX+999-32bit' );  // Failed asserting that false matches expected 2147482650.
271                }
272        }
273        /**
274         *  this is what you should get but we have hit max int
275         * @ticket 28559
276         */
277        function test_absint_to_the_power_that_fails(){
278
279                if ( $this->is_64_bit() ){
280                        $this->assertEquals( absint( 1e20 ), 100000000000000000000 ,'1e20' );
281                } else{
282                        $this->assertEquals( absint( 1e10 ), 10000000000 ,'1e10' );  //Failed asserting that 10000000000 matches expected 1410065408.
283
284                }
285
286        }
287        /**
288         * this is what you should get but we have hit max int
289         * @ticket 28559
290         */
291        function test_absint_49999999999999999999(){
292                if ( $this->is_64_bit() ){
293                        $this->assertEquals( absint( 49999999999999999999 ),  50000000000000000000,     '49999999999999999999' );
294                } else {
295                        $this->assertEquals( absint( 4999999999.9999999999 ), 5000000000,                       '4999999999.9999999999' );
296                }
297        }
298
299        /**
300         *  at .9e16 absint returns 5 not 4
301         *  @ticket 28559
302         */
303        public function  test_absint_dot_16()
304        {
305                $this->assertEquals( absint( 4.999999999999999 ), 4, '4.999999999999999' );
306
307                 // why does it swap to 4 where does the round up not round down come from
308                $this->assertEquals( absint( 4.9999999999999999 ), 4, '4.9999999999999999' );
309        }
310
311
312}
313