[wxWidgets.git] / tests / fileconf / fileconftest.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/fileconf/fileconf.cpp
// Purpose:     wxFileConf unit test
// Author:      Vadim Zeitlin
// Created:     2004-09-19
// RCS-ID:      $Id$
// Copyright:   (c) 2004 Vadim Zeitlin
///////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_FILECONFIG

#ifndef WX_PRECOMP
#endif // WX_PRECOMP

#include "wx/fileconf.h"
#include "wx/sstream.h"
#include "wx/log.h"

static const wxChar *testconfig =
_T("[root]\n")
_T("entry=value\n")
_T("[root/group1]\n")
_T("[root/group1/subgroup]\n")
_T("subentry=subvalue\n")
_T("subentry2=subvalue2\n")
_T("[root/group2]\n")
;

// ----------------------------------------------------------------------------
// local functions
// ----------------------------------------------------------------------------

static wxString Dump(wxFileConfig& fc)
{
    wxStringOutputStream sos;
    fc.Save(sos);
    return wxTextFile::Translate(sos.GetString(), wxTextFileType_Unix);
}

// helper macro to test wxFileConfig contents
#define wxVERIFY_FILECONFIG(t, fc) CPPUNIT_ASSERT_EQUAL(wxString(t), Dump(fc))

// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------

class FileConfigTestCase : public CppUnit::TestCase
{
public:
    FileConfigTestCase() { }

private:
    CPPUNIT_TEST_SUITE( FileConfigTestCase );
        CPPUNIT_TEST( Path );
        CPPUNIT_TEST( AddEntries );
        CPPUNIT_TEST( GetEntries );
        CPPUNIT_TEST( GetGroups );
        CPPUNIT_TEST( HasEntry );
        CPPUNIT_TEST( HasGroup );
        CPPUNIT_TEST( Save );
        CPPUNIT_TEST( DeleteEntry );
        CPPUNIT_TEST( DeleteGroup );
        CPPUNIT_TEST( DeleteAll );
        CPPUNIT_TEST( RenameEntry );
        CPPUNIT_TEST( RenameGroup );
        CPPUNIT_TEST( CreateEntriesAndSubgroup );
        CPPUNIT_TEST( CreateSubgroupAndEntries );
        CPPUNIT_TEST( DeleteLastGroup );
        CPPUNIT_TEST( DeleteAndRecreateGroup );
    CPPUNIT_TEST_SUITE_END();

    void Path();
    void AddEntries();
    void GetEntries();
    void GetGroups();
    void HasEntry();
    void HasGroup();
    void Save();
    void DeleteEntry();
    void DeleteGroup();
    void DeleteAll();
    void RenameEntry();
    void RenameGroup();
    void CreateEntriesAndSubgroup();
    void CreateSubgroupAndEntries();
    void DeleteLastGroup();
    void DeleteAndRecreateGroup();

    static wxString ChangePath(wxFileConfig& fc, const wxChar *path)
    {
        fc.SetPath(path);

        return fc.GetPath();
    }

    void CheckGroupEntries(const wxFileConfig& fc,
                           const wxChar *path,
                           size_t nEntries,
                           ...);
    void CheckGroupSubgroups(const wxFileConfig& fc,
                             const wxChar *path,
                             size_t nGroups,
                             ...);

    DECLARE_NO_COPY_CLASS(FileConfigTestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( FileConfigTestCase );

// also include in it's own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileConfigTestCase, "FileConfigTestCase" );

void FileConfigTestCase::Path()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CPPUNIT_ASSERT( ChangePath(fc, _T("")) == _T("") );
    CPPUNIT_ASSERT( ChangePath(fc, _T("/")) == _T("") );
    CPPUNIT_ASSERT( ChangePath(fc, _T("root")) == _T("/root") );
    CPPUNIT_ASSERT( ChangePath(fc, _T("/root")) == _T("/root") );
    CPPUNIT_ASSERT( ChangePath(fc, _T("/root/group1/subgroup")) == _T("/root/group1/subgroup") );
    CPPUNIT_ASSERT( ChangePath(fc, _T("/root/group2")) == _T("/root/group2") );
}

void FileConfigTestCase::AddEntries()
{
    wxFileConfig fc;

    wxVERIFY_FILECONFIG( _T(""), fc  );

    fc.Write(_T("/Foo"), _T("foo"));
    wxVERIFY_FILECONFIG( _T("Foo=foo\n"), fc  );

    fc.Write(_T("/Bar/Baz"), _T("baz"));
    wxVERIFY_FILECONFIG( _T("Foo=foo\n[Bar]\nBaz=baz\n"), fc  );

    fc.DeleteAll();
    wxVERIFY_FILECONFIG( _T(""), fc  );

    fc.Write(_T("/Bar/Baz"), _T("baz"));
    wxVERIFY_FILECONFIG( _T("[Bar]\nBaz=baz\n"), fc  );

    fc.Write(_T("/Foo"), _T("foo"));
    wxVERIFY_FILECONFIG( _T("Foo=foo\n[Bar]\nBaz=baz\n"), fc  );
}

void
FileConfigTestCase::CheckGroupEntries(const wxFileConfig& fc,
                                      const wxChar *path,
                                      size_t nEntries,
                                      ...)
{
    wxConfigPathChanger change(&fc, wxString(path) + _T("/"));

    CPPUNIT_ASSERT( fc.GetNumberOfEntries() == nEntries );

    va_list ap;
    va_start(ap, nEntries);

    long cookie;
    wxString name;
    for ( bool cont = fc.GetFirstEntry(name, cookie);
          cont;
          cont = fc.GetNextEntry(name, cookie), nEntries-- )
    {
        CPPUNIT_ASSERT( name == va_arg(ap, wxChar *) );
    }

    CPPUNIT_ASSERT( nEntries == 0 );

    va_end(ap);
}

void
FileConfigTestCase::CheckGroupSubgroups(const wxFileConfig& fc,
                                        const wxChar *path,
                                        size_t nGroups,
                                        ...)
{
    wxConfigPathChanger change(&fc, wxString(path) + _T("/"));

    CPPUNIT_ASSERT( fc.GetNumberOfGroups() == nGroups );

    va_list ap;
    va_start(ap, nGroups);

    long cookie;
    wxString name;
    for ( bool cont = fc.GetFirstGroup(name, cookie);
          cont;
          cont = fc.GetNextGroup(name, cookie), nGroups-- )
    {
        CPPUNIT_ASSERT( name == va_arg(ap, wxChar *) );
    }

    CPPUNIT_ASSERT( nGroups == 0 );

    va_end(ap);
}

void FileConfigTestCase::GetEntries()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CheckGroupEntries(fc, _T(""), 0);
    CheckGroupEntries(fc, _T("/root"), 1, _T("entry"));
    CheckGroupEntries(fc, _T("/root/group1"), 0);
    CheckGroupEntries(fc, _T("/root/group1/subgroup"),
                        2, _T("subentry"), _T("subentry2"));
}

