[wxWidgets.git] / tests / font / fonttest.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/font/fonttest.cpp
// Purpose:     wxFont unit test
// Author:      Francesco Montorsi
// Created:     16.3.09
// RCS-ID:      $Id$
// Copyright:   (c) 2009 Francesco Montorsi
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

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

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif // WX_PRECOMP

#if wxUSE_FONTMAP

#include "wx/font.h"

#include "asserthelper.h"

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

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

private:
    CPPUNIT_TEST_SUITE( FontTestCase );
        CPPUNIT_TEST( Construct );
        CPPUNIT_TEST( GetSet );
        CPPUNIT_TEST( NativeFontInfo );
        CPPUNIT_TEST( NativeFontInfoUserDesc );
    CPPUNIT_TEST_SUITE_END();

    void Construct();
    void GetSet();
    void NativeFontInfo();
    void NativeFontInfoUserDesc();

    static const wxFont *GetTestFonts(unsigned& numFonts)
    {
        static const wxFont testfonts[] =
        {
            *wxNORMAL_FONT,
            *wxSMALL_FONT,
            *wxITALIC_FONT,
            *wxSWISS_FONT,
            wxFont(5, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL)
        };

        numFonts = WXSIZEOF(testfonts);

        return testfonts;
    }

    DECLARE_NO_COPY_CLASS(FontTestCase)
};

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

// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FontTestCase, "FontTestCase" );

wxString DumpFont(const wxFont *font)
{
    // dumps the internal properties of a wxFont in the same order they
    // are checked by wxFontBase::operator==()

    wxASSERT(font->IsOk());

    wxString s;
    s.Printf(wxS("%d-%d;%d-%d-%d-%d-%d-%s-%d"),
             font->GetPointSize(),
             font->GetPixelSize().x,
             font->GetPixelSize().y,
             font->GetFamily(),
             font->GetStyle(),
             font->GetWeight(),
             font->GetUnderlined() ? 1 : 0,
             font->GetFaceName(),
             font->GetEncoding());

    return s;
}

void FontTestCase::Construct()
{
    // The main purpose of this test is to verify that the font ctors below
    // compile because it's easy to introduce ambiguities due to the number of
    // overloaded wxFont ctors.

    CPPUNIT_ASSERT( wxFont(10, wxFONTFAMILY_DEFAULT).IsOk() );
    CPPUNIT_ASSERT( wxFont(10, wxFONTFAMILY_DEFAULT,
                               wxFONTFLAG_DEFAULT).IsOk() );
    CPPUNIT_ASSERT( wxFont(10, wxFONTFAMILY_DEFAULT,
                               wxFONTSTYLE_NORMAL,
                               wxFONTWEIGHT_NORMAL).IsOk() );

#if FUTURE_WXWIN_COMPATIBILITY_3_0
    // Tests relying on the soon-to-be-deprecated ctor taking ints and not
    // wxFontXXX enum elements.
    CPPUNIT_ASSERT( wxFont(10, wxDEFAULT, wxNORMAL, wxNORMAL).IsOk() );
#endif // FUTURE_WXWIN_COMPATIBILITY_3_0
}

