2011-01-25 00:48:04 +00:00
< ? php
/*
* This file is part of the Symfony package .
*
2011-03-14 00:22:11 +00:00
* ( c ) Fabien Potencier < fabien @ symfony . com >
2011-01-25 00:48:04 +00:00
*
* For the full copyright and license information , please view the LICENSE
* file that was distributed with this source code .
*/
namespace Symfony\Tests\Component\Locale\Stub ;
require_once __DIR__ . '/../TestCase.php' ;
use Symfony\Component\Locale\Locale ;
2012-04-14 21:11:17 +01:00
use Symfony\Component\Locale\Stub\StubIntl ;
2011-01-25 00:48:04 +00:00
use Symfony\Component\Locale\Stub\StubNumberFormatter ;
use Symfony\Tests\Component\Locale\TestCase as LocaleTestCase ;
/**
* Note that there are some values written like - 2147483647 - 1. This is the lower 32 bit int max and is a known
* behavior of PHP .
*/
class StubNumberFormatterTest extends LocaleTestCase
{
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException
*/
public function testConstructorWithUnsupportedLocale ()
{
$formatter = new StubNumberFormatter ( 'pt_BR' );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException
*/
public function testConstructorWithUnsupportedStyle ()
{
$formatter = new StubNumberFormatter ( 'en' , StubNumberFormatter :: PATTERN_DECIMAL );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentNotImplementedException
*/
public function testConstructorWithPatternDifferentThanNull ()
{
$formatter = new StubNumberFormatter ( 'en' , StubNumberFormatter :: DECIMAL , '' );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException
*/
public function testSetAttributeWithUnsupportedAttribute ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> setAttribute ( StubNumberFormatter :: LENIENT_PARSE , null );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException
*/
public function testSetAttributeInvalidRoundingMode ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$ret = $formatter -> setAttribute ( StubNumberFormatter :: ROUNDING_MODE , null );
}
2011-02-21 01:03:37 +00:00
public function testCreateStub ()
{
$this -> assertInstanceOf (
'Symfony\Component\Locale\Stub\StubNumberFormatter' ,
StubNumberFormatter :: create ( 'en' , StubNumberFormatter :: DECIMAL )
);
}
public function testCreateIntl ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$this -> assertInstanceOf ( '\NumberFormatter' , \NumberFormatter :: create ( 'en' , \NumberFormatter :: DECIMAL ));
}
2011-01-25 00:48:04 +00:00
/**
* @ dataProvider formatCurrencyWithDecimalStyleProvider
*/
public function testFormatCurrencyWithDecimalStyleStub ( $value , $currency , $expected )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$this -> assertEquals ( $expected , $formatter -> formatCurrency ( $value , $currency ));
}
/**
* @ dataProvider formatCurrencyWithDecimalStyleProvider
*/
public function testFormatCurrencyWithDecimalStyleIntl ( $value , $currency , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$this -> assertEquals ( $expected , $formatter -> formatCurrency ( $value , $currency ));
}
public function formatCurrencyWithDecimalStyleProvider ()
{
return array (
array ( 100 , 'ALL' , '100' ),
array ( 100 , 'BRL' , '100.00' ),
array ( 100 , 'CRC' , '100' ),
array ( 100 , 'JPY' , '100' ),
array ( 100 , 'CHF' , '100' ),
array ( - 100 , 'ALL' , '-100' ),
array ( - 100 , 'BRL' , '-100' ),
array ( - 100 , 'CRC' , '-100' ),
array ( - 100 , 'JPY' , '-100' ),
array ( - 100 , 'CHF' , '-100' ),
array ( 1000.12 , 'ALL' , '1,000.12' ),
array ( 1000.12 , 'BRL' , '1,000.12' ),
array ( 1000.12 , 'CRC' , '1,000.12' ),
array ( 1000.12 , 'JPY' , '1,000.12' ),
array ( 1000.12 , 'CHF' , '1,000.12' )
);
}
/**
* @ dataProvider formatCurrencyWithCurrencyStyleProvider
*/
public function testFormatCurrencyWithCurrencyStyleStub ( $value , $currency , $expected )
{
$formatter = $this -> getStubFormatterWithCurrencyStyle ();
$this -> assertEquals ( $expected , $formatter -> formatCurrency ( $value , $currency ));
}
/**
* @ dataProvider formatCurrencyWithCurrencyStyleProvider
*/
public function testFormatCurrencyWithCurrencyStyleIntl ( $value , $currency , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2011-04-02 14:17:16 +01:00
$this -> skipIfICUVersionIsTooOld ();
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithCurrencyStyle ();
$this -> assertEquals ( $expected , $formatter -> formatCurrency ( $value , $currency ));
}
public function formatCurrencyWithCurrencyStyleProvider ()
{
return array (
array ( 100 , 'ALL' , 'ALL100' ),
array ( - 100 , 'ALL' , '(ALL100)' ),
array ( 1000.12 , 'ALL' , 'ALL1,000' ),
array ( 100 , 'BRL' , 'R$100.00' ),
array ( - 100 , 'BRL' , '(R$100.00)' ),
array ( 1000.12 , 'BRL' , 'R$1,000.12' ),
array ( 100 , 'CRC' , '₡100' ),
array ( - 100 , 'CRC' , '(₡100)' ),
array ( 1000.12 , 'CRC' , '₡1,000' ),
array ( 100 , 'JPY' , '¥100' ),
array ( - 100 , 'JPY' , '(¥100)' ),
array ( 1000.12 , 'JPY' , '¥1,000' ),
2011-05-07 17:22:40 +01:00
array ( 100 , 'EUR' , '€100.00' ),
array ( - 100 , 'EUR' , '(€100.00)' ),
array ( 1000.12 , 'EUR' , '€1,000.12' ),
2011-01-25 00:48:04 +00:00
// Rounding checks
array ( 1000.121 , 'BRL' , 'R$1,000.12' ),
array ( 1000.123 , 'BRL' , 'R$1,000.12' ),
array ( 1000.125 , 'BRL' , 'R$1,000.12' ),
array ( 1000.127 , 'BRL' , 'R$1,000.13' ),
array ( 1000.129 , 'BRL' , 'R$1,000.13' ),
2011-05-07 17:22:40 +01:00
array ( 11.50999 , 'BRL' , 'R$11.51' ),
array ( 11.9999464 , 'BRL' , 'R$12.00' )
2011-01-25 00:48:04 +00:00
);
}
/**
* @ dataProvider formatCurrencyWithCurrencyStyleSwissRoundingProvider
*/
public function testFormatCurrencyWithCurrencyStyleSwissRoundingStub ( $value , $currency , $symbol , $expected )
{
$formatter = $this -> getStubFormatterWithCurrencyStyle ();
$this -> assertEquals ( sprintf ( $expected , 'CHF' ), $formatter -> formatCurrency ( $value , $currency ));
}
/**
* @ dataProvider formatCurrencyWithCurrencyStyleSwissRoundingProvider
*/
public function testFormatCurrencyWithCurrencyStyleSwissRoundingIntl ( $value , $currency , $symbol , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2011-04-02 14:17:16 +01:00
$this -> skipIfICUVersionIsTooOld ();
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithCurrencyStyle ();
$this -> assertEquals ( sprintf ( $expected , $symbol ), $formatter -> formatCurrency ( $value , $currency ));
}
public function formatCurrencyWithCurrencyStyleSwissRoundingProvider ()
{
// The currency symbol was updated from 4.2 to the 4.4 version. The ICU CLDR data was updated in 2010-03-03,
// the 4.2 release is from 2009-05-08 and the 4.4 from 2010-03-17. It's ugly we want to compare if the
// stub implementation is behaving like the intl one
// http://bugs.icu-project.org/trac/changeset/27776/icu/trunk/source/data/curr/en.txt
2011-03-01 05:24:19 +00:00
$chf = $this -> isIntlExtensionLoaded () && $this -> isLowerThanIcuVersion ( '4.4' ) ? 'Fr.' : 'CHF' ;
2011-01-25 00:48:04 +00:00
return array (
array ( 100 , 'CHF' , $chf , '%s100.00' ),
array ( - 100 , 'CHF' , $chf , '(%s100.00)' ),
array ( 1000.12 , 'CHF' , $chf , '%s1,000.10' ),
2011-05-07 17:22:40 +01:00
array ( '1000.12' , 'CHF' , $chf , '%s1,000.10' ),
2011-01-25 00:48:04 +00:00
// Rounding checks
array ( 1000.121 , 'CHF' , $chf , '%s1,000.10' ),
array ( 1000.123 , 'CHF' , $chf , '%s1,000.10' ),
array ( 1000.125 , 'CHF' , $chf , '%s1,000.10' ),
array ( 1000.127 , 'CHF' , $chf , '%s1,000.15' ),
2011-05-07 17:22:40 +01:00
array ( 1000.129 , 'CHF' , $chf , '%s1,000.15' ),
array ( 1200000.00 , 'CHF' , $chf , '%s1,200,000.00' ),
array ( 1200000.1 , 'CHF' , $chf , '%s1,200,000.10' ),
array ( 1200000.10 , 'CHF' , $chf , '%s1,200,000.10' ),
array ( 1200000.101 , 'CHF' , $chf , '%s1,200,000.10' )
2011-01-25 00:48:04 +00:00
);
}
public function testFormatStub ()
{
2012-04-15 23:28:47 +01:00
$errorCode = StubIntl :: U_ZERO_ERROR ;
$errorMessage = 'U_ZERO_ERROR' ;
2011-01-25 00:48:04 +00:00
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$this -> assertSame ( '9.555' , $formatter -> format ( 9.555 ));
2012-04-15 23:28:47 +01:00
$this -> assertSame ( $errorMessage , StubIntl :: getErrorMessage ());
$this -> assertSame ( $errorCode , StubIntl :: getErrorCode ());
2012-04-16 00:23:02 +01:00
$this -> assertFalse ( StubIntl :: isFailure ( StubIntl :: getErrorCode ()));
2012-04-15 23:28:47 +01:00
$this -> assertSame ( $errorMessage , $formatter -> getErrorMessage ());
$this -> assertSame ( $errorCode , $formatter -> getErrorCode ());
2012-04-16 00:23:02 +01:00
$this -> assertFalse ( StubIntl :: isFailure ( $formatter -> getErrorCode ()));
2011-01-25 00:48:04 +00:00
}
public function testFormatIntl ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2012-04-15 23:28:47 +01:00
$errorCode = StubIntl :: U_ZERO_ERROR ;
$errorMessage = 'U_ZERO_ERROR' ;
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$this -> assertSame ( '9.555' , $formatter -> format ( 9.555 ));
2012-04-15 23:28:47 +01:00
$this -> assertSame ( $errorMessage , intl_get_error_message ());
$this -> assertSame ( $errorCode , intl_get_error_code ());
2012-04-16 00:23:02 +01:00
$this -> assertFalse ( intl_is_failure ( intl_get_error_code ()));
2012-04-15 23:28:47 +01:00
$this -> assertSame ( $errorMessage , $formatter -> getErrorMessage ());
$this -> assertSame ( $errorCode , $formatter -> getErrorCode ());
2012-04-16 00:23:02 +01:00
$this -> assertFalse ( intl_is_failure ( $formatter -> getErrorCode ()));
2011-01-25 00:48:04 +00:00
}
/**
* @ expectedException RuntimeException
*/
public function testFormatWithCurrencyStyleStub ()
{
$formatter = $this -> getStubFormatterWithCurrencyStyle ();
$formatter -> format ( 1 );
}
public function testFormatWithCurrencyStyleIntl ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithCurrencyStyle ();
$formatter -> setSymbol ( \NumberFormatter :: CURRENCY_SYMBOL , 'SFD' );
$this -> assertEquals ( 'SFD1.00' , $formatter -> format ( 1 ));
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException
*/
public function testFormatTypeInt32Stub ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> format ( 1 , StubNumberFormatter :: TYPE_INT32 );
}
/**
* @ dataProvider formatTypeInt32Provider
*/
public function testFormatTypeInt32Intl ( $formatter , $value , $expected , $message = '' )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formattedValue = $formatter -> format ( $value , \NumberFormatter :: TYPE_INT32 );
$this -> assertEquals ( $expected , $formattedValue , $message );
}
public function formatTypeInt32Provider ()
{
$df = $this -> getIntlFormatterWithDecimalStyle ();
$cf = $this -> getIntlFormatterWithCurrencyStyle ();
$message = '->format() TYPE_INT32 formats inconsistently an integer if out of the 32 bit range.' ;
return array (
array ( $df , 1 , '1' ),
array ( $df , 1.1 , '1' ),
array ( $df , 2147483648 , '-2,147,483,648' , $message ),
array ( $df , - 2147483649 , '2,147,483,647' , $message ),
array ( $cf , 1 , 'SFD1.00' ),
array ( $cf , 1.1 , 'SFD1.00' ),
array ( $cf , 2147483648 , '(SFD2,147,483,648.00)' , $message ),
array ( $cf , - 2147483649 , 'SFD2,147,483,647.00' , $message )
);
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException
*/
public function testFormatTypeInt64Stub ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> format ( 1 , StubNumberFormatter :: TYPE_INT64 );
}
/**
* The parse () method works differently with integer out of the 32 bit range . format () works fine .
* @ dataProvider formatTypeInt64Provider
*/
public function testFormatTypeInt64Intl ( $formatter , $value , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formattedValue = $formatter -> format ( $value , \NumberFormatter :: TYPE_INT64 );
$this -> assertEquals ( $expected , $formattedValue );
}
public function formatTypeInt64Provider ()
{
$df = $this -> getIntlFormatterWithDecimalStyle ();
$cf = $this -> getIntlFormatterWithCurrencyStyle ();
return array (
array ( $df , 1 , '1' ),
array ( $df , 1.1 , '1' ),
array ( $df , 2147483648 , '2,147,483,648' ),
array ( $df , - 2147483649 , '-2,147,483,649' ),
array ( $cf , 1 , 'SFD1.00' ),
array ( $cf , 1.1 , 'SFD1.00' ),
array ( $cf , 2147483648 , 'SFD2,147,483,648.00' ),
array ( $cf , - 2147483649 , '(SFD2,147,483,649.00)' )
);
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException
*/
public function testFormatTypeDoubleStub ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> format ( 1 , StubNumberFormatter :: TYPE_DOUBLE );
}
/**
* @ dataProvider formatTypeDoubleProvider
*/
public function testFormatTypeDoubleIntl ( $formatter , $value , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formattedValue = $formatter -> format ( $value , \NumberFormatter :: TYPE_DOUBLE );
$this -> assertEquals ( $expected , $formattedValue );
}
public function formatTypeDoubleProvider ()
{
$df = $this -> getIntlFormatterWithDecimalStyle ();
$cf = $this -> getIntlFormatterWithCurrencyStyle ();
return array (
array ( $df , 1 , '1' ),
array ( $df , 1.1 , '1.1' ),
array ( $cf , 1 , 'SFD1.00' ),
array ( $cf , 1.1 , 'SFD1.10' ),
);
}
/**
* @ expectedException PHPUnit_Framework_Error_Warning
*/
public function testFormatTypeCurrencyStub ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> format ( 1 , StubNumberFormatter :: TYPE_CURRENCY );
}
2011-05-07 17:42:40 +01:00
public function testFormatTypeCurrencyReturnStub ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$this -> assertFalse ( @ $formatter -> format ( 1 , StubNumberFormatter :: TYPE_CURRENCY ));
}
2011-01-25 00:48:04 +00:00
/**
* @ dataProvider formatTypeCurrencyProvider
* @ expectedException PHPUnit_Framework_Error_Warning
*/
public function testFormatTypeCurrencyIntl ( $formatter , $value )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formattedValue = $formatter -> format ( $value , \NumberFormatter :: TYPE_CURRENCY );
}
public function formatTypeCurrencyProvider ()
{
$df = $this -> getIntlFormatterWithDecimalStyle ();
$cf = $this -> getIntlFormatterWithCurrencyStyle ();
return array (
array ( $df , 1 ),
array ( $df , 1 ),
);
}
/**
* @ dataProvider formatFractionDigitsProvider
*/
public function testFormatFractionDigitsStub ( $value , $expected , $fractionDigits = null , $expectedFractionDigits = 1 )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
2011-04-07 08:45:39 +01:00
if ( null !== $fractionDigits ) {
2011-01-25 00:48:04 +00:00
$attributeRet = $formatter -> setAttribute ( StubNumberFormatter :: FRACTION_DIGITS , $fractionDigits );
}
$formattedValue = $formatter -> format ( $value );
$this -> assertSame ( $expected , $formattedValue );
$this -> assertSame ( $expectedFractionDigits , $formatter -> getAttribute ( StubNumberFormatter :: FRACTION_DIGITS ));
if ( isset ( $attributeRet )) {
$this -> assertTrue ( $attributeRet );
}
}
/**
* @ dataProvider formatFractionDigitsProvider
*/
public function testFormatFractionDigitsIntl ( $value , $expected , $fractionDigits = null , $expectedFractionDigits = 1 )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
2011-04-07 08:45:39 +01:00
if ( null !== $fractionDigits ) {
2011-01-25 00:48:04 +00:00
$attributeRet = $formatter -> setAttribute ( \NumberFormatter :: FRACTION_DIGITS , $fractionDigits );
}
$formattedValue = $formatter -> format ( $value );
$this -> assertSame ( $expected , $formattedValue );
$this -> assertSame ( $expectedFractionDigits , $formatter -> getAttribute ( \NumberFormatter :: FRACTION_DIGITS ));
if ( isset ( $attributeRet )) {
$this -> assertTrue ( $attributeRet );
}
}
public function formatFractionDigitsProvider ()
{
return array (
array ( 1.123 , '1.123' , null , 0 ),
array ( 1.123 , '1' , 0 , 0 ),
array ( 1.123 , '1.1' , 1 , 1 ),
array ( 1.123 , '1.12' , 2 , 2 ),
array ( 1.123 , '1' , - 1 , 0 ),
array ( 1.123 , '1' , 'abc' , 0 )
);
}
/**
* @ dataProvider formatGroupingUsedProvider
*/
public function testFormatGroupingUsedStub ( $value , $expected , $groupingUsed = null , $expectedGroupingUsed = 1 )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
2011-04-07 08:45:39 +01:00
if ( null !== $groupingUsed ) {
2011-01-25 00:48:04 +00:00
$attributeRet = $formatter -> setAttribute ( StubNumberFormatter :: GROUPING_USED , $groupingUsed );
}
$formattedValue = $formatter -> format ( $value );
$this -> assertSame ( $expected , $formattedValue );
$this -> assertSame ( $expectedGroupingUsed , $formatter -> getAttribute ( StubNumberFormatter :: GROUPING_USED ));
if ( isset ( $attributeRet )) {
$this -> assertTrue ( $attributeRet );
}
}
/**
* @ dataProvider formatGroupingUsedProvider
*/
public function testFormatGroupingUsedIntl ( $value , $expected , $groupingUsed = null , $expectedGroupingUsed = 1 )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
2011-04-07 08:45:39 +01:00
if ( null !== $groupingUsed ) {
2011-01-25 00:48:04 +00:00
$attributeRet = $formatter -> setAttribute ( \NumberFormatter :: GROUPING_USED , $groupingUsed );
}
$formattedValue = $formatter -> format ( $value );
$this -> assertSame ( $expected , $formattedValue );
$this -> assertSame ( $expectedGroupingUsed , $formatter -> getAttribute ( \NumberFormatter :: GROUPING_USED ));
if ( isset ( $attributeRet )) {
$this -> assertTrue ( $attributeRet );
}
}
public function formatGroupingUsedProvider ()
{
return array (
array ( 1000 , '1,000' , null , 1 ),
array ( 1000 , '1000' , 0 , 0 ),
array ( 1000 , '1,000' , 1 , 1 ),
array ( 1000 , '1,000' , 2 , 1 ),
array ( 1000 , '1000' , 'abc' , 0 ),
array ( 1000 , '1,000' , - 1 , 1 ),
);
}
/**
* @ dataProvider formatRoundingModeRoundHalfUpProvider
*/
public function testFormatRoundingModeStubRoundHalfUp ( $value , $expected )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> setAttribute ( StubNumberFormatter :: FRACTION_DIGITS , 2 );
$formatter -> setAttribute ( StubNumberFormatter :: ROUNDING_MODE , StubNumberFormatter :: ROUND_HALFUP );
$this -> assertSame ( $expected , $formatter -> format ( $value ), '->format() with ROUND_HALFUP rounding mode.' );
}
/**
* @ dataProvider formatRoundingModeRoundHalfUpProvider
*/
public function testFormatRoundingModeHalfUpIntl ( $value , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$formatter -> setAttribute ( \NumberFormatter :: FRACTION_DIGITS , 2 );
$formatter -> setAttribute ( \NumberFormatter :: ROUNDING_MODE , \NumberFormatter :: ROUND_HALFUP );
$this -> assertSame ( $expected , $formatter -> format ( $value ), '->format() with ROUND_HALFUP rounding mode.' );
}
public function formatRoundingModeRoundHalfUpProvider ()
{
// The commented value is differently rounded by intl's NumberFormatter in 32 and 64 bit architectures
return array (
array ( 1.121 , '1.12' ),
array ( 1.123 , '1.12' ),
// array(1.125, '1.13'),
array ( 1.127 , '1.13' ),
array ( 1.129 , '1.13' ),
);
}
/**
* @ dataProvider formatRoundingModeRoundHalfDownProvider
*/
public function testFormatRoundingModeStubRoundHalfDown ( $value , $expected )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> setAttribute ( StubNumberFormatter :: FRACTION_DIGITS , 2 );
$formatter -> setAttribute ( StubNumberFormatter :: ROUNDING_MODE , StubNumberFormatter :: ROUND_HALFDOWN );
$this -> assertSame ( $expected , $formatter -> format ( $value ), '->format() with ROUND_HALFDOWN rounding mode.' );
}
/**
* @ dataProvider formatRoundingModeRoundHalfDownProvider
*/
public function testFormatRoundingModeHalfDownIntl ( $value , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$formatter -> setAttribute ( \NumberFormatter :: FRACTION_DIGITS , 2 );
$formatter -> setAttribute ( \NumberFormatter :: ROUNDING_MODE , \NumberFormatter :: ROUND_HALFDOWN );
$this -> assertSame ( $expected , $formatter -> format ( $value ), '->format() with ROUND_HALFDOWN rounding mode.' );
}
public function formatRoundingModeRoundHalfDownProvider ()
{
return array (
array ( 1.121 , '1.12' ),
array ( 1.123 , '1.12' ),
array ( 1.125 , '1.12' ),
array ( 1.127 , '1.13' ),
array ( 1.129 , '1.13' ),
);
}
/**
* @ dataProvider formatRoundingModeRoundHalfEvenProvider
*/
public function testFormatRoundingModeStubRoundHalfEven ( $value , $expected )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> setAttribute ( StubNumberFormatter :: FRACTION_DIGITS , 2 );
$formatter -> setAttribute ( StubNumberFormatter :: ROUNDING_MODE , StubNumberFormatter :: ROUND_HALFEVEN );
$this -> assertSame ( $expected , $formatter -> format ( $value ), '->format() with ROUND_HALFEVEN rounding mode.' );
}
/**
* @ dataProvider formatRoundingModeRoundHalfEvenProvider
*/
public function testFormatRoundingModeHalfEvenIntl ( $value , $expected )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$formatter -> setAttribute ( \NumberFormatter :: FRACTION_DIGITS , 2 );
$formatter -> setAttribute ( \NumberFormatter :: ROUNDING_MODE , \NumberFormatter :: ROUND_HALFEVEN );
$this -> assertSame ( $expected , $formatter -> format ( $value ), '->format() with ROUND_HALFEVEN rounding mode.' );
}
public function formatRoundingModeRoundHalfEvenProvider ()
{
return array (
array ( 1.121 , '1.12' ),
array ( 1.123 , '1.12' ),
array ( 1.125 , '1.12' ),
array ( 1.127 , '1.13' ),
array ( 1.129 , '1.13' ),
);
}
public function testGetErrorCode ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
2012-04-14 21:11:17 +01:00
$this -> assertEquals ( StubIntl :: U_ZERO_ERROR , $formatter -> getErrorCode ());
2011-01-25 00:48:04 +00:00
}
public function testGetLocale ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
2011-02-21 01:08:36 +00:00
$this -> assertEquals ( 'en' , $formatter -> getLocale ());
2011-01-25 00:48:04 +00:00
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodNotImplementedException
*/
public function testGetPattern ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> getPattern ();
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodNotImplementedException
*/
public function testGetSymbol ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> getSymbol ( null );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodNotImplementedException
*/
public function testGetTextAttribute ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> getTextAttribute ( null );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodNotImplementedException
*/
public function testParseCurrency ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> parseCurrency ( null , $currency );
}
/**
* @ dataProvider parseProvider
*/
public function testParseStub ( $value , $expected , $message = '' )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( $value , StubNumberFormatter :: TYPE_DOUBLE );
$this -> assertSame ( $expected , $parsedValue , $message );
2011-10-30 21:52:19 +00:00
if ( $expected === false ) {
2012-04-15 23:08:47 +01:00
$errorCode = StubIntl :: U_PARSE_ERROR ;
$errorMessage = 'Number parsing failed: U_PARSE_ERROR' ;
2011-10-30 21:52:19 +00:00
} else {
2012-04-15 23:08:47 +01:00
$errorCode = StubIntl :: U_ZERO_ERROR ;
$errorMessage = 'U_ZERO_ERROR' ;
2011-10-30 21:52:19 +00:00
}
2012-04-15 23:08:47 +01:00
$this -> assertSame ( $errorMessage , StubIntl :: getErrorMessage ());
$this -> assertSame ( $errorCode , StubIntl :: getErrorCode ());
2012-04-16 00:23:02 +01:00
$this -> assertSame ( $errorCode !== 0 , StubIntl :: isFailure ( StubIntl :: getErrorCode ()));
2012-04-15 23:08:47 +01:00
$this -> assertSame ( $errorMessage , $formatter -> getErrorMessage ());
$this -> assertSame ( $errorCode , $formatter -> getErrorCode ());
2012-04-16 00:23:02 +01:00
$this -> assertSame ( $errorCode !== 0 , StubIntl :: isFailure ( $formatter -> getErrorCode ()));
2011-01-25 00:48:04 +00:00
}
/**
* @ dataProvider parseProvider
*/
public function testParseIntl ( $value , $expected , $message = '' )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2011-04-02 14:17:16 +01:00
$this -> skipIfICUVersionIsTooOld ();
2012-04-15 23:08:47 +01:00
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( $value , \NumberFormatter :: TYPE_DOUBLE );
$this -> assertSame ( $expected , $parsedValue , $message );
2011-10-30 21:52:19 +00:00
if ( $expected === false ) {
2012-04-15 23:08:47 +01:00
$errorCode = StubIntl :: U_PARSE_ERROR ;
$errorMessage = 'Number parsing failed: U_PARSE_ERROR' ;
2011-10-30 21:52:19 +00:00
} else {
2012-04-15 23:08:47 +01:00
$errorCode = StubIntl :: U_ZERO_ERROR ;
$errorMessage = 'U_ZERO_ERROR' ;
2011-10-30 21:52:19 +00:00
}
2012-04-15 23:08:47 +01:00
$this -> assertSame ( $errorMessage , intl_get_error_message ());
$this -> assertSame ( $errorCode , intl_get_error_code ());
2012-04-16 00:23:02 +01:00
$this -> assertSame ( $errorCode > 0 , intl_is_failure ( intl_get_error_code ()));
2012-04-15 23:08:47 +01:00
$this -> assertSame ( $errorMessage , $formatter -> getErrorMessage ());
$this -> assertSame ( $errorCode , $formatter -> getErrorCode ());
2012-04-16 00:23:02 +01:00
$this -> assertSame ( $errorCode > 0 , intl_is_failure ( $formatter -> getErrorCode ()));
2011-01-25 00:48:04 +00:00
}
public function parseProvider ()
{
return array (
array ( 'prefix1' , false , '->parse() does not parse a number with a string prefix.' ),
array ( '1suffix' , ( float ) 1 , '->parse() parses a number with a string suffix.' ),
);
}
/**
* @ expectedException PHPUnit_Framework_Error_Warning
*/
public function testParseTypeDefaultStub ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> parse ( '1' , StubNumberFormatter :: TYPE_DEFAULT );
}
/**
* @ expectedException PHPUnit_Framework_Error_Warning
*/
public function testParseTypeDefaultIntl ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$formatter -> parse ( '1' , \NumberFormatter :: TYPE_DEFAULT );
}
/**
* @ dataProvider parseTypeInt32Provider
*/
public function testParseTypeInt32Stub ( $value , $expected , $message = '' )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( $value , StubNumberFormatter :: TYPE_INT32 );
$this -> assertSame ( $expected , $parsedValue );
}
/**
* @ dataProvider parseTypeInt32Provider
*/
public function testParseTypeInt32Intl ( $value , $expected , $message = '' )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( $value , \NumberFormatter :: TYPE_INT32 );
$this -> assertSame ( $expected , $parsedValue );
}
public function parseTypeInt32Provider ()
{
return array (
array ( '1' , 1 ),
array ( '1.1' , 1 ),
array ( '2,147,483,647' , 2147483647 ),
array ( '-2,147,483,648' , - 2147483647 - 1 ),
array ( '2,147,483,648' , false , '->parse() TYPE_INT32 returns false when the number is greater than the integer positive range.' ),
array ( '-2,147,483,649' , false , '->parse() TYPE_INT32 returns false when the number is greater than the integer negative range.' )
);
}
2011-12-11 16:45:39 +00:00
// Stub Tests
public function testParseTypeInt64StubWith32BitIntegerInPhp32Bit ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$this -> skipIfNot32Bit ();
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( '2,147,483,647' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
$this -> assertEquals ( 2147483647 , $parsedValue );
$parsedValue = $formatter -> parse ( '-2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
2012-07-09 02:15:42 +01:00
// Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
// The negative PHP_INT_MAX was being converted to float
if (
( version_compare ( PHP_VERSION , '5.4.0' , '<' ) && version_compare ( PHP_VERSION , '5.3.14' , '>=' )) ||
version_compare ( PHP_VERSION , '5.4.4' , '>=' )
) {
$this -> assertInternalType ( 'int' , $parsedValue );
} else {
$this -> assertInternalType ( 'float' , $parsedValue );
}
$this -> assertEquals ( - 2147483648 , $parsedValue );
2011-12-11 16:45:39 +00:00
}
public function testParseTypeInt64StubWith32BitIntegerInPhp64Bit ()
{
$this -> skipIfNot64Bit ();
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( '2,147,483,647' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
$this -> assertEquals ( 2147483647 , $parsedValue );
$parsedValue = $formatter -> parse ( '-2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
$this -> assertEquals ( - 2147483647 - 1 , $parsedValue );
}
2011-01-25 00:48:04 +00:00
/**
2011-12-11 16:45:39 +00:00
* If PHP is compiled in 32 bit mode , the returned value for a 64 bit integer are float numbers .
*/
public function testParseTypeInt64StubWith64BitIntegerInPhp32Bit ()
{
$this -> skipIfNot32Bit ();
$formatter = $this -> getStubFormatterWithDecimalStyle ();
// int 64 using only 32 bit range strangeness
$parsedValue = $formatter -> parse ( '2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'float' , $parsedValue );
$this -> assertEquals ( 2147483648 , $parsedValue , '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range.' );
$parsedValue = $formatter -> parse ( '-2,147,483,649' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'float' , $parsedValue );
$this -> assertEquals ( - 2147483649 , $parsedValue , '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range.' );
}
/**
* If PHP is compiled in 64 bit mode , the returned value for a 64 bit integer are 32 bit integer numbers .
2011-01-25 00:48:04 +00:00
*/
2011-12-11 16:45:39 +00:00
public function testParseTypeInt64StubWith64BitIntegerInPhp64Bit ()
2011-01-25 00:48:04 +00:00
{
2011-12-11 16:45:39 +00:00
$this -> skipIfNot64Bit ();
2011-01-25 00:48:04 +00:00
$formatter = $this -> getStubFormatterWithDecimalStyle ();
2011-12-11 16:45:39 +00:00
$parsedValue = $formatter -> parse ( '2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
2012-07-09 02:15:42 +01:00
// Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
// A 32 bit integer was being generated instead of a 64 bit integer
if (
( version_compare ( PHP_VERSION , '5.3.14' , '<' )) ||
( version_compare ( PHP_VERSION , '5.4.0' , '>=' ) && version_compare ( PHP_VERSION , '5.4.4' , '<' ))
) {
$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).' );
} else {
$this -> assertEquals ( 2147483648 , $parsedValue , '->parse() TYPE_INT64 uses true 64 bit integers (PHP >= 5.3.14 and PHP >= 5.4.4).' );
}
2011-12-11 16:45:39 +00:00
$parsedValue = $formatter -> parse ( '-2,147,483,649' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
2012-07-09 02:15:42 +01:00
// Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
// A 32 bit integer was being generated instead of a 64 bit integer
if (
( version_compare ( PHP_VERSION , '5.3.14' , '<' )) ||
( version_compare ( PHP_VERSION , '5.4.0' , '>=' ) && version_compare ( PHP_VERSION , '5.4.4' , '<' ))
) {
$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).' );
} else {
$this -> assertEquals ( - 2147483649 , $parsedValue , '->parse() TYPE_INT64 uses true 64 bit integers (PHP >= 5.3.14 and PHP >= 5.4.4).' );
}
2011-01-25 00:48:04 +00:00
}
2011-12-11 16:45:39 +00:00
// Intl Tests
2011-01-25 00:48:04 +00:00
public function testParseTypeInt64IntlWith32BitIntegerInPhp32Bit ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2011-12-11 16:45:39 +00:00
$this -> skipIfNot32Bit ();
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( '2,147,483,647' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
$this -> assertEquals ( 2147483647 , $parsedValue );
$parsedValue = $formatter -> parse ( '-2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
2012-07-09 02:15:42 +01:00
// Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
// The negative PHP_INT_MAX was being converted to float.
if (
( version_compare ( PHP_VERSION , '5.4.0' , '<' ) && version_compare ( PHP_VERSION , '5.3.14' , '>=' )) ||
version_compare ( PHP_VERSION , '5.4.4' , '>=' )
) {
$this -> assertInternalType ( 'int' , $parsedValue );
} else {
$this -> assertInternalType ( 'float' , $parsedValue );
}
$this -> assertEquals ( - 2147483648 , $parsedValue );
2011-01-25 00:48:04 +00:00
}
public function testParseTypeInt64IntlWith32BitIntegerInPhp64Bit ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2011-12-11 16:45:39 +00:00
$this -> skipIfNot64Bit ();
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( '2,147,483,647' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
$this -> assertEquals ( 2147483647 , $parsedValue );
$parsedValue = $formatter -> parse ( '-2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
$this -> assertEquals ( - 2147483647 - 1 , $parsedValue );
}
/**
* If PHP is compiled in 32 bit mode , the returned value for a 64 bit integer are float numbers .
*/
public function testParseTypeInt64IntlWith64BitIntegerInPhp32Bit ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2011-12-11 16:45:39 +00:00
$this -> skipIfNot32Bit ();
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
// int 64 using only 32 bit range strangeness
$parsedValue = $formatter -> parse ( '2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'float' , $parsedValue );
$this -> assertEquals ( 2147483648 , $parsedValue , '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range.' );
$parsedValue = $formatter -> parse ( '-2,147,483,649' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'float' , $parsedValue );
$this -> assertEquals ( - 2147483649 , $parsedValue , '->parse() TYPE_INT64 does not use true 64 bit integers, using only the 32 bit range.' );
}
/**
* If PHP is compiled in 64 bit mode , the returned value for a 64 bit integer are 32 bit integer numbers .
*/
public function testParseTypeInt64IntlWith64BitIntegerInPhp64Bit ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
2011-12-11 16:45:39 +00:00
$this -> skipIfNot64Bit ();
2011-01-25 00:48:04 +00:00
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( '2,147,483,648' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
2012-07-09 02:15:42 +01:00
// Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
// A 32 bit integer was being generated instead of a 64 bit integer
if (
( version_compare ( PHP_VERSION , '5.3.14' , '<' )) ||
( version_compare ( PHP_VERSION , '5.4.0' , '>=' ) && version_compare ( PHP_VERSION , '5.4.4' , '<' ))
) {
$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).' );
} else {
$this -> assertEquals ( 2147483648 , $parsedValue , '->parse() TYPE_INT64 uses true 64 bit integers (PHP >= 5.3.14 and PHP >= 5.4.4).' );
}
2011-01-25 00:48:04 +00:00
$parsedValue = $formatter -> parse ( '-2,147,483,649' , \NumberFormatter :: TYPE_INT64 );
$this -> assertInternalType ( 'integer' , $parsedValue );
2012-07-09 02:15:42 +01:00
// Bug #59597 was fixed on PHP 5.3.14 and 5.4.4
// A 32 bit integer was being generated instead of a 64 bit integer
if (
( version_compare ( PHP_VERSION , '5.3.14' , '<' )) ||
( version_compare ( PHP_VERSION , '5.4.0' , '>=' ) && version_compare ( PHP_VERSION , '5.4.4' , '<' ))
) {
$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).' );
} else {
$this -> assertEquals ( - 2147483649 , $parsedValue , '->parse() TYPE_INT64 uses true 64 bit integers (PHP >= 5.3.14 and PHP >= 5.4.4).' );
}
2011-01-25 00:48:04 +00:00
}
/**
* @ dataProvider parseTypeDoubleProvider
*/
public function testParseTypeDoubleStub ( $value , $expectedValue )
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( $value , StubNumberFormatter :: TYPE_DOUBLE );
$this -> assertSame ( $expectedValue , $parsedValue );
}
/**
* @ dataProvider parseTypeDoubleProvider
*/
public function testParseTypeDoubleIntl ( $value , $expectedValue )
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( $value , \NumberFormatter :: TYPE_DOUBLE );
$this -> assertSame ( $expectedValue , $parsedValue );
}
public function parseTypeDoubleProvider ()
{
return array (
array ( '1' , ( float ) 1 ),
array ( '1.1' , 1.1 ),
array ( '9,223,372,036,854,775,808' , 9223372036854775808 ),
array ( '-9,223,372,036,854,775,809' , - 9223372036854775809 ),
);
}
/**
* @ expectedException PHPUnit_Framework_Error_Warning
*/
public function testParseTypeCurrencyStub ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> parse ( '1' , StubNumberFormatter :: TYPE_CURRENCY );
}
/**
* @ expectedException PHPUnit_Framework_Error_Warning
*/
public function testParseTypeCurrencyIntl ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$formatter -> parse ( '1' , \NumberFormatter :: TYPE_CURRENCY );
}
public function testParseWithNullPositionValueStub ()
{
$position = null ;
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> parse ( '123' , StubNumberFormatter :: TYPE_INT32 , $position );
$this -> assertNull ( $position );
}
public function testParseWithNullPositionValueIntl ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$position = 0 ;
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( '123' , \NumberFormatter :: TYPE_DOUBLE , $position );
$this -> assertEquals ( 3 , $position );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodArgumentNotImplementedException
*/
public function testParseWithNotNullPositionValueStub ()
{
$position = 1 ;
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> parse ( '123' , StubNumberFormatter :: TYPE_INT32 , $position );
}
public function testParseWithNotNullPositionValueIntl ()
{
$this -> skipIfIntlExtensionIsNotLoaded ();
$position = 1 ;
$formatter = $this -> getIntlFormatterWithDecimalStyle ();
$parsedValue = $formatter -> parse ( '123' , \NumberFormatter :: TYPE_DOUBLE , $position );
$this -> assertEquals ( 3 , $position );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodNotImplementedException
*/
public function testSetPattern ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> setPattern ( null );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodNotImplementedException
*/
public function testSetSymbol ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> setSymbol ( null , null );
}
/**
* @ expectedException Symfony\Component\Locale\Exception\MethodNotImplementedException
*/
public function testSetTextAttribute ()
{
$formatter = $this -> getStubFormatterWithDecimalStyle ();
$formatter -> setTextAttribute ( null , null );
}
protected function getStubFormatterWithDecimalStyle ()
{
return new StubNumberFormatter ( 'en' , StubNumberFormatter :: DECIMAL );
}
protected function getStubFormatterWithCurrencyStyle ()
{
return new StubNumberFormatter ( 'en' , StubNumberFormatter :: CURRENCY );
}
protected function getIntlFormatterWithDecimalStyle ()
{
if ( ! $this -> isIntlExtensionLoaded ()) {
return null ;
}
return new \NumberFormatter ( 'en' , \NumberFormatter :: DECIMAL );
}
protected function getIntlFormatterWithCurrencyStyle ()
{
if ( ! $this -> isIntlExtensionLoaded ()) {
return null ;
}
$formatter = new \NumberFormatter ( 'en' , \NumberFormatter :: CURRENCY );
$formatter -> setSymbol ( \NumberFormatter :: CURRENCY_SYMBOL , 'SFD' );
2011-06-08 18:56:59 +01:00
2011-01-25 00:48:04 +00:00
return $formatter ;
}
}