void FileConfigTestCase::GetGroups()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CheckGroupSubgroups(fc, _T(""), 1, _T("root"));
    CheckGroupSubgroups(fc, _T("/root"), 2, _T("group1"), _T("group2"));
    CheckGroupSubgroups(fc, _T("/root/group1"), 1, _T("subgroup"));
    CheckGroupSubgroups(fc, _T("/root/group2"), 0);
}

void FileConfigTestCase::HasEntry()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CPPUNIT_ASSERT( !fc.HasEntry(_T("root")) );
    CPPUNIT_ASSERT( fc.HasEntry(_T("root/entry")) );
    CPPUNIT_ASSERT( fc.HasEntry(_T("/root/entry")) );
    CPPUNIT_ASSERT( fc.HasEntry(_T("root/group1/subgroup/subentry")) );
    CPPUNIT_ASSERT( !fc.HasEntry(_T("")) );
    CPPUNIT_ASSERT( !fc.HasEntry(_T("root/group1")) );
    CPPUNIT_ASSERT( !fc.HasEntry(_T("subgroup/subentry")) );
    CPPUNIT_ASSERT( !fc.HasEntry(_T("/root/no_such_group/entry")) );
    CPPUNIT_ASSERT( !fc.HasGroup(_T("/root/no_such_group")) );
}

void FileConfigTestCase::HasGroup()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CPPUNIT_ASSERT( fc.HasGroup(_T("root")) );
    CPPUNIT_ASSERT( fc.HasGroup(_T("root/group1")) );
    CPPUNIT_ASSERT( fc.HasGroup(_T("root/group1/subgroup")) );
    CPPUNIT_ASSERT( fc.HasGroup(_T("root/group2")) );
    CPPUNIT_ASSERT( !fc.HasGroup(_T("")) );
    CPPUNIT_ASSERT( !fc.HasGroup(_T("root/group")) );
    CPPUNIT_ASSERT( !fc.HasGroup(_T("root//subgroup")) );
    CPPUNIT_ASSERT( !fc.HasGroup(_T("foot/subgroup")) );
    CPPUNIT_ASSERT( !fc.HasGroup(_T("foot")) );
}

void FileConfigTestCase::Save()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);
    wxVERIFY_FILECONFIG( testconfig, fc );
}

void FileConfigTestCase::DeleteEntry()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CPPUNIT_ASSERT( !fc.DeleteEntry(_T("foo")) );

    CPPUNIT_ASSERT( fc.DeleteEntry(_T("root/group1/subgroup/subentry")) );
    wxVERIFY_FILECONFIG( _T("[root]\n")
                         _T("entry=value\n")
                         _T("[root/group1]\n")
                         _T("[root/group1/subgroup]\n")
                         _T("subentry2=subvalue2\n")
                         _T("[root/group2]\n"),
                         fc );

    // group should be deleted now as well as it became empty
    wxConfigPathChanger change(&fc, _T("root/group1/subgroup/subentry2"));
    CPPUNIT_ASSERT( fc.DeleteEntry(_T("subentry2")) );
    wxVERIFY_FILECONFIG( _T("[root]\n")
                         _T("entry=value\n")
                         _T("[root/group1]\n")
                         _T("[root/group2]\n"),
                         fc );
}

void FileConfigTestCase::DeleteGroup()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CPPUNIT_ASSERT( !fc.DeleteGroup(_T("foo")) );

    CPPUNIT_ASSERT( fc.DeleteGroup(_T("root/group1")) );
    wxVERIFY_FILECONFIG( _T("[root]\n")
                         _T("entry=value\n")
                         _T("[root/group2]\n"),
                         fc );

    // notice trailing slash: it should be ignored
    CPPUNIT_ASSERT( fc.DeleteGroup(_T("root/group2/")) );
    wxVERIFY_FILECONFIG( _T("[root]\n")
                         _T("entry=value\n"),
                         fc );

    CPPUNIT_ASSERT( fc.DeleteGroup(_T("root")) );
    CPPUNIT_ASSERT( Dump(fc).empty() );
}