void FontTestCase::GetSet()
{
    unsigned numFonts;
    const wxFont *pf = GetTestFonts(numFonts);
    for ( unsigned n = 0; n < numFonts; n++ )
    {
        wxFont test(*pf++);

        // remember: getters can only be called when wxFont::IsOk() == true
        CPPUNIT_ASSERT( test.IsOk() );


        // test Get/SetFaceName()
        CPPUNIT_ASSERT( !test.SetFaceName("a dummy face name") );
        CPPUNIT_ASSERT( !test.IsOk() );

        // if the call to SetFaceName() below fails on your system/port,
        // consider adding another branch to this #if
#if defined(__WXMSW__) || defined(__WXOSX__)
        static const char *knownGoodFaceName = "Arial";
#else
        static const char *knownGoodFaceName = "Monospace";
#endif

        WX_ASSERT_MESSAGE
        (
            ("failed to set face name \"%s\" for test font #%u\n"
             "(this failure is harmless if this face name is not "
             "available on this system)", knownGoodFaceName, n),
            test.SetFaceName(knownGoodFaceName)
        );
        CPPUNIT_ASSERT( test.IsOk() );


        // test Get/SetFamily()

        test.SetFamily( wxFONTFAMILY_ROMAN );
        CPPUNIT_ASSERT( test.IsOk() );

        // note that there is always the possibility that GetFamily() returns
        // wxFONTFAMILY_DEFAULT (meaning "unknown" in this case) so that we
        // consider it as a valid return value
        const wxFontFamily family = test.GetFamily();
        if ( family != wxFONTFAMILY_DEFAULT )
            CPPUNIT_ASSERT_EQUAL( wxFONTFAMILY_ROMAN, family );


        // test Get/SetEncoding()

        //test.SetEncoding( wxFONTENCODING_KOI8 );
        //CPPUNIT_ASSERT( test.IsOk() );
        //CPPUNIT_ASSERT_EQUAL( wxFONTENCODING_KOI8 , test.GetEncoding() );


        // test Get/SetPointSize()

        test.SetPointSize(30);
        CPPUNIT_ASSERT( test.IsOk() );
        CPPUNIT_ASSERT_EQUAL( 30, test.GetPointSize() );


        // test Get/SetPixelSize()

        test.SetPixelSize(wxSize(0,30));
        CPPUNIT_ASSERT( test.IsOk() );
        CPPUNIT_ASSERT( test.GetPixelSize().GetHeight() <= 30 );
            // NOTE: the match found by SetPixelSize() may be not 100% precise; it
            //       only grants that a font smaller than the required height will
            //       be selected


        // test Get/SetStyle()

        test.SetStyle(wxFONTSTYLE_SLANT);
        CPPUNIT_ASSERT( test.IsOk() );
#ifdef __WXMSW__
        // on wxMSW wxFONTSTYLE_SLANT==wxFONTSTYLE_ITALIC
        CPPUNIT_ASSERT( wxFONTSTYLE_SLANT == test.GetStyle() ||
                        wxFONTSTYLE_ITALIC == test.GetStyle() );
#else
        CPPUNIT_ASSERT_EQUAL( wxFONTSTYLE_SLANT, test.GetStyle() );
#endif

        // test Get/SetUnderlined()

        test.SetUnderlined(true);
        CPPUNIT_ASSERT( test.IsOk() );
        CPPUNIT_ASSERT_EQUAL( true, test.GetUnderlined() );

        // test Get/SetStrikethrough()

        test.SetStrikethrough(true);
        CPPUNIT_ASSERT( test.IsOk() );
        CPPUNIT_ASSERT_EQUAL( true, test.GetStrikethrough() );


        // test Get/SetWeight()

        test.SetWeight(wxFONTWEIGHT_BOLD);
        CPPUNIT_ASSERT( test.IsOk() );
        CPPUNIT_ASSERT_EQUAL( wxFONTWEIGHT_BOLD, test.GetWeight() );
    }
}

