Configuration/tests/configuration_ini_reader_test.php - zetacomponents - Git at Google

 <?php
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
  * @version //autogentag//
  * @filesource
  * @package Configuration
  * @subpackage Tests
  */

 /**
  * @package Configuration
  * @subpackage Tests
  */
 class ezcConfigurationIniReaderTest extends ezcTestCase
 {
     public function testConfigSettingUseComments()
     {
         $backend = new ezcConfigurationIniReader();
         $backend->setOptions( array ( 'useComments' => true ) );
         $backend->setOptions( array ( 'useComments' => false ) );
     }

     public function testConfigSettingUseCommentsWrongType()
     {
         $backend = new ezcConfigurationIniReader();
         try
         {
             $backend->setOptions( array ( 'useComments' => 'tests/translations' ) );
             $this->fail( 'Expected exception was not thrown' );
         }
         catch ( ezcBaseSettingValueException $e )
         {
             self::assertEquals( "The value 'tests/translations' that you were trying to assign to setting 'useComments' is invalid. Allowed values are: bool", $e->getMessage() );
         }
     }

     public function testGetOptions()
     {
         $backend = new ezcConfigurationIniReader();
         $backend->setOptions( array ( 'useComments' => true ) );
         $this->assertEquals( array ( 'useComments' => true ), $backend->getOptions() );
     }

     public function testConfigSettingBroken()
     {
         $backend = new ezcConfigurationIniReader();
         try
         {
             $backend->setOptions( array ( 'lOcAtIOn' => 'tests/translations' ) );
             $this->fail( 'Expected exception was not thrown' );
         }
         catch ( ezcBaseSettingNotFoundException $e )
         {
             self::assertEquals( "The setting 'lOcAtIOn' is not a valid configuration setting.", $e->getMessage() );
         }
     }

     public function testInitCtor1()
     {
         $backend = new ezcConfigurationIniReader( 'files/basic.ini' );
         $this->assertEquals( 'files', $backend->getLocation() );
         $this->assertEquals( 'basic', $backend->getName() );
     }

     public function testInitCtor2()
     {
         $backend = new ezcConfigurationIniReader( 'files.foo/basic.ini' );
         $this->assertEquals( 'files.foo', $backend->getLocation() );
         $this->assertEquals( 'basic', $backend->getName() );
     }

     public function testInitCtor3()
     {
         try
         {
             $backend = new ezcConfigurationIniReader( 'files.foo/basic.f' );
             $this->fail( 'Expected exception not thrown' );
         }
         catch ( ezcConfigurationInvalidSuffixException $e )
         {
             $this->assertEquals( "The path 'files.foo/basic.f' has an invalid suffix (should be '.ini').", $e->getMessage() );
         }
     }

     public function testInitCtor4()
     {
         $backend = new ezcConfigurationIniReader( 'files' . DIRECTORY_SEPARATOR . 'basic.ini' );
         $this->assertEquals( 'files', $backend->getLocation() );
         $this->assertEquals( 'basic', $backend->getName() );
     }

     public function testInitCtor5()
     {
         $backend = new ezcConfigurationIniReader( 'initctor5.ini' );
         $this->assertEquals( '.', $backend->getLocation() );
         $this->assertEquals( 'initctor5', $backend->getName() );
     }

     public function testInitMethod1()
     {
         $backend = new ezcConfigurationIniReader();
         $backend->init( 'files', 'basic' );
         $this->assertEquals( 'files', $backend->getLocation() );
         $this->assertEquals( 'basic', $backend->getName() );
     }

     public function testConfigExistsCtor()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/basic.ini' );
         $this->assertEquals( true, $backend->configExists() );
     }

     public function testConfigExistsInitMethod()
     {
         $backend = new ezcConfigurationIniReader();
         $backend->init( 'Configuration/tests/files', 'basic' );
         $this->assertEquals( true, $backend->configExists() );
     }

     public function testConfigNotExistsCtor()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/non-existent.ini' );
         $this->assertEquals( false, $backend->configExists() );
     }

     public function testConfigNotExistsInitMethod()
     {
         $backend = new ezcConfigurationIniReader();
         $backend->init( 'Configuration/tests/files', 'non-existent' );
         $this->assertEquals( false, $backend->configExists() );
     }

     public function testUnexistingFile()
     {
         try
         {
             $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/non-existent.ini' );
             $backend->load();
             $this->fail( 'Expected exception not thrown' );
         }
         catch ( ezcBaseFileNotFoundException $e )
         {
             $this->assertEquals( "The file 'Configuration/tests/files/non-existent.ini' could not be found.", $e->getMessage() );
         }
     }

     public function testEmptyFile()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/empty.ini' );
         $return = $backend->load();
         $this->assertEquals( new ezcConfiguration(), $return );
     }

     public function testOneGroup()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/one-group.ini' );
         $return = $backend->load();

         $settings = array(
             'TheOnlyGroup' => array(
                 'Setting1' => true,
                 'SettingNoComment' => 42,
                 'MultiRow' => false,
             )
         );
         $comments = array(
             'TheOnlyGroup' => array(
                 '#' => "Just one group",
                 'Setting1' => " This setting sucks",
                 'MultiRow' => " Multi\n row\n comment",
             )
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function testOneGroupWithGetConfig()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/one-group.ini' );
         $backend->load();
         $return = $backend->getConfig();

         $settings = array(
             'TheOnlyGroup' => array(
                 'Setting1' => true,
                 'SettingNoComment' => 42,
                 'MultiRow' => false,
             )
         );
         $comments = array(
             'TheOnlyGroup' => array(
                 '#' => "Just one group",
                 'Setting1' => " This setting sucks",
                 'MultiRow' => " Multi\n row\n comment",
             )
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function testTwoGroups()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/two-groups.ini' );
         $return = $backend->load();

         $settings = array(
             'NotTheOnlyGroup' => array(
                 'Setting1' => true,
             ),
             'TheSecond' => array(
                 'Setting1' => false,
             ),
         );
         $comments = array(
             'NotTheOnlyGroup' => array(
                 '#' => " Not just one group",
             ),
             'TheSecond' => array(
                 '#' => " The second group",
             ),
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function testKake()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/kake.ini' );
         $return = $backend->load();

         $settings = array(
             'SettingsBlock' => array(
                 'Kake' => array(
                     'mann' => array( 'sjokolade', 'blåbær' ),
                     'fyll' => array( 'pære', 'øl' ),
                 ),
             ),
         );
         $comments = array(
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function testFormats()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/formats.ini' );
         $return = $backend->load();

         $settings = array(
             'FormatTest' => array(
                 'Decimal1' => 42,
                 'Decimal2' => 0,
                 'MaxSize' => 400,
                 'MinSize' => 0,
                 'Hex1' => 11189196,
                 'Hex2' => 11189196,
                 'Hex3' => 11189196,
                 'Hex4' => 11189196,
                 'TextColor' => 66302,
                 'Octal1' => 1,
                 'Octal2' => 458,
                 'Permission' => 438,
                 'Float1' => 0.2,
                 'Float2' => .8123,
                 'Float3' => 42.,
                 'Float4' => 314e-2,
                 'Float5' => 3.141592654e1,
                 'Price' => 10.4,
                 'Seed' => 10e5,
                 'String1' => 'Blah blah blah',
                 'String2' => 'Derick "Tiger" Rethans',
                 'String3' => 'Foo \\ Bar',
                 'String4' => 'Foo \\',
             )
         );
         $comments = array(
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function test2D()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/multi-dim.ini' );
         $return = $backend->load();

         $settings = array(
             '2D-numbered' => array(
                 'Decimal' => array( 42, 0 ),
                 'Mixed' => array( 42, 0.812, false, "Derick \"Tiger\" Rethans" ),
             ),
             '2D-associative' => array(
                 'Decimal' => array( 'a' => 42, 'b' => 0 ),
                 'Mixed' => array( 'a' => 42, 1 => 0.812, 'b' => false, 2 => "Derick \"Tiger\" Rethans" ),
             ),
         );
         $comments = array(
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function test3D()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/multi-dim2.ini' );
         $return = $backend->load();

         $settings = array(
             '3D' => array(
                 'Decimal' => array( 42, 0 ),
                 'Array' =>  array(
                     'Decimal' => array( 'a' => 42, 'b' => 0 ),
                     'Mixed' => array( 'b' => false, 2 => "Derick \"Tiger\" Rethans" ),
                 ),
                 'Quote' => array( "quo\nted" => 'string' ),
             ),
         );
         $comments = array(
             '3D' => array(
                 'Decimal' => array( " One with a comment", " Second one with a comment" ),
                 'Array' => array(
                     'Mixed' => array( 2 => " One with a comment" ),
                 ),
                 'Quote' => array( "quo\nted" => ' One with a quoted hash key' ),
             ),
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function test3DSemiColonComment()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/multi-dim3.ini' );
         $return = $backend->load();

         $settings = array(
             '3D' => array(
                 'Decimal' => array( 42, 0 ),
                 'Array' =>  array(
                     'Decimal' => array( 'a' => 42, 'b' => 0 ),
                     'Mixed' => array( 'b' => false, 2 => "Derick \"Tiger\" Rethans" ),
                 ),
                 'Quote' => array( "quo\nted" => 'string' ),
             ),
         );
         $comments = array(
             '3D' => array(
                 'Decimal' => array( " One with a comment", " Second one with a comment" ),
                 'Array' => array(
                     'Mixed' => array( 2 => " One with a comment\n multiple lines" ),
                 ),
                 'Quote' => array( "quo\nted" => ' One with a quoted hash key' ),
             ),
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     public function testIntegerRanges32Bit()
     {
         if ( PHP_INT_SIZE !== 4 )
         {
             $this->markTestSkipped( "Only for 32 bit machines" );
         }
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/int-range.ini' );
         $return = $backend->load();

         $settings = array(
             'int32' => array(
                 'InRange1' => -51,
                 'InRange2' => 59,
                 'InRangeJust0' => -2147483647,
                 'InRangeJust1' => (int) '-2147483648',
                 'InRangeJust2' => 2147483647,
                 'OutRangeJust1' => '-2147483649',
                 'OutRangeJust2' => '2147483648',
                 'OutRange1' => '-21474836480',
                 'OutRange2' => '21474836480',
             ),
             'int64' => array(
                 'InRange1' => -51,
                 'InRange2' => 59,
                 'InRangeJust0' => '-9223372036854775807',
                 'InRangeJust1' => '-9223372036854775808',
                 'InRangeJust2' => '9223372036854775807',
                 'OutRangeJust1' => '-9223372036854775809',
                 'OutRangeJust2' => '9223372036854775808',
                 'OutRange1' => '-92233720368547758080',
                 'OutRange2' => '92233720368547758080',
             ),
         );
         $comments = array(
         );
         $expected = new ezcConfiguration( $settings, $comments );

         $this->assertSame( $expected->getAllSettings(), $return->getAllSettings() );
         $this->assertSame( -2147483647, $expected->getSetting( 'int32', 'InRangeJust0' ) );
         $this->assertSame( '-2147483649', $expected->getStringSetting( 'int32', 'OutRangeJust1' ) );
         try
         {
             $this->assertSame( '-2147483649', $expected->getNumberSetting( 'int32', 'OutRangeJust1' ) );
         }
         catch ( ezcConfigurationSettingWrongTypeException $e )
         {
             self::assertSame( "The expected type for the setting 'int32', 'OutRangeJust1' is 'double or integer'. The setting was of type 'string'.", $e->getMessage() );
         }
     }

     public function testIntegerRanges64Bit()
     {
         if ( PHP_INT_SIZE !== 8 )
         {
             $this->markTestSkipped( "Only for 64 bit machines" );
         }
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/int-range.ini' );
         $return = $backend->load();

         $settings = array(
             'int32' => array(
                 'InRange1' => -51,
                 'InRange2' => 59,
                 'InRangeJust0' => -2147483647,
                 'InRangeJust1' => -2147483648,
                 'InRangeJust2' => 2147483647,
                 'OutRangeJust1' => -2147483649,
                 'OutRangeJust2' => 2147483648,
                 'OutRange1' => -21474836480,
                 'OutRange2' => 21474836480,
             ),
             'int64' => array(
                 'InRange1' => -51,
                 'InRange2' => 59,
                 'InRangeJust0' => -9223372036854775807,
                 'InRangeJust1' => (int) '-9223372036854775808', // yes, this is really necessary
                 'InRangeJust2' => 9223372036854775807,
                 'OutRangeJust1' => '-9223372036854775809',
                 'OutRangeJust2' => '9223372036854775808',
                 'OutRange1' => '-92233720368547758080',
                 'OutRange2' => '92233720368547758080',
             ),
         );
         $comments = array(
         );
         $expected = new ezcConfiguration( $settings, $comments );

         $this->assertSame( $expected->getAllSettings(), $return->getAllSettings() );
         $this->assertSame( -9223372036854775807, $expected->getSetting( 'int64', 'InRangeJust0' ) );
         $this->assertSame( '-9223372036854775809', $expected->getStringSetting( 'int64', 'OutRangeJust1' ) );
         try
         {
             $this->assertSame( '-9223372036854775809', $expected->getNumberSetting( 'int64', 'OutRangeJust1' ) );
         }
         catch ( ezcConfigurationSettingWrongTypeException $e )
         {
             self::assertSame( "The expected type for the setting 'int64', 'OutRangeJust1' is 'double or integer'. The setting was of type 'string'.", $e->getMessage() );
         }
     }

     public function testTimestamp()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/empty.ini' );
         @touch( 'Configuration/tests/files/empty.ini', 1130859680 );
         $ts = $backend->getTimestamp();
         $this->assertEquals( 1130859680, $ts );
     }

     public function testTimestampNonExistingFile()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/non-existent.ini' );
         $ts = $backend->getTimestamp();
         $this->assertEquals( false, $ts );
     }

     public function testSimpleErrors()
     {
         $backend = new ezcConfigurationIniReader( 'Configuration/tests/files/simple-errors.ini' );
         try
         {
             $return = $backend->load();
             $this->fail( 'Expected exception was not thrown' );
         }
         catch ( ezcConfigurationParseErrorException $e )
         {
             $this->assertEquals( "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$' in 'Configuration/tests/files/simple-errors.ini', line '8'.", $e->getMessage() );
         }
     }

     public function testBug7855()
     {
         $path = 'Configuration/tests/files/bug7855.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->load();

         $settings = array(
             'TestSettings' => array(
                 'SettingA' => 1,
                 'SettingB' => 2,
             ),
         );
         $comments = array(
             'TestSettings' => array(
                 'SettingB' => " This setting has no new line behind it - make sure it stays like this in this\n test file"
             ),
         );
         $expected = new ezcConfiguration( $settings, $comments );
         $this->assertEquals( $expected, $return );
     }

     /* Validation with a non-strict validator */
     public function testValidationNonStrict()
     {
         $path = 'Configuration/tests/files/simple-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( false );

         $expected = new ezcConfigurationValidationResult( $backend->getLocation(), $backend->getName(), $path );
         $expected->isValid = false;
         $item = new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'", "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'" );
         $expected->appendItem( $item );

         $this->assertEquals( $expected, $return );
     }

     public function testValidationNonStrictGetResultList()
     {
         $path = 'Configuration/tests/files/simple-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( false );
         $resultList = $return->getResultList();

         $expected = array( new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'", "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'" ) );
         $this->assertEquals( $expected, $resultList );
     }

     public function testValidationNonStrictGetResultList2()
     {
         $path = 'Configuration/tests/files/more-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( false );
         $resultList = $return->getResultList();

         $expected = array(
             new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 2, false, "Group ID 'Error Chars' has invalid characters", "Group ID 'Error Chars' has invalid characters" ),
             new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 3, false, "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'", "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'" ),
         );
         $this->assertEquals( $expected, $resultList );
     }

     public function testValidationNonStrictWarningErrorCount1()
     {
         $path = 'Configuration/tests/files/simple-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( false );
         $this->assertEquals( 1, $return->getErrorCount() );
         $this->assertEquals( 0, $return->getWarningCount() );
     }

     public function testValidationNonStrictWarningErrorCount2()
     {
         $path = 'Configuration/tests/files/more-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( false );
         $this->assertEquals( 2, $return->getErrorCount() );
         $this->assertEquals( 0, $return->getWarningCount() );
     }

     /* Validation with a strict validator */
     public function testValidationStrict()
     {
         $path = 'Configuration/tests/files/simple-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( true );

         $expected = new ezcConfigurationValidationResult( $backend->getLocation(), $backend->getName(), $path );
         $expected->isValid = false;
         $item = new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'", "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'" );
         $expected->appendItem( $item );

         $this->assertEquals( $expected, $return );
     }

     public function testValidationStrictGetResultList()
     {
         $path = 'Configuration/tests/files/simple-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( true );
         $resultList = $return->getResultList();

         $expected = array( new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'", "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'" ) );
         $this->assertEquals( $expected, $resultList );
     }

     public function testValidationStrictGetResultList2()
     {
         $path = 'Configuration/tests/files/more-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( true );
         $resultList = $return->getResultList();

         $expected = array(
             new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 2, false, "Group ID 'Error Chars' has invalid characters", "Group ID 'Error Chars' has invalid characters" ),
             new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 3, false, "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'", "Invalid data: 'c8756*&%&^%&%$&C%$%C*@%C*$'" ),
         );
         $this->assertEquals( $expected, $resultList );
     }

     public function testValidationStrictWarningErrorCount1()
     {
         $path = 'Configuration/tests/files/simple-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( true );
         $this->assertEquals( 1, $return->getErrorCount() );
         $this->assertEquals( 0, $return->getWarningCount() );
     }

     public function testValidationStrictWarningErrorCount2()
     {
         $path = 'Configuration/tests/files/more-errors.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->validate( true );
         $this->assertEquals( 2, $return->getErrorCount() );
         $this->assertEquals( 0, $return->getWarningCount() );
     }

     // test for issue #15309: A simple quote in an index hash, in ini files
     public function testQuoteInHashKey()
     {
         $path = 'Configuration/tests/files/bug15309.ini';
         $backend = new ezcConfigurationIniReader( $path );
         $return = $backend->load();
         $this->assertEquals( array( "CÔTE D'IVOIRE" => 'Wybrzeże Kości Słoniowej' ), $return->getSetting( 'TestSettings', "Countries" ) );
     }

     public static function suite()
     {
          return new PHPUnit_Framework_TestSuite( 'ezcConfigurationIniReaderTest' );
     }

 }

 ?>
	<?php
	/**
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
	* @version //autogentag//
	* @filesource
	* @package Configuration
	* @subpackage Tests
	*/

	/**
	* @package Configuration
	* @subpackage Tests
	*/
	class ezcConfigurationIniReaderTest extends ezcTestCase
	{
	public function testConfigSettingUseComments()
	{
	$backend = new ezcConfigurationIniReader();
	$backend->setOptions( array ( 'useComments' => true ) );
	$backend->setOptions( array ( 'useComments' => false ) );
	}

	public function testConfigSettingUseCommentsWrongType()
	{
	$backend = new ezcConfigurationIniReader();
	try
	{
	$backend->setOptions( array ( 'useComments' => 'tests/translations' ) );
	$this->fail( 'Expected exception was not thrown' );
	}
	catch ( ezcBaseSettingValueException $e )
	{
	self::assertEquals( "The value 'tests/translations' that you were trying to assign to setting 'useComments' is invalid. Allowed values are: bool", $e->getMessage() );
	}
	}

	public function testGetOptions()
	{
	$backend = new ezcConfigurationIniReader();
	$backend->setOptions( array ( 'useComments' => true ) );
	$this->assertEquals( array ( 'useComments' => true ), $backend->getOptions() );
	}

	public function testConfigSettingBroken()
	{
	$backend = new ezcConfigurationIniReader();
	try
	{
	$backend->setOptions( array ( 'lOcAtIOn' => 'tests/translations' ) );
	$this->fail( 'Expected exception was not thrown' );
	}
	catch ( ezcBaseSettingNotFoundException $e )
	{
	self::assertEquals( "The setting 'lOcAtIOn' is not a valid configuration setting.", $e->getMessage() );
	}
	}

	public function testInitCtor1()
	{
	$backend = new ezcConfigurationIniReader( 'files/basic.ini' );
	$this->assertEquals( 'files', $backend->getLocation() );
	$this->assertEquals( 'basic', $backend->getName() );
	}

	public function testInitCtor2()
	{
	$backend = new ezcConfigurationIniReader( 'files.foo/basic.ini' );
	$this->assertEquals( 'files.foo', $backend->getLocation() );
	$this->assertEquals( 'basic', $backend->getName() );
	}

	public function testInitCtor3()
	{
	try
	{
	$backend = new ezcConfigurationIniReader( 'files.foo/basic.f' );
	$this->fail( 'Expected exception not thrown' );
	}
	catch ( ezcConfigurationInvalidSuffixException $e )
	{
	$this->assertEquals( "The path 'files.foo/basic.f' has an invalid suffix (should be '.ini').", $e->getMessage() );
	}
	}

	public function testInitCtor4()
	{
	$backend = new ezcConfigurationIniReader( 'files' . DIRECTORY_SEPARATOR . 'basic.ini' );
	$this->assertEquals( 'files', $backend->getLocation() );
	$this->assertEquals( 'basic', $backend->getName() );
	}

	public function testInitCtor5()
	{
	$backend = new ezcConfigurationIniReader( 'initctor5.ini' );
	$this->assertEquals( '.', $backend->getLocation() );
	$this->assertEquals( 'initctor5', $backend->getName() );
	}

	public function testInitMethod1()
	{
	$backend = new ezcConfigurationIniReader();
	$backend->init( 'files', 'basic' );
	$this->assertEquals( 'files', $backend->getLocation() );
	$this->assertEquals( 'basic', $backend->getName() );
	}

	public function testConfigExistsCtor()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/basic.ini' );
	$this->assertEquals( true, $backend->configExists() );
	}

	public function testConfigExistsInitMethod()
	{
	$backend = new ezcConfigurationIniReader();
	$backend->init( 'Configuration/tests/files', 'basic' );
	$this->assertEquals( true, $backend->configExists() );
	}

	public function testConfigNotExistsCtor()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/non-existent.ini' );
	$this->assertEquals( false, $backend->configExists() );
	}

	public function testConfigNotExistsInitMethod()
	{
	$backend = new ezcConfigurationIniReader();
	$backend->init( 'Configuration/tests/files', 'non-existent' );
	$this->assertEquals( false, $backend->configExists() );
	}

	public function testUnexistingFile()
	{
	try
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/non-existent.ini' );
	$backend->load();
	$this->fail( 'Expected exception not thrown' );
	}
	catch ( ezcBaseFileNotFoundException $e )
	{
	$this->assertEquals( "The file 'Configuration/tests/files/non-existent.ini' could not be found.", $e->getMessage() );
	}
	}

	public function testEmptyFile()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/empty.ini' );
	$return = $backend->load();
	$this->assertEquals( new ezcConfiguration(), $return );
	}

	public function testOneGroup()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/one-group.ini' );
	$return = $backend->load();

	$settings = array(
	'TheOnlyGroup' => array(
	'Setting1' => true,
	'SettingNoComment' => 42,
	'MultiRow' => false,
	)
	);
	$comments = array(
	'TheOnlyGroup' => array(
	'#' => "Just one group",
	'Setting1' => " This setting sucks",
	'MultiRow' => " Multi\n row\n comment",
	)
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function testOneGroupWithGetConfig()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/one-group.ini' );
	$backend->load();
	$return = $backend->getConfig();

	$settings = array(
	'TheOnlyGroup' => array(
	'Setting1' => true,
	'SettingNoComment' => 42,
	'MultiRow' => false,
	)
	);
	$comments = array(
	'TheOnlyGroup' => array(
	'#' => "Just one group",
	'Setting1' => " This setting sucks",
	'MultiRow' => " Multi\n row\n comment",
	)
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function testTwoGroups()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/two-groups.ini' );
	$return = $backend->load();

	$settings = array(
	'NotTheOnlyGroup' => array(
	'Setting1' => true,
	),
	'TheSecond' => array(
	'Setting1' => false,
	),
	);
	$comments = array(
	'NotTheOnlyGroup' => array(
	'#' => " Not just one group",
	),
	'TheSecond' => array(
	'#' => " The second group",
	),
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function testKake()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/kake.ini' );
	$return = $backend->load();

	$settings = array(
	'SettingsBlock' => array(
	'Kake' => array(
	'mann' => array( 'sjokolade', 'blåbær' ),
	'fyll' => array( 'pære', 'øl' ),
	),
	),
	);
	$comments = array(
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function testFormats()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/formats.ini' );
	$return = $backend->load();

	$settings = array(
	'FormatTest' => array(
	'Decimal1' => 42,
	'Decimal2' => 0,
	'MaxSize' => 400,
	'MinSize' => 0,
	'Hex1' => 11189196,
	'Hex2' => 11189196,
	'Hex3' => 11189196,
	'Hex4' => 11189196,
	'TextColor' => 66302,
	'Octal1' => 1,
	'Octal2' => 458,
	'Permission' => 438,
	'Float1' => 0.2,
	'Float2' => .8123,
	'Float3' => 42.,
	'Float4' => 314e-2,
	'Float5' => 3.141592654e1,
	'Price' => 10.4,
	'Seed' => 10e5,
	'String1' => 'Blah blah blah',
	'String2' => 'Derick "Tiger" Rethans',
	'String3' => 'Foo \\ Bar',
	'String4' => 'Foo \\',
	)
	);
	$comments = array(
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function test2D()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/multi-dim.ini' );
	$return = $backend->load();

	$settings = array(
	'2D-numbered' => array(
	'Decimal' => array( 42, 0 ),
	'Mixed' => array( 42, 0.812, false, "Derick \"Tiger\" Rethans" ),
	),
	'2D-associative' => array(
	'Decimal' => array( 'a' => 42, 'b' => 0 ),
	'Mixed' => array( 'a' => 42, 1 => 0.812, 'b' => false, 2 => "Derick \"Tiger\" Rethans" ),
	),
	);
	$comments = array(
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function test3D()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/multi-dim2.ini' );
	$return = $backend->load();

	$settings = array(
	'3D' => array(
	'Decimal' => array( 42, 0 ),
	'Array' => array(
	'Decimal' => array( 'a' => 42, 'b' => 0 ),
	'Mixed' => array( 'b' => false, 2 => "Derick \"Tiger\" Rethans" ),
	),
	'Quote' => array( "quo\nted" => 'string' ),
	),
	);
	$comments = array(
	'3D' => array(
	'Decimal' => array( " One with a comment", " Second one with a comment" ),
	'Array' => array(
	'Mixed' => array( 2 => " One with a comment" ),
	),
	'Quote' => array( "quo\nted" => ' One with a quoted hash key' ),
	),
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function test3DSemiColonComment()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/multi-dim3.ini' );
	$return = $backend->load();

	$settings = array(
	'3D' => array(
	'Decimal' => array( 42, 0 ),
	'Array' => array(
	'Decimal' => array( 'a' => 42, 'b' => 0 ),
	'Mixed' => array( 'b' => false, 2 => "Derick \"Tiger\" Rethans" ),
	),
	'Quote' => array( "quo\nted" => 'string' ),
	),
	);
	$comments = array(
	'3D' => array(
	'Decimal' => array( " One with a comment", " Second one with a comment" ),
	'Array' => array(
	'Mixed' => array( 2 => " One with a comment\n multiple lines" ),
	),
	'Quote' => array( "quo\nted" => ' One with a quoted hash key' ),
	),
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	public function testIntegerRanges32Bit()
	{
	if ( PHP_INT_SIZE !== 4 )
	{
	$this->markTestSkipped( "Only for 32 bit machines" );
	}
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/int-range.ini' );
	$return = $backend->load();

	$settings = array(
	'int32' => array(
	'InRange1' => -51,
	'InRange2' => 59,
	'InRangeJust0' => -2147483647,
	'InRangeJust1' => (int) '-2147483648',
	'InRangeJust2' => 2147483647,
	'OutRangeJust1' => '-2147483649',
	'OutRangeJust2' => '2147483648',
	'OutRange1' => '-21474836480',
	'OutRange2' => '21474836480',
	),
	'int64' => array(
	'InRange1' => -51,
	'InRange2' => 59,
	'InRangeJust0' => '-9223372036854775807',
	'InRangeJust1' => '-9223372036854775808',
	'InRangeJust2' => '9223372036854775807',
	'OutRangeJust1' => '-9223372036854775809',
	'OutRangeJust2' => '9223372036854775808',
	'OutRange1' => '-92233720368547758080',
	'OutRange2' => '92233720368547758080',
	),
	);
	$comments = array(
	);
	$expected = new ezcConfiguration( $settings, $comments );

	$this->assertSame( $expected->getAllSettings(), $return->getAllSettings() );
	$this->assertSame( -2147483647, $expected->getSetting( 'int32', 'InRangeJust0' ) );
	$this->assertSame( '-2147483649', $expected->getStringSetting( 'int32', 'OutRangeJust1' ) );
	try
	{
	$this->assertSame( '-2147483649', $expected->getNumberSetting( 'int32', 'OutRangeJust1' ) );
	}
	catch ( ezcConfigurationSettingWrongTypeException $e )
	{
	self::assertSame( "The expected type for the setting 'int32', 'OutRangeJust1' is 'double or integer'. The setting was of type 'string'.", $e->getMessage() );
	}
	}

	public function testIntegerRanges64Bit()
	{
	if ( PHP_INT_SIZE !== 8 )
	{
	$this->markTestSkipped( "Only for 64 bit machines" );
	}
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/int-range.ini' );
	$return = $backend->load();

	$settings = array(
	'int32' => array(
	'InRange1' => -51,
	'InRange2' => 59,
	'InRangeJust0' => -2147483647,
	'InRangeJust1' => -2147483648,
	'InRangeJust2' => 2147483647,
	'OutRangeJust1' => -2147483649,
	'OutRangeJust2' => 2147483648,
	'OutRange1' => -21474836480,
	'OutRange2' => 21474836480,
	),
	'int64' => array(
	'InRange1' => -51,
	'InRange2' => 59,
	'InRangeJust0' => -9223372036854775807,
	'InRangeJust1' => (int) '-9223372036854775808', // yes, this is really necessary
	'InRangeJust2' => 9223372036854775807,
	'OutRangeJust1' => '-9223372036854775809',
	'OutRangeJust2' => '9223372036854775808',
	'OutRange1' => '-92233720368547758080',
	'OutRange2' => '92233720368547758080',
	),
	);
	$comments = array(
	);
	$expected = new ezcConfiguration( $settings, $comments );

	$this->assertSame( $expected->getAllSettings(), $return->getAllSettings() );
	$this->assertSame( -9223372036854775807, $expected->getSetting( 'int64', 'InRangeJust0' ) );
	$this->assertSame( '-9223372036854775809', $expected->getStringSetting( 'int64', 'OutRangeJust1' ) );
	try
	{
	$this->assertSame( '-9223372036854775809', $expected->getNumberSetting( 'int64', 'OutRangeJust1' ) );
	}
	catch ( ezcConfigurationSettingWrongTypeException $e )
	{
	self::assertSame( "The expected type for the setting 'int64', 'OutRangeJust1' is 'double or integer'. The setting was of type 'string'.", $e->getMessage() );
	}
	}

	public function testTimestamp()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/empty.ini' );
	@touch( 'Configuration/tests/files/empty.ini', 1130859680 );
	$ts = $backend->getTimestamp();
	$this->assertEquals( 1130859680, $ts );
	}

	public function testTimestampNonExistingFile()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/non-existent.ini' );
	$ts = $backend->getTimestamp();
	$this->assertEquals( false, $ts );
	}

	public function testSimpleErrors()
	{
	$backend = new ezcConfigurationIniReader( 'Configuration/tests/files/simple-errors.ini' );
	try
	{
	$return = $backend->load();
	$this->fail( 'Expected exception was not thrown' );
	}
	catch ( ezcConfigurationParseErrorException $e )
	{
	$this->assertEquals( "Invalid data: 'c8756&%&^%&%$&C%$%C@%C*$' in 'Configuration/tests/files/simple-errors.ini', line '8'.", $e->getMessage() );
	}
	}

	public function testBug7855()
	{
	$path = 'Configuration/tests/files/bug7855.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->load();

	$settings = array(
	'TestSettings' => array(
	'SettingA' => 1,
	'SettingB' => 2,
	),
	);
	$comments = array(
	'TestSettings' => array(
	'SettingB' => " This setting has no new line behind it - make sure it stays like this in this\n test file"
	),
	);
	$expected = new ezcConfiguration( $settings, $comments );
	$this->assertEquals( $expected, $return );
	}

	/* Validation with a non-strict validator */
	public function testValidationNonStrict()
	{
	$path = 'Configuration/tests/files/simple-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( false );

	$expected = new ezcConfigurationValidationResult( $backend->getLocation(), $backend->getName(), $path );
	$expected->isValid = false;
	$item = new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'", "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'" );
	$expected->appendItem( $item );

	$this->assertEquals( $expected, $return );
	}

	public function testValidationNonStrictGetResultList()
	{
	$path = 'Configuration/tests/files/simple-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( false );
	$resultList = $return->getResultList();

	$expected = array( new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'", "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'" ) );
	$this->assertEquals( $expected, $resultList );
	}

	public function testValidationNonStrictGetResultList2()
	{
	$path = 'Configuration/tests/files/more-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( false );
	$resultList = $return->getResultList();

	$expected = array(
	new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 2, false, "Group ID 'Error Chars' has invalid characters", "Group ID 'Error Chars' has invalid characters" ),
	new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 3, false, "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'", "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'" ),
	);
	$this->assertEquals( $expected, $resultList );
	}

	public function testValidationNonStrictWarningErrorCount1()
	{
	$path = 'Configuration/tests/files/simple-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( false );
	$this->assertEquals( 1, $return->getErrorCount() );
	$this->assertEquals( 0, $return->getWarningCount() );
	}

	public function testValidationNonStrictWarningErrorCount2()
	{
	$path = 'Configuration/tests/files/more-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( false );
	$this->assertEquals( 2, $return->getErrorCount() );
	$this->assertEquals( 0, $return->getWarningCount() );
	}

	/* Validation with a strict validator */
	public function testValidationStrict()
	{
	$path = 'Configuration/tests/files/simple-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( true );

	$expected = new ezcConfigurationValidationResult( $backend->getLocation(), $backend->getName(), $path );
	$expected->isValid = false;
	$item = new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'", "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'" );
	$expected->appendItem( $item );

	$this->assertEquals( $expected, $return );
	}

	public function testValidationStrictGetResultList()
	{
	$path = 'Configuration/tests/files/simple-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( true );
	$resultList = $return->getResultList();

	$expected = array( new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 8, false, "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'", "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'" ) );
	$this->assertEquals( $expected, $resultList );
	}

	public function testValidationStrictGetResultList2()
	{
	$path = 'Configuration/tests/files/more-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( true );
	$resultList = $return->getResultList();

	$expected = array(
	new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 2, false, "Group ID 'Error Chars' has invalid characters", "Group ID 'Error Chars' has invalid characters" ),
	new ezcConfigurationValidationItem( ezcConfigurationValidationItem::ERROR, $path, 3, false, "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'", "Invalid data: 'c8756&%&^%&%$&C%$%C@%C$'" ),
	);
	$this->assertEquals( $expected, $resultList );
	}

	public function testValidationStrictWarningErrorCount1()
	{
	$path = 'Configuration/tests/files/simple-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( true );
	$this->assertEquals( 1, $return->getErrorCount() );
	$this->assertEquals( 0, $return->getWarningCount() );
	}

	public function testValidationStrictWarningErrorCount2()
	{
	$path = 'Configuration/tests/files/more-errors.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->validate( true );
	$this->assertEquals( 2, $return->getErrorCount() );
	$this->assertEquals( 0, $return->getWarningCount() );
	}

	// test for issue #15309: A simple quote in an index hash, in ini files
	public function testQuoteInHashKey()
	{
	$path = 'Configuration/tests/files/bug15309.ini';
	$backend = new ezcConfigurationIniReader( $path );
	$return = $backend->load();
	$this->assertEquals( array( "CÔTE D'IVOIRE" => 'Wybrzeże Kości Słoniowej' ), $return->getSetting( 'TestSettings', "Countries" ) );
	}

	public static function suite()
	{
	return new PHPUnit_Framework_TestSuite( 'ezcConfigurationIniReaderTest' );
	}

	}

	?>