void FileConfigTestCase::DeleteAll()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CPPUNIT_ASSERT( fc.DeleteAll() );
    CPPUNIT_ASSERT( Dump(fc).empty() );
}

void FileConfigTestCase::RenameEntry()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    fc.SetPath(_T("root"));
    CPPUNIT_ASSERT( fc.RenameEntry(_T("entry"), _T("newname")) );
    wxVERIFY_FILECONFIG( _T("[root]\n")
                         _T("newname=value\n")
                         _T("[root/group1]\n")
                         _T("[root/group1/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[root/group2]\n"),
                         fc );

    fc.SetPath(_T("group1/subgroup"));
    CPPUNIT_ASSERT( !fc.RenameEntry(_T("entry"), _T("newname")) );
    CPPUNIT_ASSERT( !fc.RenameEntry(_T("subentry"), _T("subentry2")) );

    CPPUNIT_ASSERT( fc.RenameEntry(_T("subentry"), _T("subentry1")) );
    wxVERIFY_FILECONFIG( _T("[root]\n")
                         _T("newname=value\n")
                         _T("[root/group1]\n")
                         _T("[root/group1/subgroup]\n")
                         _T("subentry2=subvalue2\n")
                         _T("subentry1=subvalue\n")
                         _T("[root/group2]\n"),
                         fc );
}

void FileConfigTestCase::RenameGroup()
{
    wxStringInputStream sis(testconfig);
    wxFileConfig fc(sis);

    CPPUNIT_ASSERT( fc.RenameGroup(_T("root"), _T("foot")) );
    wxVERIFY_FILECONFIG( _T("[foot]\n")
                         _T("entry=value\n")
                         _T("[foot/group1]\n")
                         _T("[foot/group1/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[foot/group2]\n"),
                         fc );

    // renaming a path doesn't work, it must be the immediate group
    CPPUNIT_ASSERT( !fc.RenameGroup(_T("foot/group1"), _T("group2")) );


    fc.SetPath(_T("foot"));

    // renaming to a name of existing group doesn't work
    CPPUNIT_ASSERT( !fc.RenameGroup(_T("group1"), _T("group2")) );

    // try exchanging the groups names and then restore them back
    CPPUNIT_ASSERT( fc.RenameGroup(_T("group1"), _T("groupTmp")) );
    wxVERIFY_FILECONFIG( _T("[foot]\n")
                         _T("entry=value\n")
                         _T("[foot/groupTmp]\n")
                         _T("[foot/groupTmp/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[foot/group2]\n"),
                         fc );

    CPPUNIT_ASSERT( fc.RenameGroup(_T("group2"), _T("group1")) );
    wxVERIFY_FILECONFIG( _T("[foot]\n")
                         _T("entry=value\n")
                         _T("[foot/groupTmp]\n")
                         _T("[foot/groupTmp/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[foot/group1]\n"),
                         fc );

    CPPUNIT_ASSERT( fc.RenameGroup(_T("groupTmp"), _T("group2")) );
    wxVERIFY_FILECONFIG( _T("[foot]\n")
                         _T("entry=value\n")
                         _T("[foot/group2]\n")
                         _T("[foot/group2/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[foot/group1]\n"),
                         fc );

    CPPUNIT_ASSERT( fc.RenameGroup(_T("group1"), _T("groupTmp")) );
    wxVERIFY_FILECONFIG( _T("[foot]\n")
                         _T("entry=value\n")
                         _T("[foot/group2]\n")
                         _T("[foot/group2/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[foot/groupTmp]\n"),
                         fc );

    CPPUNIT_ASSERT( fc.RenameGroup(_T("group2"), _T("group1")) );
    wxVERIFY_FILECONFIG( _T("[foot]\n")
                         _T("entry=value\n")
                         _T("[foot/group1]\n")
                         _T("[foot/group1/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[foot/groupTmp]\n"),
                         fc );

    CPPUNIT_ASSERT( fc.RenameGroup(_T("groupTmp"), _T("group2")) );
    wxVERIFY_FILECONFIG( _T("[foot]\n")
                         _T("entry=value\n")
                         _T("[foot/group1]\n")
                         _T("[foot/group1/subgroup]\n")
                         _T("subentry=subvalue\n")
                         _T("subentry2=subvalue2\n")
                         _T("[foot/group2]\n"),
                         fc );
}

void FileConfigTestCase::CreateSubgroupAndEntries()
{
    wxFileConfig fc;
    fc.Write(_T("sub/sub_first"), _T("sub_one"));
    fc.Write(_T("first"), _T("one"));

    wxVERIFY_FILECONFIG( _T("first=one\n")
                         _T("[sub]\n")
                         _T("sub_first=sub_one\n"),
                         fc );
}

void FileConfigTestCase::CreateEntriesAndSubgroup()
{
    wxFileConfig fc;
    fc.Write(_T("first"), _T("one"));
    fc.Write(_T("second"), _T("two"));
    fc.Write(_T("sub/sub_first"), _T("sub_one"));

    wxVERIFY_FILECONFIG( _T("first=one\n")
                         _T("second=two\n")
                         _T("[sub]\n")
                         _T("sub_first=sub_one\n"),
                         fc );
}