void FontTestCase::NativeFontInfo()
{
    unsigned numFonts;
    const wxFont *pf = GetTestFonts(numFonts);
    for ( size_t n = 0; n < numFonts; n++ )
    {
        wxFont test(*pf++);

        const wxString& nid = test.GetNativeFontInfoDesc();
        CPPUNIT_ASSERT( !nid.empty() );
            // documented to be never empty

        wxFont temp;
        CPPUNIT_ASSERT( temp.SetNativeFontInfo(nid) );
        CPPUNIT_ASSERT( temp.IsOk() );
        WX_ASSERT_MESSAGE(
            ("Test #%lu failed\ndump of test font: \"%s\"\ndump of temp font: \"%s\"", \
             n, DumpFont(&test), DumpFont(&temp)),
            temp == test );
    }

    // test that clearly invalid font info strings do not work
    wxFont font;
    CPPUNIT_ASSERT( !font.SetNativeFontInfo("") );

    // pango_font_description_from_string() used by wxFont in wxGTK and wxX11
    // never returns an error at all so this assertion fails there -- and as it
    // doesn't seem to be possible to do anything about it maybe we should
    // change wxMSW and other ports to also accept any strings?
#if !defined(__WXGTK__) && !defined(__WXX11__)
    CPPUNIT_ASSERT( !font.SetNativeFontInfo("bloordyblop") );
#endif

    // Pango font description doesn't have 'underlined' and 'strikethrough'
    // attributes, so wxNativeFontInfo implements these itself. Test if these
    // are properly preserved by wxNativeFontInfo or its string description.
    font.SetUnderlined(true);
    font.SetStrikethrough(true);
    CPPUNIT_ASSERT_EQUAL(font, wxFont(font));
    CPPUNIT_ASSERT_EQUAL(font, wxFont(*font.GetNativeFontInfo()));
    CPPUNIT_ASSERT_EQUAL(font, wxFont(font.GetNativeFontInfoDesc()));
    font.SetUnderlined(false);
    CPPUNIT_ASSERT_EQUAL(font, wxFont(font));
    CPPUNIT_ASSERT_EQUAL(font, wxFont(*font.GetNativeFontInfo()));
    CPPUNIT_ASSERT_EQUAL(font, wxFont(font.GetNativeFontInfoDesc()));
    font.SetUnderlined(true);
    font.SetStrikethrough(false);
    CPPUNIT_ASSERT_EQUAL(font, wxFont(font));
    CPPUNIT_ASSERT_EQUAL(font, wxFont(*font.GetNativeFontInfo()));
    CPPUNIT_ASSERT_EQUAL(font, wxFont(font.GetNativeFontInfoDesc()));
    // note: the GetNativeFontInfoUserDesc() doesn't preserve all attributes
    // according to docs, so it is not tested.
}

void FontTestCase::NativeFontInfoUserDesc()
{
    unsigned numFonts;
    const wxFont *pf = GetTestFonts(numFonts);
    for ( size_t n = 0; n < numFonts; n++ )
    {
        wxFont test(*pf++);

        const wxString& niud = test.GetNativeFontInfoUserDesc();
        CPPUNIT_ASSERT( !niud.empty() );
            // documented to be never empty

        wxFont temp2;
        CPPUNIT_ASSERT( temp2.SetNativeFontInfoUserDesc(niud) );
        CPPUNIT_ASSERT( temp2.IsOk() );

#ifdef __WXGTK__
        // Pango saves/restores all font info in the user-friendly string:
        WX_ASSERT_MESSAGE(
            ("Test #%lu failed; native info user desc was \"%s\" for test and \"%s\" for temp2", \
             n, niud, temp2.GetNativeFontInfoUserDesc()),
            temp2 == test );
#else
        // NOTE: as documented GetNativeFontInfoUserDesc/SetNativeFontInfoUserDesc
        //       are not granted to save/restore all font info.
        //       In fact e.g. the font family is not saved at all; test only those
        //       info which GetNativeFontInfoUserDesc() does indeed save:
        CPPUNIT_ASSERT_EQUAL( test.GetWeight(), temp2.GetWeight() );
        CPPUNIT_ASSERT_EQUAL( test.GetStyle(), temp2.GetStyle() );

        // if the original face name was empty, it means that any face name (in
        // this family) can be used for the new font so we shouldn't be
        // surprised to find that they differ in this case
        const wxString facename = test.GetFaceName();
        if ( !facename.empty() )
        {
            CPPUNIT_ASSERT_EQUAL( facename.Upper(), temp2.GetFaceName().Upper() );
        }

        CPPUNIT_ASSERT_EQUAL( test.GetPointSize(), temp2.GetPointSize() );
        CPPUNIT_ASSERT_EQUAL( test.GetEncoding(), temp2.GetEncoding() );
#endif
    }
}

