]> git.immae.eu Git - github/wallabag/wallabag.git/blob - vendor/symfony/intl/Symfony/Component/Intl/Tests/NumberFormatter/AbstractNumberFormatterTest.php
ad5581b44b99aa15ca10f7ec7bd9313cddfb4798
[github/wallabag/wallabag.git] / vendor / symfony / intl / Symfony / Component / Intl / Tests / NumberFormatter / AbstractNumberFormatterTest.php
1 <?php
2
3 /*
4 * This file is part of the Symfony package.
5 *
6 * (c) Fabien Potencier <fabien@symfony.com>
7 *
8 * For the full copyright and license information, please view the LICENSE
9 * file that was distributed with this source code.
10 */
11
12 namespace Symfony\Component\Intl\Tests\NumberFormatter;
13
14 use Symfony\Component\Intl\Globals\IntlGlobals;
15 use Symfony\Component\Intl\Intl;
16 use Symfony\Component\Intl\Locale;
17 use Symfony\Component\Intl\NumberFormatter\NumberFormatter;
18 use Symfony\Component\Intl\Util\IntlTestHelper;
19
20 /**
21 * Note that there are some values written like -2147483647 - 1. This is the lower 32bit int max and is a known
22 * behavior of PHP.
23 */
24 abstract class AbstractNumberFormatterTest extends \PHPUnit_Framework_TestCase
25 {
26 /**
27 * @dataProvider formatCurrencyWithDecimalStyleProvider
28 */
29 public function testFormatCurrencyWithDecimalStyle($value, $currency, $expected)
30 {
31 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
32 $this->assertEquals($expected, $formatter->formatCurrency($value, $currency));
33 }
34
35 public function formatCurrencyWithDecimalStyleProvider()
36 {
37 return array(
38 array(100, 'ALL', '100'),
39 array(100, 'BRL', '100.00'),
40 array(100, 'CRC', '100'),
41 array(100, 'JPY', '100'),
42 array(100, 'CHF', '100'),
43 array(-100, 'ALL', '-100'),
44 array(-100, 'BRL', '-100'),
45 array(-100, 'CRC', '-100'),
46 array(-100, 'JPY', '-100'),
47 array(-100, 'CHF', '-100'),
48 array(1000.12, 'ALL', '1,000.12'),
49 array(1000.12, 'BRL', '1,000.12'),
50 array(1000.12, 'CRC', '1,000.12'),
51 array(1000.12, 'JPY', '1,000.12'),
52 array(1000.12, 'CHF', '1,000.12')
53 );
54 }
55
56 /**
57 * @dataProvider formatCurrencyWithCurrencyStyleProvider
58 */
59 public function testFormatCurrencyWithCurrencyStyle($value, $currency, $expected)
60 {
61 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
62 $this->assertEquals($expected, $formatter->formatCurrency($value, $currency));
63 }
64
65 public function formatCurrencyWithCurrencyStyleProvider()
66 {
67 return array(
68 array(100, 'ALL', 'ALL100'),
69 array(-100, 'ALL', '(ALL100)'),
70 array(1000.12, 'ALL', 'ALL1,000'),
71
72 array(100, 'JPY', '¥100'),
73 array(-100, 'JPY', '(¥100)'),
74 array(1000.12, 'JPY', '¥1,000'),
75
76 array(100, 'EUR', '€100.00'),
77 array(-100, 'EUR', '(€100.00)'),
78 array(1000.12, 'EUR', '€1,000.12'),
79 );
80 }
81
82 /**
83 * @dataProvider formatCurrencyWithCurrencyStyleCostaRicanColonsRoundingProvider
84 */
85 public function testFormatCurrencyWithCurrencyStyleCostaRicanColonsRounding($value, $currency, $symbol, $expected)
86 {
87 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
88 $this->assertEquals(sprintf($expected, $symbol), $formatter->formatCurrency($value, $currency));
89 }
90
91 public function formatCurrencyWithCurrencyStyleCostaRicanColonsRoundingProvider()
92 {
93 return array(
94 array(100, 'CRC', 'CRC', '%s100'),
95 array(-100, 'CRC', 'CRC', '(%s100)'),
96 array(1000.12, 'CRC', 'CRC', '%s1,000'),
97 );
98 }
99
100 /**
101 * @dataProvider formatCurrencyWithCurrencyStyleBrazilianRealRoundingProvider
102 */
103 public function testFormatCurrencyWithCurrencyStyleBrazilianRealRounding($value, $currency, $symbol, $expected)
104 {
105 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
106 $this->assertEquals(sprintf($expected, $symbol), $formatter->formatCurrency($value, $currency));
107 }
108
109 public function formatCurrencyWithCurrencyStyleBrazilianRealRoundingProvider()
110 {
111 return array(
112 array(100, 'BRL', 'R', '%s$100.00'),
113 array(-100, 'BRL', 'R', '(%s$100.00)'),
114 array(1000.12, 'BRL', 'R', '%s$1,000.12'),
115
116 // Rounding checks
117 array(1000.121, 'BRL', 'R', '%s$1,000.12'),
118 array(1000.123, 'BRL', 'R', '%s$1,000.12'),
119 array(1000.125, 'BRL', 'R', '%s$1,000.12'),
120 array(1000.127, 'BRL', 'R', '%s$1,000.13'),
121 array(1000.129, 'BRL', 'R', '%s$1,000.13'),
122 array(11.50999, 'BRL', 'R', '%s$11.51'),
123 array(11.9999464, 'BRL', 'R', '%s$12.00')
124 );
125 }
126
127 /**
128 * @dataProvider formatCurrencyWithCurrencyStyleSwissRoundingProvider
129 */
130 public function testFormatCurrencyWithCurrencyStyleSwissRounding($value, $currency, $symbol, $expected)
131 {
132 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
133 $this->assertEquals(sprintf($expected, $symbol), $formatter->formatCurrency($value, $currency));
134 }
135
136 public function formatCurrencyWithCurrencyStyleSwissRoundingProvider()
137 {
138 return array(
139 array(100, 'CHF', 'CHF', '%s100.00'),
140 array(-100, 'CHF', 'CHF', '(%s100.00)'),
141 array(1000.12, 'CHF', 'CHF', '%s1,000.10'),
142 array('1000.12', 'CHF', 'CHF', '%s1,000.10'),
143
144 // Rounding checks
145 array(1000.121, 'CHF', 'CHF', '%s1,000.10'),
146 array(1000.123, 'CHF', 'CHF', '%s1,000.10'),
147 array(1000.125, 'CHF', 'CHF', '%s1,000.10'),
148 array(1000.127, 'CHF', 'CHF', '%s1,000.15'),
149 array(1000.129, 'CHF', 'CHF', '%s1,000.15'),
150
151 array(1200000.00, 'CHF', 'CHF', '%s1,200,000.00'),
152 array(1200000.1, 'CHF', 'CHF', '%s1,200,000.10'),
153 array(1200000.10, 'CHF', 'CHF', '%s1,200,000.10'),
154 array(1200000.101, 'CHF', 'CHF', '%s1,200,000.10')
155 );
156 }
157
158 public function testFormat()
159 {
160 $errorCode = IntlGlobals::U_ZERO_ERROR;
161 $errorMessage = 'U_ZERO_ERROR';
162
163 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
164 $this->assertSame('9.555', $formatter->format(9.555));
165
166 $this->assertSame($errorMessage, $this->getIntlErrorMessage());
167 $this->assertSame($errorCode, $this->getIntlErrorCode());
168 $this->assertFalse($this->isIntlFailure($this->getIntlErrorCode()));
169 $this->assertSame($errorMessage, $formatter->getErrorMessage());
170 $this->assertSame($errorCode, $formatter->getErrorCode());
171 $this->assertFalse($this->isIntlFailure($formatter->getErrorCode()));
172 }
173
174 public function testFormatWithCurrencyStyle()
175 {
176 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
177 $this->assertEquals('¤1.00', $formatter->format(1));
178 }
179
180 /**
181 * @dataProvider formatTypeInt32Provider
182 */
183 public function testFormatTypeInt32($formatter, $value, $expected, $message = '')
184 {
185 $formattedValue = $formatter->format($value, NumberFormatter::TYPE_INT32);
186 $this->assertEquals($expected, $formattedValue, $message);
187 }
188
189 public function formatTypeInt32Provider()
190 {
191 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
192
193 $message = '->format() TYPE_INT32 formats inconsistently an integer if out of the 32 bit range.';
194
195 return array(
196 array($formatter, 1, '1'),
197 array($formatter, 1.1, '1'),
198 array($formatter, 2147483648, '-2,147,483,648', $message),
199 array($formatter, -2147483649, '2,147,483,647', $message),
200 );
201 }
202
203 /**
204 * @dataProvider formatTypeInt32WithCurrencyStyleProvider
205 */
206 public function testFormatTypeInt32WithCurrencyStyle($formatter, $value, $expected, $message = '')
207 {
208 $formattedValue = $formatter->format($value, NumberFormatter::TYPE_INT32);
209 $this->assertEquals($expected, $formattedValue, $message);
210 }
211
212 public function formatTypeInt32WithCurrencyStyleProvider()
213 {
214 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
215
216 $message = '->format() TYPE_INT32 formats inconsistently an integer if out of the 32 bit range.';
217
218 return array(
219 array($formatter, 1, '¤1.00'),
220 array($formatter, 1.1, '¤1.00'),
221 array($formatter, 2147483648, '(¤2,147,483,648.00)', $message),
222 array($formatter, -2147483649, '¤2,147,483,647.00', $message)
223 );
224 }
225
226 /**
227 * The parse() method works differently with integer out of the 32 bit range. format() works fine.
228 * @dataProvider formatTypeInt64Provider
229 */
230 public function testFormatTypeInt64($formatter, $value, $expected)
231 {
232 $formattedValue = $formatter->format($value, NumberFormatter::TYPE_INT64);
233 $this->assertEquals($expected, $formattedValue);
234 }
235
236 public function formatTypeInt64Provider()
237 {
238 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
239
240 return array(
241 array($formatter, 1, '1'),
242 array($formatter, 1.1, '1'),
243 array($formatter, 2147483648, '2,147,483,648'),
244 array($formatter, -2147483649, '-2,147,483,649'),
245 );
246 }
247
248 /**
249 * @dataProvider formatTypeInt64WithCurrencyStyleProvider
250 */
251 public function testFormatTypeInt64WithCurrencyStyle($formatter, $value, $expected)
252 {
253 $formattedValue = $formatter->format($value, NumberFormatter::TYPE_INT64);
254 $this->assertEquals($expected, $formattedValue);
255 }
256
257 public function formatTypeInt64WithCurrencyStyleProvider()
258 {
259 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
260
261 return array(
262 array($formatter, 1, '¤1.00'),
263 array($formatter, 1.1, '¤1.00'),
264 array($formatter, 2147483648, '¤2,147,483,648.00'),
265 array($formatter, -2147483649, '(¤2,147,483,649.00)')
266 );
267 }
268
269 /**
270 * @dataProvider formatTypeDoubleProvider
271 */
272 public function testFormatTypeDouble($formatter, $value, $expected)
273 {
274 $formattedValue = $formatter->format($value, NumberFormatter::TYPE_DOUBLE);
275 $this->assertEquals($expected, $formattedValue);
276 }
277
278 public function formatTypeDoubleProvider()
279 {
280 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
281
282 return array(
283 array($formatter, 1, '1'),
284 array($formatter, 1.1, '1.1'),
285 );
286 }
287
288 /**
289 * @dataProvider formatTypeDoubleWithCurrencyStyleProvider
290 */
291 public function testFormatTypeDoubleWithCurrencyStyle($formatter, $value, $expected)
292 {
293 $formattedValue = $formatter->format($value, NumberFormatter::TYPE_DOUBLE);
294 $this->assertEquals($expected, $formattedValue);
295 }
296
297 public function formatTypeDoubleWithCurrencyStyleProvider()
298 {
299 $formatter = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
300
301 return array(
302 array($formatter, 1, '¤1.00'),
303 array($formatter, 1.1, '¤1.10'),
304 );
305 }
306
307 /**
308 * @dataProvider formatTypeCurrencyProvider
309 * @expectedException \PHPUnit_Framework_Error_Warning
310 */
311 public function testFormatTypeCurrency($formatter, $value)
312 {
313 $formatter->format($value, NumberFormatter::TYPE_CURRENCY);
314 }
315
316 /**
317 * @dataProvider formatTypeCurrencyProvider
318 */
319 public function testFormatTypeCurrencyReturn($formatter, $value)
320 {
321 $this->assertFalse(@$formatter->format($value, NumberFormatter::TYPE_CURRENCY));
322 }
323
324 public function formatTypeCurrencyProvider()
325 {
326 $df = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
327 $cf = $this->getNumberFormatter('en', NumberFormatter::CURRENCY);
328
329 return array(
330 array($df, 1),
331 array($cf, 1),
332 );
333 }
334
335 /**
336 * @dataProvider formatFractionDigitsProvider
337 */
338 public function testFormatFractionDigits($value, $expected, $fractionDigits = null, $expectedFractionDigits = 1)
339 {
340 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
341
342 if (null !== $fractionDigits) {
343 $attributeRet = $formatter->setAttribute(NumberFormatter::FRACTION_DIGITS, $fractionDigits);
344 }
345
346 $formattedValue = $formatter->format($value);
347 $this->assertSame($expected, $formattedValue);
348 $this->assertSame($expectedFractionDigits, $formatter->getAttribute(NumberFormatter::FRACTION_DIGITS));
349
350 if (isset($attributeRet)) {
351 $this->assertTrue($attributeRet);
352 }
353 }
354
355 public function formatFractionDigitsProvider()
356 {
357 return array(
358 array(1.123, '1.123', null, 0),
359 array(1.123, '1', 0, 0),
360 array(1.123, '1.1', 1, 1),
361 array(1.123, '1.12', 2, 2),
362 array(1.123, '1', -1, 0),
363 array(1.123, '1', 'abc', 0)
364 );
365 }
366
367 /**
368 * @dataProvider formatGroupingUsedProvider
369 */
370 public function testFormatGroupingUsed($value, $expected, $groupingUsed = null, $expectedGroupingUsed = 1)
371 {
372 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
373
374 if (null !== $groupingUsed) {
375 $attributeRet = $formatter->setAttribute(NumberFormatter::GROUPING_USED, $groupingUsed);
376 }
377
378 $formattedValue = $formatter->format($value);
379 $this->assertSame($expected, $formattedValue);
380 $this->assertSame($expectedGroupingUsed, $formatter->getAttribute(NumberFormatter::GROUPING_USED));
381
382 if (isset($attributeRet)) {
383 $this->assertTrue($attributeRet);
384 }
385 }
386
387 public function formatGroupingUsedProvider()
388 {
389 return array(
390 array(1000, '1,000', null, 1),
391 array(1000, '1000', 0, 0),
392 array(1000, '1,000', 1, 1),
393 array(1000, '1,000', 2, 1),
394 array(1000, '1000', 'abc', 0),
395 array(1000, '1,000', -1, 1),
396 );
397 }
398
399 /**
400 * @dataProvider formatRoundingModeRoundHalfUpProvider
401 */
402 public function testFormatRoundingModeHalfUp($value, $expected)
403 {
404 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
405 $formatter->setAttribute(NumberFormatter::FRACTION_DIGITS, 2);
406
407 $formatter->setAttribute(NumberFormatter::ROUNDING_MODE, NumberFormatter::ROUND_HALFUP);
408 $this->assertSame($expected, $formatter->format($value), '->format() with ROUND_HALFUP rounding mode.');
409 }
410
411 public function formatRoundingModeRoundHalfUpProvider()
412 {
413 // The commented value is differently rounded by intl's NumberFormatter in 32 and 64 bit architectures
414 return array(
415 array(1.121, '1.12'),
416 array(1.123, '1.12'),
417 // array(1.125, '1.13'),
418 array(1.127, '1.13'),
419 array(1.129, '1.13'),
420 );
421 }
422
423 /**
424 * @dataProvider formatRoundingModeRoundHalfDownProvider
425 */
426 public function testFormatRoundingModeHalfDown($value, $expected)
427 {
428 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
429 $formatter->setAttribute(NumberFormatter::FRACTION_DIGITS, 2);
430
431 $formatter->setAttribute(NumberFormatter::ROUNDING_MODE, NumberFormatter::ROUND_HALFDOWN);
432 $this->assertSame($expected, $formatter->format($value), '->format() with ROUND_HALFDOWN rounding mode.');
433 }
434
435 public function formatRoundingModeRoundHalfDownProvider()
436 {
437 return array(
438 array(1.121, '1.12'),
439 array(1.123, '1.12'),
440 array(1.125, '1.12'),
441 array(1.127, '1.13'),
442 array(1.129, '1.13'),
443 );
444 }
445
446 /**
447 * @dataProvider formatRoundingModeRoundHalfEvenProvider
448 */
449 public function testFormatRoundingModeHalfEven($value, $expected)
450 {
451 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
452 $formatter->setAttribute(NumberFormatter::FRACTION_DIGITS, 2);
453
454 $formatter->setAttribute(NumberFormatter::ROUNDING_MODE, NumberFormatter::ROUND_HALFEVEN);
455 $this->assertSame($expected, $formatter->format($value), '->format() with ROUND_HALFEVEN rounding mode.');
456 }
457
458 public function formatRoundingModeRoundHalfEvenProvider()
459 {
460 return array(
461 array(1.121, '1.12'),
462 array(1.123, '1.12'),
463 array(1.125, '1.12'),
464 array(1.127, '1.13'),
465 array(1.129, '1.13'),
466 );
467 }
468
469 public function testGetLocale()
470 {
471 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
472 $this->assertEquals('en', $formatter->getLocale());
473 }
474
475 /**
476 * @dataProvider parseProvider
477 */
478 public function testParse($value, $expected, $message = '')
479 {
480 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
481 $parsedValue = $formatter->parse($value, NumberFormatter::TYPE_DOUBLE);
482 $this->assertSame($expected, $parsedValue, $message);
483
484 if ($expected === false) {
485 $errorCode = IntlGlobals::U_PARSE_ERROR;
486 $errorMessage = 'Number parsing failed: U_PARSE_ERROR';
487 } else {
488 $errorCode = IntlGlobals::U_ZERO_ERROR;
489 $errorMessage = 'U_ZERO_ERROR';
490 }
491
492 $this->assertSame($errorMessage, $this->getIntlErrorMessage());
493 $this->assertSame($errorCode, $this->getIntlErrorCode());
494 $this->assertSame($errorCode !== 0, $this->isIntlFailure($this->getIntlErrorCode()));
495 $this->assertSame($errorMessage, $formatter->getErrorMessage());
496 $this->assertSame($errorCode, $formatter->getErrorCode());
497 $this->assertSame($errorCode !== 0, $this->isIntlFailure($formatter->getErrorCode()));
498 }
499
500 public function parseProvider()
501 {
502 return array(
503 array('prefix1', false, '->parse() does not parse a number with a string prefix.'),
504 array('1suffix', (float) 1, '->parse() parses a number with a string suffix.'),
505 );
506 }
507
508 /**
509 * @expectedException \PHPUnit_Framework_Error_Warning
510 */
511 public function testParseTypeDefault()
512 {
513 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
514 $formatter->parse('1', NumberFormatter::TYPE_DEFAULT);
515 }
516
517 /**
518 * @dataProvider parseTypeInt32Provider
519 */
520 public function testParseTypeInt32($value, $expected, $message = '')
521 {
522 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
523 $parsedValue = $formatter->parse($value, NumberFormatter::TYPE_INT32);
524 $this->assertSame($expected, $parsedValue);
525 }
526
527 public function parseTypeInt32Provider()
528 {
529 return array(
530 array('1', 1),
531 array('1.1', 1),
532 array('2,147,483,647', 2147483647),
533 array('-2,147,483,648', -2147483647 - 1),
534 array('2,147,483,648', false, '->parse() TYPE_INT32 returns false when the number is greater than the integer positive range.'),
535 array('-2,147,483,649', false, '->parse() TYPE_INT32 returns false when the number is greater than the integer negative range.')
536 );
537 }
538
539 public function testParseTypeInt64With32BitIntegerInPhp32Bit()
540 {
541 IntlTestHelper::require32Bit($this);
542
543 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
544
545 $parsedValue = $formatter->parse('2,147,483,647', NumberFormatter::TYPE_INT64);
546 $this->assertInternalType('integer', $parsedValue);
547 $this->assertEquals(2147483647, $parsedValue);
548
549 $parsedValue = $formatter->parse('-2,147,483,648', NumberFormatter::TYPE_INT64);
550
551 // Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
552 // The negative PHP_INT_MAX was being converted to float
553 if (
554 (version_compare(PHP_VERSION, '5.4.0', '<') && version_compare(PHP_VERSION, '5.3.14', '>=')) ||
555 version_compare(PHP_VERSION, '5.4.4', '>=')
556 ) {
557 $this->assertInternalType('int', $parsedValue);
558 } else {
559 $this->assertInternalType('float', $parsedValue);
560 }
561
562 $this->assertEquals(-2147483648, $parsedValue);
563 }
564
565 public function testParseTypeInt64With32BitIntegerInPhp64Bit()
566 {
567 IntlTestHelper::require64Bit($this);
568
569 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
570
571 $parsedValue = $formatter->parse('2,147,483,647', NumberFormatter::TYPE_INT64);
572 $this->assertInternalType('integer', $parsedValue);
573 $this->assertEquals(2147483647, $parsedValue);
574
575 $parsedValue = $formatter->parse('-2,147,483,648', NumberFormatter::TYPE_INT64);
576 $this->assertInternalType('integer', $parsedValue);
577 $this->assertEquals(-2147483647 - 1, $parsedValue);
578 }
579
580 /**
581 * If PHP is compiled in 32bit mode, the returned value for a 64bit integer are float numbers.
582 */
583 public function testParseTypeInt64With64BitIntegerInPhp32Bit()
584 {
585 IntlTestHelper::require32Bit($this);
586
587 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
588
589 // int 64 using only 32 bit range strangeness
590 $parsedValue = $formatter->parse('2,147,483,648', NumberFormatter::TYPE_INT64);
591 $this->assertInternalType('float', $parsedValue);
592 $this->assertEquals(2147483648, $parsedValue, '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range.');
593
594 $parsedValue = $formatter->parse('-2,147,483,649', NumberFormatter::TYPE_INT64);
595 $this->assertInternalType('float', $parsedValue);
596 $this->assertEquals(-2147483649, $parsedValue, '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range.');
597 }
598
599 /**
600 * If PHP is compiled in 64bit mode, the returned value for a 64bit integer are 32bit integer numbers.
601 */
602 public function testParseTypeInt64With64BitIntegerInPhp64Bit()
603 {
604 IntlTestHelper::require64Bit($this);
605
606 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
607
608 $parsedValue = $formatter->parse('2,147,483,648', NumberFormatter::TYPE_INT64);
609 $this->assertInternalType('integer', $parsedValue);
610
611 // Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
612 // A 32 bit integer was being generated instead of a 64 bit integer
613 if (
614 (version_compare(PHP_VERSION, '5.3.14', '<')) ||
615 (version_compare(PHP_VERSION, '5.4.0', '>=') && version_compare(PHP_VERSION, '5.4.4', '<'))
616 ) {
617 $this->assertEquals(-2147483648, $parsedValue, '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range (PHP < 5.3.14 and PHP < 5.4.4).');
618 } else {
619 $this->assertEquals(2147483648, $parsedValue, '->parse() TYPE_INT64 uses true 64 bit integers (PHP >= 5.3.14 and PHP >= 5.4.4).');
620 }
621
622 $parsedValue = $formatter->parse('-2,147,483,649', NumberFormatter::TYPE_INT64);
623 $this->assertInternalType('integer', $parsedValue);
624
625 // Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
626 // A 32 bit integer was being generated instead of a 64 bit integer
627 if (
628 (version_compare(PHP_VERSION, '5.3.14', '<')) ||
629 (version_compare(PHP_VERSION, '5.4.0', '>=') && version_compare(PHP_VERSION, '5.4.4', '<'))
630 ) {
631 $this->assertEquals(2147483647, $parsedValue, '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range (PHP < 5.3.14 and PHP < 5.4.4).');
632 } else {
633 $this->assertEquals(-2147483649, $parsedValue, '->parse() TYPE_INT64 uses true 64 bit integers (PHP >= 5.3.14 and PHP >= 5.4.4).');
634 }
635 }
636
637 /**
638 * @dataProvider parseTypeDoubleProvider
639 */
640 public function testParseTypeDouble($value, $expectedValue)
641 {
642 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
643 $parsedValue = $formatter->parse($value, NumberFormatter::TYPE_DOUBLE);
644 $this->assertSame($expectedValue, $parsedValue);
645 }
646
647 public function parseTypeDoubleProvider()
648 {
649 return array(
650 array('1', (float) 1),
651 array('1.1', 1.1),
652 array('9,223,372,036,854,775,808', 9223372036854775808),
653 array('-9,223,372,036,854,775,809', -9223372036854775809),
654 );
655 }
656
657 /**
658 * @expectedException \PHPUnit_Framework_Error_Warning
659 */
660 public function testParseTypeCurrency()
661 {
662 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
663 $formatter->parse('1', NumberFormatter::TYPE_CURRENCY);
664 }
665
666 public function testParseWithNullPositionValue()
667 {
668 $position = null;
669 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
670 $formatter->parse('123', NumberFormatter::TYPE_INT32, $position);
671 $this->assertNull($position);
672 }
673
674 public function testParseWithNotNullPositionValue()
675 {
676 $position = 1;
677 $formatter = $this->getNumberFormatter('en', NumberFormatter::DECIMAL);
678 $formatter->parse('123', NumberFormatter::TYPE_DOUBLE, $position);
679 $this->assertEquals(3, $position);
680 }
681
682 /**
683 * @param string $locale
684 * @param null $style
685 * @param null $pattern
686 *
687 * @return \NumberFormatter
688 */
689 abstract protected function getNumberFormatter($locale = 'en', $style = null, $pattern = null);
690
691 /**
692 * @return string
693 */
694 abstract protected function getIntlErrorMessage();
695
696 /**
697 * @return integer
698 */
699 abstract protected function getIntlErrorCode();
700
701 /**
702 * @param integer $errorCode
703 *
704 * @return Boolean
705 */
706 abstract protected function isIntlFailure($errorCode);
707 }