static void EmptyConfigAndWriteKey()
{
    wxFileConfig fc(_T("deleteconftest"));

    const wxString groupPath = _T("/root");

    if ( fc.Exists(groupPath) )
    {
        // using DeleteGroup exposes the problem, using DeleteAll doesn't
        CPPUNIT_ASSERT( fc.DeleteGroup(groupPath) );
    }

    // the config must be empty for the problem to arise
    CPPUNIT_ASSERT( !fc.GetNumberOfEntries(true) );
    CPPUNIT_ASSERT( !fc.GetNumberOfGroups(true) );


    // this crashes on second call of this function
    CPPUNIT_ASSERT( fc.Write(groupPath + _T("/entry"), _T("value")) );
}

void FileConfigTestCase::DeleteLastGroup()
{
    /*
    We make 2 of the same calls, first to create a file config with a single
    group and key...
    */
    ::EmptyConfigAndWriteKey();

    /*
    ... then the same but this time the key's group is deleted before the
    key is written again. This causes a crash.
    */
    ::EmptyConfigAndWriteKey();


    // clean up
    wxLogNull noLogging;
    (void) ::wxRemoveFile(wxFileConfig::GetLocalFileName(_T("deleteconftest")));
}

void FileConfigTestCase::DeleteAndRecreateGroup()
{
    static const wxChar *confInitial =
        _T("[First]\n")
        _T("Value1=Foo\n")
        _T("[Second]\n")
        _T("Value2=Bar\n");

    wxStringInputStream sis(confInitial);
    wxFileConfig fc(sis);

    fc.DeleteGroup(_T("Second"));
    wxVERIFY_FILECONFIG( _T("[First]\n")
                         _T("Value1=Foo\n"),
                         fc );

    fc.Write(_T("Second/Value2"), _T("New"));
    wxVERIFY_FILECONFIG( _T("[First]\n")
                         _T("Value1=Foo\n")
                         _T("[Second]\n")
                         _T("Value2=New\n"),
                         fc );
}

#endif // wxUSE_FILECONFIG
Commit	Line	Data
17c24d37 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/fileconf/fileconf.cpp
	3	// Purpose: wxFileConf unit test
	4	// Author: Vadim Zeitlin
	5	// Created: 2004-09-19
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2004 Vadim Zeitlin
	8	///////////////////////////////////////////////////////////////////////////////
	9
	10	// ----------------------------------------------------------------------------
	11	// headers
	12	// ----------------------------------------------------------------------------
	13
8899b155	14	#include "testprec.h"
17c24d37 VZ	15
	16	#ifdef __BORLANDC__
	17	#pragma hdrstop
	18	#endif
	19
	20	#if wxUSE_FILECONFIG
	21
	22	#ifndef WX_PRECOMP
	23	#endif // WX_PRECOMP
	24
	25	#include "wx/fileconf.h"
	26	#include "wx/sstream.h"
ca7766b4	27	#include "wx/log.h"
17c24d37 VZ	28
	29	static const wxChar *testconfig =
	30	_T("[root]\n")
	31	_T("entry=value\n")
	32	_T("[root/group1]\n")
	33	_T("[root/group1/subgroup]\n")
	34	_T("subentry=subvalue\n")
9db6158a	35	_T("subentry2=subvalue2\n")
17c24d37 VZ	36	_T("[root/group2]\n")
	37	;
	38
e1a2c7a5 VZ	39	// ----------------------------------------------------------------------------
	40	// local functions
	41	// ----------------------------------------------------------------------------
	42
	43	static wxString Dump(wxFileConfig& fc)
	44	{
	45	wxStringOutputStream sos;
	46	fc.Save(sos);
	47	return wxTextFile::Translate(sos.GetString(), wxTextFileType_Unix);
	48	}
	49
	50	// helper macro to test wxFileConfig contents
	51	#define wxVERIFY_FILECONFIG(t, fc) CPPUNIT_ASSERT_EQUAL(wxString(t), Dump(fc))
	52
17c24d37 VZ	53	// ----------------------------------------------------------------------------
	54	// test class
	55	// ----------------------------------------------------------------------------
	56
	57	class FileConfigTestCase : public CppUnit::TestCase
	58	{
	59	public:
8899b155	60	FileConfigTestCase() { }
17c24d37 VZ	61
	62	private:
	63	CPPUNIT_TEST_SUITE( FileConfigTestCase );
9db6158a	64	CPPUNIT_TEST( Path );
bd2fe27e	65	CPPUNIT_TEST( AddEntries );
9db6158a VZ	66	CPPUNIT_TEST( GetEntries );
	67	CPPUNIT_TEST( GetGroups );
	68	CPPUNIT_TEST( HasEntry );
17c24d37	69	CPPUNIT_TEST( HasGroup );
94139118 VZ	70	CPPUNIT_TEST( Save );
	71	CPPUNIT_TEST( DeleteEntry );
	72	CPPUNIT_TEST( DeleteGroup );
	73	CPPUNIT_TEST( DeleteAll );
	74	CPPUNIT_TEST( RenameEntry );
	75	CPPUNIT_TEST( RenameGroup );
c406cd3d VZ	76	CPPUNIT_TEST( CreateEntriesAndSubgroup );
c406cd3d VZ	77	CPPUNIT_TEST( CreateSubgroupAndEntries );
cbc9c06f	78	CPPUNIT_TEST( DeleteLastGroup );
6ad0a7d5	79	CPPUNIT_TEST( DeleteAndRecreateGroup );
17c24d37 VZ	80	CPPUNIT_TEST_SUITE_END();
17c24d37 VZ	81
9db6158a	82	void Path();
bd2fe27e	83	void AddEntries();
9db6158a VZ	84	void GetEntries();
	85	void GetGroups();
	86	void HasEntry();
17c24d37	87	void HasGroup();
94139118 VZ	88	void Save();
	89	void DeleteEntry();
	90	void DeleteGroup();
	91	void DeleteAll();
	92	void RenameEntry();
	93	void RenameGroup();
c406cd3d VZ	94	void CreateEntriesAndSubgroup();
c406cd3d VZ	95	void CreateSubgroupAndEntries();
cbc9c06f	96	void DeleteLastGroup();
6ad0a7d5	97	void DeleteAndRecreateGroup();
17c24d37	98
9db6158a VZ	99	static wxString ChangePath(wxFileConfig& fc, const wxChar *path)
	100	{
	101	fc.SetPath(path);
	102
	103	return fc.GetPath();
	104	}
	105
	106	void CheckGroupEntries(const wxFileConfig& fc,
	107	const wxChar *path,
	108	size_t nEntries,
	109	...);
	110	void CheckGroupSubgroups(const wxFileConfig& fc,
	111	const wxChar *path,
	112	size_t nGroups,
	113	...);
	114
17c24d37 VZ	115	DECLARE_NO_COPY_CLASS(FileConfigTestCase)
	116	};
	117
	118	// register in the unnamed registry so that these tests are run by default
	119	CPPUNIT_TEST_SUITE_REGISTRATION( FileConfigTestCase );
	120
	121	// also include in it's own registry so that these tests can be run alone
	122	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileConfigTestCase, "FileConfigTestCase" );
	123