#endif // wxUSE_FONTMAP
Commit	Line	Data
5b06a80f FM	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/font/fonttest.cpp
	3	// Purpose: wxFont unit test
	4	// Author: Francesco Montorsi
	5	// Created: 16.3.09
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2009 Francesco Montorsi
	8	// Licence: wxWindows licence
	9	///////////////////////////////////////////////////////////////////////////////
	10
	11	// ----------------------------------------------------------------------------
	12	// headers
	13	// ----------------------------------------------------------------------------
	14
	15	#include "testprec.h"
	16
	17	#ifdef __BORLANDC__
	18	#pragma hdrstop
	19	#endif
	20
	21	#ifndef WX_PRECOMP
	22	#include "wx/wx.h"
	23	#endif // WX_PRECOMP
	24
	25	#if wxUSE_FONTMAP
	26
	27	#include "wx/font.h"
	28
a349dc10 VZ	29	#include "asserthelper.h"
a349dc10 VZ	30
5b06a80f FM	31	// ----------------------------------------------------------------------------
	32	// test class
	33	// ----------------------------------------------------------------------------
	34
	35	class FontTestCase : public CppUnit::TestCase
	36	{
	37	public:
	38	FontTestCase() { }
	39
	40	private:
	41	CPPUNIT_TEST_SUITE( FontTestCase );
cec8d677	42	CPPUNIT_TEST( Construct );
5b06a80f	43	CPPUNIT_TEST( GetSet );
c56fc0dc VZ	44	CPPUNIT_TEST( NativeFontInfo );
c56fc0dc VZ	45	CPPUNIT_TEST( NativeFontInfoUserDesc );
5b06a80f FM	46	CPPUNIT_TEST_SUITE_END();
5b06a80f FM	47
cec8d677	48	void Construct();
5b06a80f	49	void GetSet();
c56fc0dc VZ	50	void NativeFontInfo();
	51	void NativeFontInfoUserDesc();
	52
	53	static const wxFont *GetTestFonts(unsigned& numFonts)
	54	{
	55	static const wxFont testfonts[] =
	56	{
	57	*wxNORMAL_FONT,
	58	*wxSMALL_FONT,
	59	*wxITALIC_FONT,
	60	*wxSWISS_FONT,
	61	wxFont(5, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL)
	62	};
	63
	64	numFonts = WXSIZEOF(testfonts);
	65
	66	return testfonts;
	67	}
5b06a80f FM	68
	69	DECLARE_NO_COPY_CLASS(FontTestCase)
	70	};
	71
	72	// register in the unnamed registry so that these tests are run by default
	73	CPPUNIT_TEST_SUITE_REGISTRATION( FontTestCase );
	74
e3778b4d	75	// also include in its own registry so that these tests can be run alone
5b06a80f FM	76	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FontTestCase, "FontTestCase" );
5b06a80f FM	77
aeecbca0 FM	78	wxString DumpFont(const wxFont *font)
	79	{
	80	// dumps the internal properties of a wxFont in the same order they
	81	// are checked by wxFontBase::operator==()
c56fc0dc	82
aeecbca0	83	wxASSERT(font->IsOk());
c56fc0dc	84
aeecbca0 FM	85	wxString s;
	86	s.Printf(wxS("%d-%d;%d-%d-%d-%d-%d-%s-%d"),
	87	font->GetPointSize(),
	88	font->GetPixelSize().x,
	89	font->GetPixelSize().y,
	90	font->GetFamily(),
	91	font->GetStyle(),
	92	font->GetWeight(),
	93	font->GetUnderlined() ? 1 : 0,
	94	font->GetFaceName(),
	95	font->GetEncoding());
	96
	97	return s;
	98	}
