<?php
/**
 * @copyright Copyright (C) 2005 eZ systems as. All rights reserved.
 * @license http://ez.no/licenses/new_bsd New BSD License
 * @version 1.0beta1
 * @filesource
 * @package Configuration
 * @subpackage Tests
 */

/**
 * @package Configuration
 * @subpackage Tests
 */
class ezcConfigurationTest extends ezcTestCase
{
    public function testAllSettings()
    {
        $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",
            )
        );
        $return = new ezcConfiguration( $settings, $comments );
        $this->assertEquals( $settings, $return->allSettings() );
    }

    public function testAllComments()
    {
        $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",
            )
        );
        $return = new ezcConfiguration( $settings, $comments );
        $this->assertEquals( $comments, $return->allComments() );
    }

    public function testHasSetting1()
    {
        $settings = array(
        );
        $comments = array(
        );
        $return = new ezcConfiguration( $settings, $comments );
        $this->assertEquals( false, $return->hasSetting( 'NonExistingGroup', 'NonExistent' ) );
    }

    public function testHasSetting2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
                'SettingNoComment' => 42,
                'MultiRow' => false,
            )
        );
        $comments = array(
        );
        $return = new ezcConfiguration( $settings, $comments );
        $this->assertEquals( true, $return->hasSetting( 'TheOnlyGroup', 'Setting1' ) );
        $this->assertEquals( true, $return->hasSetting( 'TheOnlyGroup', 'SettingNoComment' ) );
        $this->assertEquals( true, $return->hasSetting( 'TheOnlyGroup', 'MultiRow' ) );
        $this->assertEquals( false, $return->hasSetting( 'TheOnlyGroup', 'NonExistent' ) );
        $this->assertEquals( false, $return->hasSetting( 'NonExistingGroup', 'Setting1' ) );
        $this->assertEquals( false, $return->hasSetting( 'NonExistingGroup', 'NonExistent' ) );
    }

    public function testHasSetting3()
    {
        $settings = array(
            '3D' => array(
                'Decimal' => array( 42, 0 ),
                'Array' =>  array(
                    'Decimal' => array( 'a' => 42, 'b' => 0 ),
                    'Mixed' => array( 'b' => false, 2 => "Derick \"Tiger\" Rethans" ),
                ),
            ),
        );
        $comments = array(
        );
        $return = new ezcConfiguration( $settings, $comments );
        $this->assertEquals( true, $return->hasSetting( '3D', 'Decimal' ) );
        $this->assertEquals( true, $return->hasSetting( '3D', 'Array' ) );
        $this->assertEquals( false, $return->hasSetting( '3D', 'Array[Mixed]' ) );
        $this->assertEquals( false, $return->hasSetting( '3D', 'NonExistent' ) );
    }

    public function testSettingBrokenSettingName()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
            )
        );
        $comments = array(
        );
        $return = new ezcConfiguration( $settings, $comments );
        try
        {
            $setting = $return->setting( 'TheOnlyGroup', array( 'Setting1' ) );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( 'The setting name <a:1:{i:0;s:8:"Setting1";}> is not a string.', $e->getMessage() );
            $this->assertEquals( ezcConfigurationException::SETTINGNAME_NOT_STRING, $e->getCode() );
        }
    }

    public function testSetting1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
                'SettingNoComment' => 42,
                'MultiRow' => false,
            )
        );
        $comments = array(
        );
        $return = new ezcConfiguration( $settings, $comments );
        $this->assertEquals( true, $return->setting( 'TheOnlyGroup', 'Setting1' ) );
        $this->assertEquals( 42, $return->setting( 'TheOnlyGroup', 'SettingNoComment' ) );
        $this->assertEquals( false, $return->setting( 'TheOnlyGroup', 'MultiRow' ) );
    }

    public function testSetting2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $dummy = $configuration->setting( 'NonExistingGroup', 'Dummy' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <NonExistingGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testSetting3()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $dummy = $configuration->setting( 'TheOnlyGroup', 'NonExistent' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_SETTING, $e->getCode() );
            $this->assertEquals( "The setting <TheOnlyGroup>, <NonExistent> does not exist.", $e->getMessage() );
        }
    }

    public function testBoolSetting()
    {
        $settings = array(
            'Types' => array(
                'Bool' => true,
                'Float' => 3.14,
                'Int' => 42,
                'String' => "Components",
                'Array' => array( 1 => 'Een', 2 => 'Twee' ),
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $bool = $configuration->boolSetting( 'Types', 'Bool' );
        $this->assertEquals( true, $bool );
        try
        {
            $configuration->boolSetting( 'Types', 'Float' );
            $configuration->boolSetting( 'Types', 'Int' );
            $configuration->boolSetting( 'Types', 'String' );
            $configuration->boolSetting( 'Types', 'Array' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::SETTING_NOT_BOOL, $e->getCode() );
            $this->assertEquals( "The setting <Types>, <Float> is not a boolean.", $e->getMessage() );
        }
    }

    public function testNumberSetting1()
    {
        $settings = array(
            'Types' => array(
                'Bool' => true,
                'Float' => 3.14,
                'Int' => 42,
                'String' => "Components",
                'Array' => array( 1 => 'Een', 2 => 'Twee' ),
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $float = $configuration->numberSetting( 'Types', 'Float' );
        $this->assertEquals( 3.14, $float );
        try
        {
            $configuration->numberSetting( 'Types', 'Bool' );
            $configuration->numberSetting( 'Types', 'Int' );
            $configuration->numberSetting( 'Types', 'String' );
            $configuration->numberSetting( 'Types', 'Array' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::SETTING_NOT_NUMBER, $e->getCode() );
            $this->assertEquals( "The setting <Types>, <Bool> is not a number.", $e->getMessage() );
        }
    }

    public function testNumberSetting2()
    {
        $settings = array(
            'Types' => array(
                'Bool' => true,
                'Float' => 3.14,
                'Int' => 42,
                'String' => "Components",
                'Array' => array( 1 => 'Een', 2 => 'Twee' ),
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $number = $configuration->numberSetting( 'Types', 'Int' );
        $this->assertEquals( 42, $number );
        try
        {
            $configuration->numberSetting( 'Types', 'String' );
            $configuration->numberSetting( 'Types', 'Bool' );
            $configuration->numberSetting( 'Types', 'Float' );
            $configuration->numberSetting( 'Types', 'Array' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::SETTING_NOT_NUMBER, $e->getCode() );
            $this->assertEquals( "The setting <Types>, <String> is not a number.", $e->getMessage() );
        }
    }

    public function testStringSetting()
    {
        $settings = array(
            'Types' => array(
                'Bool' => true,
                'Float' => 3.14,
                'Int' => 42,
                'String' => "Components",
                'Array' => array( 1 => 'Een', 2 => 'Twee' ),
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $string = $configuration->stringSetting( 'Types', 'String' );
        $this->assertEquals( 'Components', $string );
        try
        {
            $configuration->stringSetting( 'Types', 'Array' );
            $configuration->stringSetting( 'Types', 'Bool' );
            $configuration->stringSetting( 'Types', 'Float' );
            $configuration->stringSetting( 'Types', 'Int' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::SETTING_NOT_STRING, $e->getCode() );
            $this->assertEquals( "The setting <Types>, <Array> is not a string.", $e->getMessage() );
        }
    }

    public function testArraySetting()
    {
        $settings = array(
            'Types' => array(
                'Bool' => true,
                'Float' => 3.14,
                'Int' => 42,
                'String' => "Components",
                'Array' => array( 1 => 'Een', 2 => 'Twee' ),
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $array = $configuration->arraySetting( 'Types', 'Array' );
        $this->assertEquals( array( 1 => 'Een', 2 => 'Twee' ), $array );
        try
        {
            $configuration->arraySetting( 'Types', 'Bool' );
            $configuration->arraySetting( 'Types', 'Float' );
            $configuration->arraySetting( 'Types', 'Int' );
            $configuration->arraySetting( 'Types', 'String' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::SETTING_NOT_ARRAY, $e->getCode() );
            $this->assertEquals( "The setting <Types>, <Bool> is not an array.", $e->getMessage() );
        }
    }

    public function testComment()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
                'SettingNoComment' => 42,
            )
        );
        $comments = array(
            'TheOnlyGroup' => array(
                'Setting1' => 'Comment for setting 1',
            )
        );
        $return = new ezcConfiguration( $settings, $comments );
        $this->assertEquals( 'Comment for setting 1', $return->comment( 'TheOnlyGroup', 'Setting1' ) );
        $this->assertEquals( false, $return->comment( 'TheOnlyGroup', 'SettingNoComment' ) );
    }

    public function testComment2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $dummy = $configuration->comment( 'NonExistingGroup', 'Dummy' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <NonExistingGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testComment3()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $dummy = $configuration->comment( 'TheOnlyGroup', 'NonExistent' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_SETTING, $e->getCode() );
            $this->assertEquals( "The setting <TheOnlyGroup>, <NonExistent> does not exist.", $e->getMessage() );
        }
    }

    public function testSetSettingOverwrite()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing1' => true,
                'Existing2' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );

        $configuration->setSetting( 'TheOnlyGroup', 'Existing1', 'yes' );
        $configuration->setSetting( 'TheOnlyGroup', 'Existing2', 'yes', 'With comment' );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertEquals( 'yes', $configuration->setting( 'TheOnlyGroup', 'Existing1' ) );
        $this->assertEquals( 'yes', $configuration->setting( 'TheOnlyGroup', 'Existing2' ) );
        $this->assertEquals( false, $configuration->comment( 'TheOnlyGroup', 'Existing1' ) );
        $this->assertEquals( 'With comment', $configuration->comment( 'TheOnlyGroup', 'Existing2' ) );
    }

    public function testSetSettingNew()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );

        $configuration->setSetting( 'TheOnlyGroup', 'New1', 42 );
        $configuration->setSetting( 'TheOnlyGroup', 'New2', 43, 'With comment' );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertEquals( 42, $configuration->setting( 'TheOnlyGroup', 'New1' ) );
        $this->assertEquals( 43, $configuration->setting( 'TheOnlyGroup', 'New2' ) );
        $this->assertEquals( false, $configuration->comment( 'TheOnlyGroup', 'New1' ) );
        $this->assertEquals( 'With comment', $configuration->comment( 'TheOnlyGroup', 'New2' ) );
    }

    public function testSettingRemove1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );

        $configuration->removeSetting( 'TheOnlyGroup', 'Setting1' );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertEquals( false, $configuration->hasSetting( 'TheOnlyGroup', 'Setting1' ) );
    }

    public function testSettingRemove2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $dummy = $configuration->removeSetting( 'NonExistingGroup', 'Dummy' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <NonExistingGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testSettingRemove3()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $dummy = $configuration->removeSetting( 'TheOnlyGroup', 'NonExistent' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_SETTING, $e->getCode() );
            $this->assertEquals( "The setting <TheOnlyGroup>, <NonExistent> does not exist.", $e->getMessage() );
        }
    }

    public function testSettingHasSettings()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
                'Setting2' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $found = $configuration->hasSettings( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
        $this->assertEquals( true, $found );
    }

    public function testSettingHasSettings2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $found = $configuration->hasSettings( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
        $this->assertEquals( false, $found );
    }

    public function testSettingHasSettings3()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $found = $configuration->hasSettings( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
        $this->assertEquals( false, $found );
    }

    public function testSettingHasGroup1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $found = $configuration->hasGroup( 'TheOnlyGroup' );
        $this->assertEquals( true, $found );
    }

    public function testSettingHasGroup2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $found = $configuration->hasGroup( 'NonExistingGroup' );
        $this->assertEquals( false, $found );
    }

    public function testSettings1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
                'Setting2' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $found = $configuration->settings( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
        $this->assertEquals( $settings['TheOnlyGroup'], $found );
    }

    public function testSettings2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $found = $configuration->settings( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_SETTING, $e->getCode() );
            $this->assertEquals( "The setting <TheOnlyGroup>, <Setting2> does not exist.", $e->getMessage() );
        }
    }

    public function testSettings3()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $found = $configuration->settings( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <TheOnlyGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testComments1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
                'Setting2' => true,
            )
        );
        $comments = array(
            'TheOnlyGroup' => array(
                'Setting1' => 'Houston, we have a comment!',
            )
        );
        $expected = array(
            'Setting1' => 'Houston, we have a comment!',
            'Setting2' => false,
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        $found = $configuration->comments( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
        $this->assertEquals( $expected, $found );
    }

    public function testComments2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Setting1' => true,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $found = $configuration->comments( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_SETTING, $e->getCode() );
            $this->assertEquals( "The setting <TheOnlyGroup>, <Setting2> does not exist.", $e->getMessage() );
        }
    }

    public function testComments3()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $found = $configuration->comments( 'TheOnlyGroup', array( 'Setting1', 'Setting2' ) );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <TheOnlyGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testSetSettingsOverwrite()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing1' => true,
                'Existing2' => 'true',
                'Existing3' => 1,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );

        $configuration->setSettings(
            'TheOnlyGroup',
            array( 'Existing1', 'Existing2', 'Existing3' ),
            array( false, 'false', 0 ),
            array( 'Comment', null )
        );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertEquals(
            array( 'Existing1' => false, 'Existing2' => 'false', 'Existing3' => 0 ),
            $configuration->settings( 'TheOnlyGroup', array( 'Existing1', 'Existing2', 'Existing3' ) )
        );
        $this->assertEquals(
            array( 'Existing1' => 'Comment', 'Existing2' => false, 'Existing3' => false ),
            $configuration->comments( 'TheOnlyGroup', array( 'Existing1', 'Existing2', 'Existing3' ) )
        );
    }

    public function testSetSettingsNew()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );

        $configuration->setSettings( 'TheOnlyGroup', array( 'Existing1', 'Existing2', 'Existing3' ), array( false, 'false', 0 ) );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertEquals(
            array( 'Existing1' => false, 'Existing2' => 'false', 'Existing3' => 0 ),
            $configuration->settings( 'TheOnlyGroup', array( 'Existing1', 'Existing2', 'Existing3' ) )
        );
    }

    public function testSettingsInGroup1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing1' => true,
                'Existing2' => 'true',
                'Existing3' => 1,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertEquals(
            array( 'Existing1' => true, 'Existing2' => 'true', 'Existing3' => 1 ),
            $configuration->settingsInGroup( 'TheOnlyGroup' )
        );
    }

    public function testSettingsInGroup2()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        try
        {
            $configuration->settingsInGroup( 'TheOnlyGroup' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <TheOnlyGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testRemoveSettings()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing1' => true,
                'Existing2' => 'true',
                'Existing3' => 1,
            )
        );
        $comments = array(
            'TheOnlyGroup' => array(
                'Existing1' => 'Comment1',
                'Existing2' => 'Comment2',
            )
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );

        $configuration->removeSettings( 'TheOnlyGroup', array( 'Existing1' ) );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertEquals(
            array( 'Existing2' => 'true', 'Existing3' => 1 ),
            $configuration->settingsInGroup( 'TheOnlyGroup' )
        );
        $this->assertEquals( false, $configuration->hasSetting( 'TheOnlyGroup', 'Existing1' ) );
    }

    public function testAddGroup1()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );

        $found = $configuration->addGroup( 'TheOnlyGroup', 'A comment' );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertPrivatePropertySame( $configuration, 'comments', array( 'TheOnlyGroup' => array( '#' => 'A comment' ) ) );
    }

    public function testAddGroup2()
    {
        $settings = array(
            'TheOnlyGroup' => array(
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );

        try
        {
            $found = $configuration->addGroup( 'TheOnlyGroup', 'A comment' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::GROUP_ALREADY_EXISTS, $e->getCode() );
            $this->assertEquals( "The settings group <TheOnlyGroup> already exists.", $e->getMessage() );
        }
    }

    public function testSettingsNames1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing1' => true,
                'Existing2' => 'true',
                'Existing3' => 1,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertEquals(
            array( 'Existing1', 'Existing2', 'Existing3' ),
            $configuration->settingNames( 'TheOnlyGroup' )
        );
    }

    public function testSettingsNames2()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        try
        {
            $configuration->settingNames( 'TheOnlyGroup' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <TheOnlyGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testRemoveGroup1()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing1' => true,
                'Existing2' => 'true',
                'Existing3' => 1,
            )
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $configuration->removeGroup( 'TheOnlyGroup' );
        $this->assertEquals( false, $configuration->hasGroup( 'TheOnlyGroup' ) );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
    }

    public function testRemoveGroup2()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        try
        {
            $configuration->removeGroup( 'TheOnlyGroup' );
            $this->fail( "Expected exception not thrown" );
        }
        catch ( ezcConfigurationException $e )
        {
            $this->assertEquals( ezcConfigurationException::UNKNOWN_GROUP, $e->getCode() );
            $this->assertEquals( "The settings group <TheOnlyGroup> does not exist.", $e->getMessage() );
        }
    }

    public function testRemoveAllSettings()
    {
        $settings = array(
            'TheOnlyGroup' => array(
                'Existing1' => true,
            ),
            'TheSecondOnlyGroup' => array(
                'Existing1' => true,
            ),
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $configuration->removeAllSettings();
        $this->assertEquals( false, $configuration->hasGroup( 'TheOnlyGroup' ) );
        $this->assertEquals( false, $configuration->hasGroup( 'TheSecondOnlyGroup' ) );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
    }

    public function testIsModified()
    {
        $settings = array(
        );
        $comments = array(
        );
        $configuration = new ezcConfiguration( $settings, $comments );
        $this->assertPrivatePropertySame( $configuration, 'isModified', false );
        $this->assertEquals( false, $configuration->isModified() );

        $found = $configuration->addGroup( 'TheOnlyGroup', 'A comment' );
        $this->assertPrivatePropertySame( $configuration, 'isModified', true );
        $this->assertEquals( true, $configuration->isModified() );
    }

    public static function suite()
    {
         return new ezcTestSuite( 'ezcConfigurationTest' );
    }

}

?>