9db6158a VZ	124	void FileConfigTestCase::Path()
	125	{
	126	wxStringInputStream sis(testconfig);
	127	wxFileConfig fc(sis);
	128
	129	CPPUNIT_ASSERT( ChangePath(fc, _T("")) == _T("") );
	130	CPPUNIT_ASSERT( ChangePath(fc, _T("/")) == _T("") );
	131	CPPUNIT_ASSERT( ChangePath(fc, _T("root")) == _T("/root") );
	132	CPPUNIT_ASSERT( ChangePath(fc, _T("/root")) == _T("/root") );
	133	CPPUNIT_ASSERT( ChangePath(fc, _T("/root/group1/subgroup")) == _T("/root/group1/subgroup") );
	134	CPPUNIT_ASSERT( ChangePath(fc, _T("/root/group2")) == _T("/root/group2") );
	135	}
	136
bd2fe27e VZ	137	void FileConfigTestCase::AddEntries()
	138	{
	139	wxFileConfig fc;
	140
e1a2c7a5	141	wxVERIFY_FILECONFIG( _T(""), fc );
bd2fe27e VZ	142
bd2fe27e VZ	143	fc.Write(_T("/Foo"), _T("foo"));
e1a2c7a5	144	wxVERIFY_FILECONFIG( _T("Foo=foo\n"), fc );
bd2fe27e VZ	145
bd2fe27e VZ	146	fc.Write(_T("/Bar/Baz"), _T("baz"));
e1a2c7a5	147	wxVERIFY_FILECONFIG( _T("Foo=foo\n[Bar]\nBaz=baz\n"), fc );
bd2fe27e VZ	148
bd2fe27e VZ	149	fc.DeleteAll();
e1a2c7a5	150	wxVERIFY_FILECONFIG( _T(""), fc );
bd2fe27e VZ	151
bd2fe27e VZ	152	fc.Write(_T("/Bar/Baz"), _T("baz"));
e1a2c7a5	153	wxVERIFY_FILECONFIG( _T("[Bar]\nBaz=baz\n"), fc );
bd2fe27e VZ	154
bd2fe27e VZ	155	fc.Write(_T("/Foo"), _T("foo"));
e1a2c7a5	156	wxVERIFY_FILECONFIG( _T("Foo=foo\n[Bar]\nBaz=baz\n"), fc );
bd2fe27e VZ	157	}
bd2fe27e VZ	158
9db6158a VZ	159	void
	160	FileConfigTestCase::CheckGroupEntries(const wxFileConfig& fc,
	161	const wxChar *path,
	162	size_t nEntries,
	163	...)
	164	{
	165	wxConfigPathChanger change(&fc, wxString(path) + _T("/"));
	166
	167	CPPUNIT_ASSERT( fc.GetNumberOfEntries() == nEntries );
	168
	169	va_list ap;
	170	va_start(ap, nEntries);
	171
	172	long cookie;
	173	wxString name;
	174	for ( bool cont = fc.GetFirstEntry(name, cookie);
	175	cont;
	176	cont = fc.GetNextEntry(name, cookie), nEntries-- )
	177	{
	178	CPPUNIT_ASSERT( name == va_arg(ap, wxChar *) );
	179	}
	180
	181	CPPUNIT_ASSERT( nEntries == 0 );
	182
	183	va_end(ap);
	184	}
	185
	186	void
	187	FileConfigTestCase::CheckGroupSubgroups(const wxFileConfig& fc,
	188	const wxChar *path,
	189	size_t nGroups,
	190	...)
	191	{
	192	wxConfigPathChanger change(&fc, wxString(path) + _T("/"));
	193
	194	CPPUNIT_ASSERT( fc.GetNumberOfGroups() == nGroups );
	195
	196	va_list ap;
	197	va_start(ap, nGroups);
	198
	199	long cookie;
	200	wxString name;
	201	for ( bool cont = fc.GetFirstGroup(name, cookie);
	202	cont;
	203	cont = fc.GetNextGroup(name, cookie), nGroups-- )
	204	{
	205	CPPUNIT_ASSERT( name == va_arg(ap, wxChar *) );
	206	}
	207
	208	CPPUNIT_ASSERT( nGroups == 0 );
	209
	210	va_end(ap);
	211	}
	212
	213	void FileConfigTestCase::GetEntries()
	214	{
	215	wxStringInputStream sis(testconfig);
	216	wxFileConfig fc(sis);
	217
	218	CheckGroupEntries(fc, _T(""), 0);
	219	CheckGroupEntries(fc, _T("/root"), 1, _T("entry"));
	220	CheckGroupEntries(fc, _T("/root/group1"), 0);
	221	CheckGroupEntries(fc, _T("/root/group1/subgroup"),
	222	2, _T("subentry"), _T("subentry2"));
223	}
224
225	void FileConfigTestCase::GetGroups()
226	{
227	wxStringInputStream sis(testconfig);
228	wxFileConfig fc(sis);
229
230	CheckGroupSubgroups(fc, _T(""), 1, _T("root"));
231	CheckGroupSubgroups(fc, _T("/root"), 2, _T("group1"), _T("group2"));
232	CheckGroupSubgroups(fc, _T("/root/group1"), 1, _T("subgroup"));
233	CheckGroupSubgroups(fc, _T("/root/group2"), 0);
234	}
235
236	void FileConfigTestCase::HasEntry()
237	{
238	wxStringInputStream sis(testconfig);
239	wxFileConfig fc(sis);
240
241	CPPUNIT_ASSERT( !fc.HasEntry(_T("root")) );
242	CPPUNIT_ASSERT( fc.HasEntry(_T("root/entry")) );
243	CPPUNIT_ASSERT( fc.HasEntry(_T("/root/entry")) );
244	CPPUNIT_ASSERT( fc.HasEntry(_T("root/group1/subgroup/subentry")) );
245	CPPUNIT_ASSERT( !fc.HasEntry(_T("")) );
246	CPPUNIT_ASSERT( !fc.HasEntry(_T("root/group1")) );
247	CPPUNIT_ASSERT( !fc.HasEntry(_T("subgroup/subentry")) );
b0db68b2 VZ	248	CPPUNIT_ASSERT( !fc.HasEntry(_T("/root/no_such_group/entry")) );
b0db68b2 VZ	249	CPPUNIT_ASSERT( !fc.HasGroup(_T("/root/no_such_group")) );
9db6158a VZ	250	}
9db6158a VZ	251
17c24d37 VZ	252	void FileConfigTestCase::HasGroup()
	253	{
	254	wxStringInputStream sis(testconfig);
	255	wxFileConfig fc(sis);
	256
	257	CPPUNIT_ASSERT( fc.HasGroup(_T("root")) );
	258	CPPUNIT_ASSERT( fc.HasGroup(_T("root/group1")) );
	259	CPPUNIT_ASSERT( fc.HasGroup(_T("root/group1/subgroup")) );
	260	CPPUNIT_ASSERT( fc.HasGroup(_T("root/group2")) );
17c24d37 VZ	261	CPPUNIT_ASSERT( !fc.HasGroup(_T("")) );
	262	CPPUNIT_ASSERT( !fc.HasGroup(_T("root/group")) );
	263	CPPUNIT_ASSERT( !fc.HasGroup(_T("root//subgroup")) );
993896f1 VZ	264	CPPUNIT_ASSERT( !fc.HasGroup(_T("foot/subgroup")) );
993896f1 VZ	265	CPPUNIT_ASSERT( !fc.HasGroup(_T("foot")) );
17c24d37 VZ	266	}
17c24d37 VZ	267
94139118 VZ	268	void FileConfigTestCase::Save()
	269	{
	270	wxStringInputStream sis(testconfig);
	271	wxFileConfig fc(sis);
e1a2c7a5	272	wxVERIFY_FILECONFIG( testconfig, fc );
94139118 VZ	273	}
	274
	275	void FileConfigTestCase::DeleteEntry()
	276	{
	277	wxStringInputStream sis(testconfig);
	278	wxFileConfig fc(sis);
	279
	280	CPPUNIT_ASSERT( !fc.DeleteEntry(_T("foo")) );
	281
	282	CPPUNIT_ASSERT( fc.DeleteEntry(_T("root/group1/subgroup/subentry")) );
e1a2c7a5 VZ	283	wxVERIFY_FILECONFIG( _T("[root]\n")
	284	_T("entry=value\n")
	285	_T("[root/group1]\n")
	286	_T("[root/group1/subgroup]\n")
	287	_T("subentry2=subvalue2\n")
	288	_T("[root/group2]\n"),
	289	fc );
94139118 VZ	290
	291	// group should be deleted now as well as it became empty
	292	wxConfigPathChanger change(&fc, _T("root/group1/subgroup/subentry2"));
	293	CPPUNIT_ASSERT( fc.DeleteEntry(_T("subentry2")) );
e1a2c7a5 VZ	294	wxVERIFY_FILECONFIG( _T("[root]\n")
	295	_T("entry=value\n")
	296	_T("[root/group1]\n")
	297	_T("[root/group2]\n"),
	298	fc );
94139118 VZ	299	}
	300
	301	void FileConfigTestCase::DeleteGroup()
	302	{
	303	wxStringInputStream sis(testconfig);
	304	wxFileConfig fc(sis);
	305
	306	CPPUNIT_ASSERT( !fc.DeleteGroup(_T("foo")) );
	307
	308	CPPUNIT_ASSERT( fc.DeleteGroup(_T("root/group1")) );
e1a2c7a5 VZ	309	wxVERIFY_FILECONFIG( _T("[root]\n")
	310	_T("entry=value\n")
	311	_T("[root/group2]\n"),
	312	fc );
94139118	313
35c4b4da VZ	314	// notice trailing slash: it should be ignored
35c4b4da VZ	315	CPPUNIT_ASSERT( fc.DeleteGroup(_T("root/group2/")) );
e1a2c7a5 VZ	316	wxVERIFY_FILECONFIG( _T("[root]\n")
	317	_T("entry=value\n"),
	318	fc );
94139118 VZ	319
	320	CPPUNIT_ASSERT( fc.DeleteGroup(_T("root")) );
	321	CPPUNIT_ASSERT( Dump(fc).empty() );
	322	}
	323
	324	void FileConfigTestCase::DeleteAll()
	325	{
	326	wxStringInputStream sis(testconfig);
	327	wxFileConfig fc(sis);
	328
	329	CPPUNIT_ASSERT( fc.DeleteAll() );
	330	CPPUNIT_ASSERT( Dump(fc).empty() );
	331	}
	332
	333	void FileConfigTestCase::RenameEntry()
	334	{
	335	wxStringInputStream sis(testconfig);
	336	wxFileConfig fc(sis);
	337
	338	fc.SetPath(_T("root"));
	339	CPPUNIT_ASSERT( fc.RenameEntry(_T("entry"), _T("newname")) );
e1a2c7a5 VZ	340	wxVERIFY_FILECONFIG( _T("[root]\n")
	341	_T("newname=value\n")
	342	_T("[root/group1]\n")
	343	_T("[root/group1/subgroup]\n")
	344	_T("subentry=subvalue\n")
	345	_T("subentry2=subvalue2\n")
	346	_T("[root/group2]\n"),
	347	fc );
94139118 VZ	348
	349	fc.SetPath(_T("group1/subgroup"));
	350	CPPUNIT_ASSERT( !fc.RenameEntry(_T("entry"), _T("newname")) );
	351	CPPUNIT_ASSERT( !fc.RenameEntry(_T("subentry"), _T("subentry2")) );
	352
	353	CPPUNIT_ASSERT( fc.RenameEntry(_T("subentry"), _T("subentry1")) );
e1a2c7a5 VZ	354	wxVERIFY_FILECONFIG( _T("[root]\n")
	355	_T("newname=value\n")
	356	_T("[root/group1]\n")
	357	_T("[root/group1/subgroup]\n")
	358	_T("subentry2=subvalue2\n")
	359	_T("subentry1=subvalue\n")
	360	_T("[root/group2]\n"),
	361	fc );
94139118 VZ	362	}
	363
	364	void FileConfigTestCase::RenameGroup()
	365	{
	366	wxStringInputStream sis(testconfig);
	367	wxFileConfig fc(sis);
	368
	369	CPPUNIT_ASSERT( fc.RenameGroup(_T("root"), _T("foot")) );
e1a2c7a5 VZ	370	wxVERIFY_FILECONFIG( _T("[foot]\n")
	371	_T("entry=value\n")
	372	_T("[foot/group1]\n")
	373	_T("[foot/group1/subgroup]\n")
	374	_T("subentry=subvalue\n")
	375	_T("subentry2=subvalue2\n")
	376	_T("[foot/group2]\n"),
	377	fc );
3ca10461	378
126bd656 VZ	379	// renaming a path doesn't work, it must be the immediate group
	380	CPPUNIT_ASSERT( !fc.RenameGroup(_T("foot/group1"), _T("group2")) );
	381
	382
3ca10461 VZ	383	fc.SetPath(_T("foot"));
3ca10461 VZ	384
126bd656 VZ	385	// renaming to a name of existing group doesn't work
	386	CPPUNIT_ASSERT( !fc.RenameGroup(_T("group1"), _T("group2")) );
	387
	388	// try exchanging the groups names and then restore them back
3ca10461 VZ	389	CPPUNIT_ASSERT( fc.RenameGroup(_T("group1"), _T("groupTmp")) );
	390	wxVERIFY_FILECONFIG( _T("[foot]\n")
	391	_T("entry=value\n")
	392	_T("[foot/groupTmp]\n")
	393	_T("[foot/groupTmp/subgroup]\n")
	394	_T("subentry=subvalue\n")
	395	_T("subentry2=subvalue2\n")
	396	_T("[foot/group2]\n"),
	397	fc );
	398
	399	CPPUNIT_ASSERT( fc.RenameGroup(_T("group2"), _T("group1")) );
	400	wxVERIFY_FILECONFIG( _T("[foot]\n")
	401	_T("entry=value\n")
	402	_T("[foot/groupTmp]\n")
	403	_T("[foot/groupTmp/subgroup]\n")
	404	_T("subentry=subvalue\n")
	405	_T("subentry2=subvalue2\n")
	406	_T("[foot/group1]\n"),
	407	fc );
	408
	409	CPPUNIT_ASSERT( fc.RenameGroup(_T("groupTmp"), _T("group2")) );
	410	wxVERIFY_FILECONFIG( _T("[foot]\n")
	411	_T("entry=value\n")
	412	_T("[foot/group2]\n")
	413	_T("[foot/group2/subgroup]\n")
	414	_T("subentry=subvalue\n")
	415	_T("subentry2=subvalue2\n")
	416	_T("[foot/group1]\n"),
	417	fc );
126bd656 VZ	418
	419	CPPUNIT_ASSERT( fc.RenameGroup(_T("group1"), _T("groupTmp")) );
	420	wxVERIFY_FILECONFIG( _T("[foot]\n")
	421	_T("entry=value\n")
	422	_T("[foot/group2]\n")
	423	_T("[foot/group2/subgroup]\n")
	424	_T("subentry=subvalue\n")
	425	_T("subentry2=subvalue2\n")
	426	_T("[foot/groupTmp]\n"),
	427	fc );
	428
	429	CPPUNIT_ASSERT( fc.RenameGroup(_T("group2"), _T("group1")) );
	430	wxVERIFY_FILECONFIG( _T("[foot]\n")
	431	_T("entry=value\n")
	432	_T("[foot/group1]\n")
	433	_T("[foot/group1/subgroup]\n")
	434	_T("subentry=subvalue\n")
	435	_T("subentry2=subvalue2\n")
	436	_T("[foot/groupTmp]\n"),
	437	fc );
	438
	439	CPPUNIT_ASSERT( fc.RenameGroup(_T("groupTmp"), _T("group2")) );
	440	wxVERIFY_FILECONFIG( _T("[foot]\n")
	441	_T("entry=value\n")
	442	_T("[foot/group1]\n")
	443	_T("[foot/group1/subgroup]\n")
	444	_T("subentry=subvalue\n")
	445	_T("subentry2=subvalue2\n")
	446	_T("[foot/group2]\n"),
	447	fc );
94139118 VZ	448	}
94139118 VZ	449
c406cd3d VZ	450	void FileConfigTestCase::CreateSubgroupAndEntries()
	451	{
	452	wxFileConfig fc;
	453	fc.Write(_T("sub/sub_first"), _T("sub_one"));
	454	fc.Write(_T("first"), _T("one"));
	455
e1a2c7a5 VZ	456	wxVERIFY_FILECONFIG( _T("first=one\n")
	457	_T("[sub]\n")
	458	_T("sub_first=sub_one\n"),
	459	fc );
c406cd3d VZ	460	}
	461
	462	void FileConfigTestCase::CreateEntriesAndSubgroup()
	463	{
	464	wxFileConfig fc;
	465	fc.Write(_T("first"), _T("one"));
	466	fc.Write(_T("second"), _T("two"));
	467	fc.Write(_T("sub/sub_first"), _T("sub_one"));
	468
e1a2c7a5 VZ	469	wxVERIFY_FILECONFIG( _T("first=one\n")
	470	_T("second=two\n")
	471	_T("[sub]\n")
	472	_T("sub_first=sub_one\n"),
	473	fc );
c406cd3d	474	}
cbc9c06f DS	475
	476	static void EmptyConfigAndWriteKey()
	477	{
	478	wxFileConfig fc(_T("deleteconftest"));
	479
	480	const wxString groupPath = _T("/root");
	481
c406cd3d	482	if ( fc.Exists(groupPath) )
cbc9c06f DS	483	{
	484	// using DeleteGroup exposes the problem, using DeleteAll doesn't
	485	CPPUNIT_ASSERT( fc.DeleteGroup(groupPath) );
	486	}
	487
	488	// the config must be empty for the problem to arise
	489	CPPUNIT_ASSERT( !fc.GetNumberOfEntries(true) );
	490	CPPUNIT_ASSERT( !fc.GetNumberOfGroups(true) );
	491
	492
	493	// this crashes on second call of this function
	494	CPPUNIT_ASSERT( fc.Write(groupPath + _T("/entry"), _T("value")) );
	495	}
	496
	497	void FileConfigTestCase::DeleteLastGroup()
	498	{
	499	/*
	500	We make 2 of the same calls, first to create a file config with a single
	501	group and key...
	502	*/
	503	::EmptyConfigAndWriteKey();
	504
	505	/*
	506	... then the same but this time the key's group is deleted before the
	507	key is written again. This causes a crash.
	508	*/
	509	::EmptyConfigAndWriteKey();
	510
	511
	512	// clean up
	513	wxLogNull noLogging;
c406cd3d	514	(void) ::wxRemoveFile(wxFileConfig::GetLocalFileName(_T("deleteconftest")));
cbc9c06f DS	515	}
cbc9c06f DS	516
6ad0a7d5 VZ	517	void FileConfigTestCase::DeleteAndRecreateGroup()
	518	{
	519	static const wxChar *confInitial =
	520	_T("[First]\n")
	521	_T("Value1=Foo\n")
	522	_T("[Second]\n")
	523	_T("Value2=Bar\n");
	524
	525	wxStringInputStream sis(confInitial);
	526	wxFileConfig fc(sis);
	527
	528	fc.DeleteGroup(_T("Second"));
	529	wxVERIFY_FILECONFIG( _T("[First]\n")
	530	_T("Value1=Foo\n"),
	531	fc );
	532
	533	fc.Write(_T("Second/Value2"), _T("New"));
	534	wxVERIFY_FILECONFIG( _T("[First]\n")
	535	_T("Value1=Foo\n")
	536	_T("[Second]\n")
	537	_T("Value2=New\n"),
	538	fc );
	539	}
	540
17c24d37 VZ	541	#endif // wxUSE_FILECONFIG
17c24d37 VZ	542