5b06a80f	99
cec8d677 VZ	100	void FontTestCase::Construct()
	101	{
	102	// The main purpose of this test is to verify that the font ctors below
	103	// compile because it's easy to introduce ambiguities due to the number of
	104	// overloaded wxFont ctors.
	105
	106	CPPUNIT_ASSERT( wxFont(10, wxFONTFAMILY_DEFAULT).IsOk() );
	107	CPPUNIT_ASSERT( wxFont(10, wxFONTFAMILY_DEFAULT,
	108	wxFONTFLAG_DEFAULT).IsOk() );
	109	CPPUNIT_ASSERT( wxFont(10, wxFONTFAMILY_DEFAULT,
	110	wxFONTSTYLE_NORMAL,
	111	wxFONTWEIGHT_NORMAL).IsOk() );
	112
	113	#if FUTURE_WXWIN_COMPATIBILITY_3_0
	114	// Tests relying on the soon-to-be-deprecated ctor taking ints and not
	115	// wxFontXXX enum elements.
	116	CPPUNIT_ASSERT( wxFont(10, wxDEFAULT, wxNORMAL, wxNORMAL).IsOk() );
	117	#endif // FUTURE_WXWIN_COMPATIBILITY_3_0
	118	}
	119
5b06a80f FM	120	void FontTestCase::GetSet()
5b06a80f FM	121	{
c56fc0dc VZ	122	unsigned numFonts;
c56fc0dc VZ	123	const wxFont *pf = GetTestFonts(numFonts);
b7cb8553	124	for ( unsigned n = 0; n < numFonts; n++ )
5b06a80f	125	{
c56fc0dc	126	wxFont test(*pf++);
5b06a80f FM	127
	128	// remember: getters can only be called when wxFont::IsOk() == true
	129	CPPUNIT_ASSERT( test.IsOk() );
	130
	131
	132	// test Get/SetFaceName()
5b06a80f FM	133	CPPUNIT_ASSERT( !test.SetFaceName("a dummy face name") );
	134	CPPUNIT_ASSERT( !test.IsOk() );
	135
3f7c8a87 VZ	136	// if the call to SetFaceName() below fails on your system/port,
	137	// consider adding another branch to this #if
	138	#if defined(__WXMSW__) \|\| defined(__WXOSX__)
	139	static const char *knownGoodFaceName = "Arial";
	140	#else
b7cb8553	141	static const char *knownGoodFaceName = "Monospace";
3f7c8a87 VZ	142	#endif
3f7c8a87 VZ	143
b7cb8553 VZ	144	WX_ASSERT_MESSAGE
	145	(
	146	("failed to set face name \"%s\" for test font #%u\n"
	147	"(this failure is harmless if this face name is not "
	148	"available on this system)", knownGoodFaceName, n),
	149	test.SetFaceName(knownGoodFaceName)
	150	);
5b06a80f FM	151	CPPUNIT_ASSERT( test.IsOk() );
	152
	153
	154	// test Get/SetFamily()
	155
6aea1e4a	156	test.SetFamily( wxFONTFAMILY_ROMAN );
14a83cbf	157	CPPUNIT_ASSERT( test.IsOk() );
aa6b8882 VZ	158
	159	// note that there is always the possibility that GetFamily() returns
	160	// wxFONTFAMILY_DEFAULT (meaning "unknown" in this case) so that we
	161	// consider it as a valid return value
	162	const wxFontFamily family = test.GetFamily();
	163	if ( family != wxFONTFAMILY_DEFAULT )
	164	CPPUNIT_ASSERT_EQUAL( wxFONTFAMILY_ROMAN, family );
6aea1e4a	165
5b06a80f	166
5b06a80f FM	167	// test Get/SetEncoding()
	168
	169	//test.SetEncoding( wxFONTENCODING_KOI8 );
14a83cbf	170	//CPPUNIT_ASSERT( test.IsOk() );
5b06a80f FM	171	//CPPUNIT_ASSERT_EQUAL( wxFONTENCODING_KOI8 , test.GetEncoding() );
5b06a80f FM	172
c56fc0dc VZ	173
	174	// test Get/SetPointSize()
	175
	176	test.SetPointSize(30);
	177	CPPUNIT_ASSERT( test.IsOk() );
	178	CPPUNIT_ASSERT_EQUAL( 30, test.GetPointSize() );
	179
	180
	181	// test Get/SetPixelSize()
	182
	183	test.SetPixelSize(wxSize(0,30));
	184	CPPUNIT_ASSERT( test.IsOk() );
	185	CPPUNIT_ASSERT( test.GetPixelSize().GetHeight() <= 30 );
	186	// NOTE: the match found by SetPixelSize() may be not 100% precise; it
	187	// only grants that a font smaller than the required height will
	188	// be selected
	189
	190
	191	// test Get/SetStyle()
	192
	193	test.SetStyle(wxFONTSTYLE_SLANT);
	194	CPPUNIT_ASSERT( test.IsOk() );
	195	#ifdef __WXMSW__
	196	// on wxMSW wxFONTSTYLE_SLANT==wxFONTSTYLE_ITALIC
	197	CPPUNIT_ASSERT( wxFONTSTYLE_SLANT == test.GetStyle() \|\|
	198	wxFONTSTYLE_ITALIC == test.GetStyle() );
	199	#else
	200	CPPUNIT_ASSERT_EQUAL( wxFONTSTYLE_SLANT, test.GetStyle() );
	201	#endif
	202
	203	// test Get/SetUnderlined()
	204
	205	test.SetUnderlined(true);
	206	CPPUNIT_ASSERT( test.IsOk() );
	207	CPPUNIT_ASSERT_EQUAL( true, test.GetUnderlined() );
	208
a349dc10 VZ	209	// test Get/SetStrikethrough()
	210
	211	test.SetStrikethrough(true);
	212	CPPUNIT_ASSERT( test.IsOk() );
	213	CPPUNIT_ASSERT_EQUAL( true, test.GetStrikethrough() );
	214
c56fc0dc VZ	215
	216	// test Get/SetWeight()
	217
	218	test.SetWeight(wxFONTWEIGHT_BOLD);
	219	CPPUNIT_ASSERT( test.IsOk() );
	220	CPPUNIT_ASSERT_EQUAL( wxFONTWEIGHT_BOLD, test.GetWeight() );
	221	}
	222	}
	223
	224	void FontTestCase::NativeFontInfo()
	225	{
	226	unsigned numFonts;
	227	const wxFont *pf = GetTestFonts(numFonts);
	228	for ( size_t n = 0; n < numFonts; n++ )
	229	{
	230	wxFont test(*pf++);
	231
5b06a80f FM	232	const wxString& nid = test.GetNativeFontInfoDesc();
5b06a80f FM	233	CPPUNIT_ASSERT( !nid.empty() );
14a83cbf	234	// documented to be never empty
c56fc0dc	235
5b06a80f	236	wxFont temp;
14a83cbf FM	237	CPPUNIT_ASSERT( temp.SetNativeFontInfo(nid) );
14a83cbf FM	238	CPPUNIT_ASSERT( temp.IsOk() );
c56fc0dc	239	WX_ASSERT_MESSAGE(
aeecbca0 FM	240	("Test #%lu failed\ndump of test font: \"%s\"\ndump of temp font: \"%s\"", \
aeecbca0 FM	241	n, DumpFont(&test), DumpFont(&temp)),
9b5e0a6d	242	temp == test );
c56fc0dc VZ	243	}
	244
	245	// test that clearly invalid font info strings do not work
	246	wxFont font;
	247	CPPUNIT_ASSERT( !font.SetNativeFontInfo("") );
541aafe2 VZ	248
	249	// pango_font_description_from_string() used by wxFont in wxGTK and wxX11
	250	// never returns an error at all so this assertion fails there -- and as it
	251	// doesn't seem to be possible to do anything about it maybe we should
	252	// change wxMSW and other ports to also accept any strings?
	253	#if !defined(__WXGTK__) && !defined(__WXX11__)
c56fc0dc	254	CPPUNIT_ASSERT( !font.SetNativeFontInfo("bloordyblop") );
541aafe2	255	#endif
a349dc10 VZ	256
	257	// Pango font description doesn't have 'underlined' and 'strikethrough'
	258	// attributes, so wxNativeFontInfo implements these itself. Test if these
	259	// are properly preserved by wxNativeFontInfo or its string description.
	260	font.SetUnderlined(true);
	261	font.SetStrikethrough(true);
	262	CPPUNIT_ASSERT_EQUAL(font, wxFont(font));
	263	CPPUNIT_ASSERT_EQUAL(font, wxFont(*font.GetNativeFontInfo()));
	264	CPPUNIT_ASSERT_EQUAL(font, wxFont(font.GetNativeFontInfoDesc()));
	265	font.SetUnderlined(false);
	266	CPPUNIT_ASSERT_EQUAL(font, wxFont(font));
	267	CPPUNIT_ASSERT_EQUAL(font, wxFont(*font.GetNativeFontInfo()));
	268	CPPUNIT_ASSERT_EQUAL(font, wxFont(font.GetNativeFontInfoDesc()));
	269	font.SetUnderlined(true);
	270	font.SetStrikethrough(false);
	271	CPPUNIT_ASSERT_EQUAL(font, wxFont(font));
	272	CPPUNIT_ASSERT_EQUAL(font, wxFont(*font.GetNativeFontInfo()));
	273	CPPUNIT_ASSERT_EQUAL(font, wxFont(font.GetNativeFontInfoDesc()));
	274	// note: the GetNativeFontInfoUserDesc() doesn't preserve all attributes
	275	// according to docs, so it is not tested.
c56fc0dc VZ	276	}
	277
	278	void FontTestCase::NativeFontInfoUserDesc()
	279	{
	280	unsigned numFonts;
	281	const wxFont *pf = GetTestFonts(numFonts);
	282	for ( size_t n = 0; n < numFonts; n++ )
	283	{
	284	wxFont test(*pf++);
14a83cbf	285
5b06a80f FM	286	const wxString& niud = test.GetNativeFontInfoUserDesc();
5b06a80f FM	287	CPPUNIT_ASSERT( !niud.empty() );
14a83cbf	288	// documented to be never empty
c56fc0dc	289
5b06a80f	290	wxFont temp2;
14a83cbf FM	291	CPPUNIT_ASSERT( temp2.SetNativeFontInfoUserDesc(niud) );
	292	CPPUNIT_ASSERT( temp2.IsOk() );
	293
	294	#ifdef __WXGTK__
	295	// Pango saves/restores all font info in the user-friendly string:
c56fc0dc	296	WX_ASSERT_MESSAGE(
6aafb945 FM	297	("Test #%lu failed; native info user desc was \"%s\" for test and \"%s\" for temp2", \
6aafb945 FM	298	n, niud, temp2.GetNativeFontInfoUserDesc()),
9b5e0a6d	299	temp2 == test );
14a83cbf FM	300	#else
	301	// NOTE: as documented GetNativeFontInfoUserDesc/SetNativeFontInfoUserDesc
	302	// are not granted to save/restore all font info.
	303	// In fact e.g. the font family is not saved at all; test only those
	304	// info which GetNativeFontInfoUserDesc() does indeed save:
	305	CPPUNIT_ASSERT_EQUAL( test.GetWeight(), temp2.GetWeight() );
	306	CPPUNIT_ASSERT_EQUAL( test.GetStyle(), temp2.GetStyle() );
14a83cbf	307
c56fc0dc VZ	308	// if the original face name was empty, it means that any face name (in
	309	// this family) can be used for the new font so we shouldn't be
	310	// surprised to find that they differ in this case
	311	const wxString facename = test.GetFaceName();
	312	if ( !facename.empty() )
	313	{
	314	CPPUNIT_ASSERT_EQUAL( facename.Upper(), temp2.GetFaceName().Upper() );
	315	}
14a83cbf	316
c56fc0dc VZ	317	CPPUNIT_ASSERT_EQUAL( test.GetPointSize(), temp2.GetPointSize() );
c56fc0dc VZ	318	CPPUNIT_ASSERT_EQUAL( test.GetEncoding(), temp2.GetEncoding() );
14a83cbf	319	#endif
5b06a80f FM	320	}
	321	}
	322
	323	#endif // wxUSE_FONTMAP