cheng/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
0455e25302
wxWidgets/tests/controls/textctrltest.cpp
Vadim Zeitlin e307945170 Merge branch 'ui-locale' 
Add wxUILocale class providing functionality which can be implemented
portably for all major platforms, including macOS, and doesn't force
the change of the global C locale, unlike wxLocale.

See https://github.com/wxWidgets/wxWidgets/pull/2464
2021-08-26 15:49:57 +02:00

1516 lines
43 KiB
C++
Raw Blame History

///////////////////////////////////////////////////////////////////////////////
// Name: tests/controls/textctrltest.cpp
// Purpose: wxTextCtrl unit test
// Author: Vadim Zeitlin
// Created: 2007-09-25
// Copyright: (c) 2007 Vadim Zeitlin <vadim@wxwidgets.org>
///////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "testprec.h"
#if wxUSE_TEXTCTRL
#ifndef WX_PRECOMP
#include "wx/app.h"
#include "wx/textctrl.h"
#endif // WX_PRECOMP
#include "wx/platinfo.h"
#include "wx/scopedptr.h"
#include "wx/uiaction.h"
#if wxUSE_CLIPBOARD
#include "wx/clipbrd.h"
#include "wx/dataobj.h"
#endif // wxUSE_CLIPBOARD
#ifdef __WXGTK__
#include "wx/stopwatch.h"
#endif
#include "wx/private/localeset.h"
#include "textentrytest.h"
#include "testableframe.h"
#include "asserthelper.h"
static const int TEXT_HEIGHT = 200;
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
#define wxHAS_2CHAR_NEWLINES 1
#else
#define wxHAS_2CHAR_NEWLINES 0
#endif
// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------
class TextCtrlTestCase : public TextEntryTestCase, public CppUnit::TestCase
{
public:
TextCtrlTestCase() { }
virtual void setUp() wxOVERRIDE;
virtual void tearDown() wxOVERRIDE;
private:
virtual wxTextEntry *GetTestEntry() const wxOVERRIDE { return m_text; }
virtual wxWindow *GetTestWindow() const wxOVERRIDE { return m_text; }
#define SINGLE_AND_MULTI_TESTS() \
WXUISIM_TEST( ReadOnly ); \
CPPUNIT_TEST( StreamInput ); \
CPPUNIT_TEST( Redirector )
CPPUNIT_TEST_SUITE( TextCtrlTestCase );
// These tests run for single line text controls.
wxTEXT_ENTRY_TESTS();
WXUISIM_TEST( MaxLength );
CPPUNIT_TEST( PositionToXYSingleLine );
CPPUNIT_TEST( XYToPositionSingleLine );
CPPUNIT_TEST( HitTestSingleLine );
SINGLE_AND_MULTI_TESTS();
// Now switch to the multi-line text controls.
CPPUNIT_TEST( PseudoTestSwitchToMultiLineStyle );
// Rerun the text entry tests not specific to single line controls for
// multiline ones now.
wxTEXT_ENTRY_TESTS();
SINGLE_AND_MULTI_TESTS();
// All tests from now on are for multi-line controls only.
CPPUNIT_TEST( MultiLineReplace );
//WXUISIM_TEST( ProcessEnter );
WXUISIM_TEST( Url );
CPPUNIT_TEST( Style );
CPPUNIT_TEST( FontStyle );
CPPUNIT_TEST( Lines );
#if wxUSE_LOG
CPPUNIT_TEST( LogTextCtrl );
#endif // wxUSE_LOG
CPPUNIT_TEST( LongText );
CPPUNIT_TEST( PositionToCoords );
CPPUNIT_TEST( PositionToCoordsRich );
CPPUNIT_TEST( PositionToCoordsRich2 );
CPPUNIT_TEST( PositionToXYMultiLine );
CPPUNIT_TEST( XYToPositionMultiLine );
#if wxUSE_RICHEDIT
CPPUNIT_TEST( PositionToXYMultiLineRich );
CPPUNIT_TEST( XYToPositionMultiLineRich );
CPPUNIT_TEST( PositionToXYMultiLineRich2 );
CPPUNIT_TEST( XYToPositionMultiLineRich2 );
#endif // wxUSE_RICHEDIT
CPPUNIT_TEST_SUITE_END();
void PseudoTestSwitchToMultiLineStyle()
{
ms_style = wxTE_MULTILINE;
}
void MultiLineReplace();
void ReadOnly();
void MaxLength();
void StreamInput();
void Redirector();
void HitTestSingleLine();
//void ProcessEnter();
void Url();
void Style();
void FontStyle();
void Lines();
#if wxUSE_LOG
void LogTextCtrl();
#endif // wxUSE_LOG
void LongText();
void PositionToCoords();
void PositionToCoordsRich();
void PositionToCoordsRich2();
void PositionToXYMultiLine();
void XYToPositionMultiLine();
#if wxUSE_RICHEDIT
void PositionToXYMultiLineRich();
void XYToPositionMultiLineRich();
void PositionToXYMultiLineRich2();
void XYToPositionMultiLineRich2();
#endif // wxUSE_RICHEDIT
void PositionToXYSingleLine();
void XYToPositionSingleLine();
void DoPositionToCoordsTestWithStyle(long style);
void DoPositionToXYMultiLine(long style);
void DoXYToPositionMultiLine(long style);
// Create the control with the following styles added to ms_style which may
// (or not) already contain wxTE_MULTILINE.
void CreateText(long extraStyles);
wxTextCtrl *m_text;
static long ms_style;
wxDECLARE_NO_COPY_CLASS(TextCtrlTestCase);
};
// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( TextCtrlTestCase );
// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TextCtrlTestCase, "TextCtrlTestCase" );
// ----------------------------------------------------------------------------
// test initialization
// ----------------------------------------------------------------------------
// This is 0 initially and set to wxTE_MULTILINE later to allow running the
// same tests for both single and multi line controls.
long TextCtrlTestCase::ms_style = 0;
void TextCtrlTestCase::CreateText(long extraStyles)
{
const long style = ms_style | extraStyles;
const int h = (style & wxTE_MULTILINE) ? TEXT_HEIGHT : -1;
m_text = new wxTextCtrl(wxTheApp->GetTopWindow(), wxID_ANY, "",
wxDefaultPosition, wxSize(400, h),
style);
}
void TextCtrlTestCase::setUp()
{
CreateText(0);
}
void TextCtrlTestCase::tearDown()
{
wxDELETE(m_text);
}
// ----------------------------------------------------------------------------
// tests themselves
// ----------------------------------------------------------------------------
void TextCtrlTestCase::MultiLineReplace()
{
m_text->SetValue("Hello replace\n"
"0123456789012");
m_text->SetInsertionPoint(0);
m_text->Replace(6, 13, "changed");
CPPUNIT_ASSERT_EQUAL("Hello changed\n"
"0123456789012",
m_text->GetValue());
CPPUNIT_ASSERT_EQUAL(13, m_text->GetInsertionPoint());
m_text->Replace(13, -1, "");
CPPUNIT_ASSERT_EQUAL("Hello changed", m_text->GetValue());
CPPUNIT_ASSERT_EQUAL(13, m_text->GetInsertionPoint());
}
void TextCtrlTestCase::ReadOnly()
{
#if wxUSE_UIACTIONSIMULATOR
// we need a read only control for this test so recreate it
delete m_text;
CreateText(wxTE_READONLY);
EventCounter updated(m_text, wxEVT_TEXT);
m_text->SetFocus();
wxUIActionSimulator sim;
sim.Text("abcdef");
wxYield();
CPPUNIT_ASSERT_EQUAL("", m_text->GetValue());
CPPUNIT_ASSERT_EQUAL(0, updated.GetCount());
// SetEditable() is supposed to override wxTE_READONLY
m_text->SetEditable(true);
#if defined(__WXOSX__) || defined(__WXUNIVERSAL__)
// a ready only text field might not have been focusable at all
m_text->SetFocus();
#endif
sim.Text("abcdef");
wxYield();
CPPUNIT_ASSERT_EQUAL("abcdef", m_text->GetValue());
CPPUNIT_ASSERT_EQUAL(6, updated.GetCount());
#endif
}
void TextCtrlTestCase::MaxLength()
{
#if wxUSE_UIACTIONSIMULATOR
EventCounter updated(m_text, wxEVT_TEXT);
EventCounter maxlen(m_text, wxEVT_TEXT_MAXLEN);
m_text->SetFocus();
wxYield();
m_text->SetMaxLength(10);
wxUIActionSimulator sim;
sim.Text("abcdef");
wxYield();
CPPUNIT_ASSERT_EQUAL(0, maxlen.GetCount());
sim.Text("ghij");
wxYield();
CPPUNIT_ASSERT_EQUAL(0, maxlen.GetCount());
CPPUNIT_ASSERT_EQUAL(10, updated.GetCount());
maxlen.Clear();
updated.Clear();
sim.Text("k");
wxYield();
CPPUNIT_ASSERT_EQUAL(1, maxlen.GetCount());
CPPUNIT_ASSERT_EQUAL(0, updated.GetCount());
maxlen.Clear();
updated.Clear();
m_text->SetMaxLength(0);
sim.Text("k");
wxYield();
CPPUNIT_ASSERT_EQUAL(0, maxlen.GetCount());
CPPUNIT_ASSERT_EQUAL(1, updated.GetCount());
#endif
}
void TextCtrlTestCase::StreamInput()
{
#ifndef __WXOSX__
{
// Ensure we use decimal point and not a comma.
wxCLocaleSetter setCLocale;
*m_text << "stringinput"
<< 10
<< 1000L
<< 3.14f
<< 2.71
<< 'a'
<< L'b';
}
CPPUNIT_ASSERT_EQUAL("stringinput1010003.142.71ab", m_text->GetValue());
m_text->SetValue("");
#if wxHAS_TEXT_WINDOW_STREAM
std::ostream stream(m_text);
// We don't test a wide character as this is not a wide stream
stream << "stringinput"
<< 10
<< 1000L
<< 3.14f
<< 2.71
<< 'a';
stream.flush();
CPPUNIT_ASSERT_EQUAL("stringinput1010003.142.71a", m_text->GetValue());
#endif // wxHAS_TEXT_WINDOW_STREAM
#endif // !__WXOSX__
}
void TextCtrlTestCase::Redirector()
{
#if wxHAS_TEXT_WINDOW_STREAM && wxUSE_STD_IOSTREAM
wxStreamToTextRedirector redirect(m_text);
std::cout << "stringinput"
<< 10
<< 1000L
<< 3.14f
<< 2.71
<< 'a';
CPPUNIT_ASSERT_EQUAL("stringinput1010003.142.71a", m_text->GetValue());
#endif
}
void TextCtrlTestCase::HitTestSingleLine()
{
#ifdef __WXQT__
WARN("Does not work under WxQt");
#else
m_text->ChangeValue("Hit me");
// We don't know the size of the text borders, so we can't really do any
// exact tests, just try to verify that the results are roughly as
// expected.
const wxSize sizeChar = m_text->GetTextExtent("X");
const int yMid = sizeChar.y / 2;
long pos = -1;
#ifdef __WXGTK__
wxYield();
#endif
// Hitting a point near the left side of the control should find one of the
// first few characters under it.
SECTION("Normal")
{
REQUIRE( m_text->HitTest(wxPoint(2*sizeChar.x, yMid), &pos) == wxTE_HT_ON_TEXT );
CHECK( pos >= 0 );
CHECK( pos < 3 );
}
// Hitting a point well beyond the end of the text shouldn't find any valid
// character.
SECTION("Beyond")
{
REQUIRE( m_text->HitTest(wxPoint(20*sizeChar.x, yMid), &pos) == wxTE_HT_BEYOND );
CHECK( pos == m_text->GetLastPosition() );
}
// Making the control scroll, by ensuring that its contents is too long to
// show inside its window, should change the hit test result for the same
// position as used above.
SECTION("Scrolled")
{
m_text->ChangeValue(wxString(200, 'X'));
m_text->SetInsertionPointEnd();
#ifdef __WXGTK__
// wxGTK must be given an opportunity to lay the text out.
for ( wxStopWatch sw; sw.Time() < 50; )
wxYield();
#endif
REQUIRE( m_text->HitTest(wxPoint(2*sizeChar.x, yMid), &pos) == wxTE_HT_ON_TEXT );
CHECK( pos > 3 );
// Using negative coordinates works even under Xvfb, so test at least
// for this -- however this only works in wxGTK, not wxMSW.
#ifdef __WXGTK__
REQUIRE( m_text->HitTest(wxPoint(-2*sizeChar.x, yMid), &pos) == wxTE_HT_ON_TEXT );
CHECK( pos > 3 );
#endif // __WXGTK__
}
#endif
}
#if 0
void TextCtrlTestCase::ProcessEnter()
{
#if wxUSE_UIACTIONSIMULATOR
wxTestableFrame* frame = wxStaticCast(wxTheApp->GetTopWindow(),
wxTestableFrame);
EventCounter count(m_text, wxEVT_TEXT_ENTER);
m_text->SetFocus();
wxUIActionSimulator sim;
sim.Char(WXK_RETURN);
wxYield();
CPPUNIT_ASSERT_EQUAL(0, frame->GetEventCount(wxEVT_TEXT_ENTER));
// we need a text control with wxTE_PROCESS_ENTER for this test
delete m_text;
CreateText(wxTE_PROCESS_ENTER);
m_text->SetFocus();
sim.Char(WXK_RETURN);
wxYield();
CPPUNIT_ASSERT_EQUAL(1, frame->GetEventCount(wxEVT_TEXT_ENTER));
#endif
}
#endif
void TextCtrlTestCase::Url()
{
#if wxUSE_UIACTIONSIMULATOR && defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
// For some reason, this test sporadically fails when run in AppVeyor or
// GitHub Actions CI environments, even though it passes locally.
if ( IsAutomaticTest() )
return;
delete m_text;
CreateText(wxTE_RICH | wxTE_AUTO_URL);
EventCounter url(m_text, wxEVT_TEXT_URL);
m_text->AppendText("http://www.wxwidgets.org");
wxUIActionSimulator sim;
sim.MouseMove(m_text->ClientToScreen(wxPoint(5, 5)));
sim.MouseClick();
wxYield();
CPPUNIT_ASSERT_EQUAL(1, url.GetCount());
#endif
}
void TextCtrlTestCase::Style()
{
#if !defined(__WXOSX__) && !defined(__WXQT__)
delete m_text;
// We need wxTE_RICH under windows for style support
CreateText(wxTE_MULTILINE|wxTE_RICH);
// Red text on a white background
m_text->SetDefaultStyle(wxTextAttr(*wxRED, *wxWHITE));
CPPUNIT_ASSERT_EQUAL(m_text->GetDefaultStyle().GetTextColour(), *wxRED);
CPPUNIT_ASSERT_EQUAL(m_text->GetDefaultStyle().GetBackgroundColour(),
*wxWHITE);
m_text->AppendText("red on white ");
// Red text on a grey background
m_text->SetDefaultStyle(wxTextAttr(wxNullColour, *wxLIGHT_GREY));
CPPUNIT_ASSERT_EQUAL(m_text->GetDefaultStyle().GetTextColour(), *wxRED);
CPPUNIT_ASSERT_EQUAL(m_text->GetDefaultStyle().GetBackgroundColour(),
*wxLIGHT_GREY);
m_text->AppendText("red on grey ");
// Blue text on a grey background
m_text->SetDefaultStyle(wxTextAttr(*wxBLUE));
CPPUNIT_ASSERT_EQUAL(m_text->GetDefaultStyle().GetTextColour(), *wxBLUE);
CPPUNIT_ASSERT_EQUAL(m_text->GetDefaultStyle().GetBackgroundColour(),
*wxLIGHT_GREY);
m_text->AppendText("blue on grey");
// Get getting the style at a specific location
wxTextAttr style;
// We have to check that styles are supported
if ( !m_text->GetStyle(3, style) )
{
WARN("Retrieving text style not supported, skipping test.");
return;
}
CHECK( style.GetTextColour() == *wxRED );
CHECK( style.GetBackgroundColour() == *wxWHITE );
// And then setting the style
REQUIRE( m_text->SetStyle(15, 18, style) );
REQUIRE( m_text->GetStyle(17, style) );
CHECK( style.GetTextColour() == *wxRED );
CHECK( style.GetBackgroundColour() == *wxWHITE );
#else
WARN("Does not work under WxQt or OSX");
#endif
}
void TextCtrlTestCase::FontStyle()
{
// We need wxTE_RICH under MSW and wxTE_MULTILINE under GTK for style
// support so recreate the control with these styles.
delete m_text;
CreateText(wxTE_RICH);
// Check that we get back the same font from GetStyle() after setting it
// with SetDefaultStyle().
wxFont fontIn(14,
wxFONTFAMILY_DEFAULT,
wxFONTSTYLE_NORMAL,
wxFONTWEIGHT_NORMAL);
wxTextAttr attrIn;
attrIn.SetFont(fontIn);
if ( !m_text->SetDefaultStyle(attrIn) )
{
// Skip the test if the styles are not supported.
return;
}
m_text->AppendText("Default font size 14");
wxTextAttr attrOut;
if ( !m_text->GetStyle(5, attrOut) )
{
WARN("Retrieving text style not supported, skipping test.");
return;
}
CPPUNIT_ASSERT( attrOut.HasFont() );
wxFont fontOut = attrOut.GetFont();
#ifdef __WXMSW__
// Under MSW we get back an encoding in the font even though we hadn't
// specified it originally. It's not really a problem but we need this hack
// to prevent the assert below from failing because of it.
fontOut.SetEncoding(fontIn.GetEncoding());
#endif
CPPUNIT_ASSERT_EQUAL( fontIn, fontOut );
// Also check the same for SetStyle().
fontIn.SetPointSize(10);
fontIn.SetWeight(wxFONTWEIGHT_BOLD);
attrIn.SetFont(fontIn);
m_text->SetStyle(0, 6, attrIn);
m_text->GetStyle(4, attrOut);
CPPUNIT_ASSERT( attrOut.HasFont() );
fontOut = attrOut.GetFont();
#ifdef __WXMSW__
fontOut.SetEncoding(fontIn.GetEncoding());
#endif
CPPUNIT_ASSERT_EQUAL( fontIn, fontOut );
}
void TextCtrlTestCase::Lines()
{
m_text->SetValue("line1\nline2\nlong long line 3");
m_text->Refresh();
m_text->Update();
CPPUNIT_ASSERT_EQUAL(3, m_text->GetNumberOfLines());
CPPUNIT_ASSERT_EQUAL(5, m_text->GetLineLength(0));
CPPUNIT_ASSERT_EQUAL("line2", m_text->GetLineText(1));
CPPUNIT_ASSERT_EQUAL(16, m_text->GetLineLength(2));
m_text->AppendText("\n\nMore text on line 5");
CPPUNIT_ASSERT_EQUAL(5, m_text->GetNumberOfLines());
CPPUNIT_ASSERT_EQUAL(0, m_text->GetLineLength(3));
CPPUNIT_ASSERT_EQUAL("", m_text->GetLineText(3));
// Verify that wrapped lines count as (at least) lines (but it can be more
// if it's wrapped more than once).
//
// This currently doesn't work neither in wxGTK, wxUniv, or wxOSX/Cocoa, see
// #12366, where GetNumberOfLines() always returns the number of logical,
// not physical, lines.
m_text->AppendText("\n" + wxString(50, '1') + ' ' + wxString(50, '2'));
#if defined(__WXGTK__) || defined(__WXOSX_COCOA__) || defined(__WXUNIVERSAL__) || defined(__WXQT__)
CPPUNIT_ASSERT_EQUAL(6, m_text->GetNumberOfLines());
#else
CPPUNIT_ASSERT(m_text->GetNumberOfLines() > 6);
#endif
}
#if wxUSE_LOG
void TextCtrlTestCase::LogTextCtrl()
{
CPPUNIT_ASSERT(m_text->IsEmpty());
wxLogTextCtrl* logtext = new wxLogTextCtrl(m_text);
wxLog* old = wxLog::SetActiveTarget(logtext);
logtext->LogText("text");
delete wxLog::SetActiveTarget(old);
CPPUNIT_ASSERT(!m_text->IsEmpty());
}
#endif // wxUSE_LOG
void TextCtrlTestCase::LongText()
{
// This test is only possible under MSW as in the other ports
// SetMaxLength() can't be used with multi line text controls.
#ifdef __WXMSW__
delete m_text;
CreateText(wxTE_MULTILINE|wxTE_DONTWRAP);
const int numLines = 1000;
const int lenPattern = 100;
int i;
// Pattern for the line.
wxChar linePattern[lenPattern+1];
for (i = 0; i < lenPattern - 1; i++)
{
linePattern[i] = wxChar('0' + i % 10);
}
linePattern[WXSIZEOF(linePattern) - 1] = wxChar('\0');
// Fill the control.
m_text->SetMaxLength(15000);
for (i = 0; i < numLines; i++)
{
m_text->AppendText(wxString::Format(wxT("[%3d] %s\n"), i, linePattern));
}
// Check the content.
for (i = 0; i < numLines; i++)
{
wxString pattern = wxString::Format(wxT("[%3d] %s"), i, linePattern);
wxString line = m_text->GetLineText(i);
CPPUNIT_ASSERT_EQUAL( line, pattern );
}
#endif // __WXMSW__
}
void TextCtrlTestCase::PositionToCoords()
{
DoPositionToCoordsTestWithStyle(0);
}
void TextCtrlTestCase::PositionToCoordsRich()
{
DoPositionToCoordsTestWithStyle(wxTE_RICH);
}
void TextCtrlTestCase::PositionToCoordsRich2()
{
DoPositionToCoordsTestWithStyle(wxTE_RICH2);
}
void TextCtrlTestCase::DoPositionToCoordsTestWithStyle(long style)
{
delete m_text;
CreateText(style|wxTE_MULTILINE);
// Asking for invalid index should fail.
WX_ASSERT_FAILS_WITH_ASSERT( m_text->PositionToCoords(1) );
// Getting position shouldn't return wxDefaultPosition except if the method
// is not implemented at all in the current port.
const wxPoint pos0 = m_text->PositionToCoords(0);
if ( pos0 == wxDefaultPosition )
{
#if ( wxHAS_2CHAR_NEWLINES ) || defined(__WXGTK20__)
CPPUNIT_FAIL( "PositionToCoords() unexpectedly failed." );
#endif
return;
}
CPPUNIT_ASSERT(pos0.x >= 0);
CPPUNIT_ASSERT(pos0.y >= 0);
m_text->SetValue("Hello");
wxYield(); // Let GTK layout the control correctly.
// Position of non-first character should be positive.
const long posHello4 = m_text->PositionToCoords(4).x;
CPPUNIT_ASSERT( posHello4 > 0 );
// Asking for position beyond the last character should succeed and return
// reasonable result.
CPPUNIT_ASSERT( m_text->PositionToCoords(5).x > posHello4 );
// But asking for the next position should fail.
WX_ASSERT_FAILS_WITH_ASSERT( m_text->PositionToCoords(6) );
// Test getting the coordinates of the last character when it is in the
// beginning of a new line to exercise MSW code which has specific logic
// for it.
m_text->AppendText("\n");
const wxPoint posLast = m_text->PositionToCoords(m_text->GetLastPosition());
CPPUNIT_ASSERT_EQUAL( pos0.x, posLast.x );
CPPUNIT_ASSERT( posLast.y > 0 );
// Add enough contents to the control to make sure it has a scrollbar.
m_text->SetValue("First line" + wxString(50, '\n') + "Last line");
m_text->SetInsertionPoint(0);
wxYield(); // Let GTK layout the control correctly.
// This shouldn't change anything for the first position coordinates.
CPPUNIT_ASSERT_EQUAL( pos0, m_text->PositionToCoords(0) );
// And the last one must be beyond the window boundary and so not be
// visible -- but getting its coordinate should still work.
CPPUNIT_ASSERT
(
m_text->PositionToCoords(m_text->GetLastPosition()).y > TEXT_HEIGHT
);
// Now make it scroll to the end and check that the first position now has
// negative offset as its above the visible part of the window while the
// last position is in its bounds.
m_text->SetInsertionPointEnd();
const int pos = m_text->GetInsertionPoint();
// wxGTK needs to yield here to update the text control.
#ifdef __WXGTK__
wxStopWatch sw;
while ( m_text->PositionToCoords(0).y == 0 ||
m_text->PositionToCoords(pos).y > TEXT_HEIGHT )
{
if ( sw.Time() > 1000 )
{
FAIL("Timed out waiting for wxTextCtrl update.");
break;
}
wxYield();
}
#endif // __WXGTK__
wxPoint coords = m_text->PositionToCoords(0);
INFO("First position coords = " << coords);
CPPUNIT_ASSERT( coords.y < 0 );
coords = m_text->PositionToCoords(pos);
INFO("Position is " << pos << ", coords = " << coords);
CPPUNIT_ASSERT( coords.y <= TEXT_HEIGHT );
}
void TextCtrlTestCase::PositionToXYMultiLine()
{
DoPositionToXYMultiLine(0);
}
#if wxUSE_RICHEDIT
void TextCtrlTestCase::PositionToXYMultiLineRich()
{
DoPositionToXYMultiLine(wxTE_RICH);
}
void TextCtrlTestCase::PositionToXYMultiLineRich2()
{
DoPositionToXYMultiLine(wxTE_RICH2);
}
#endif // wxUSE_RICHEDIT
void TextCtrlTestCase::DoPositionToXYMultiLine(long style)
{
delete m_text;
CreateText(style|wxTE_MULTILINE|wxTE_DONTWRAP);
#if wxHAS_2CHAR_NEWLINES
const bool isRichEdit = (style & (wxTE_RICH | wxTE_RICH2)) != 0;
#endif
typedef struct { long x, y; } XYPos;
bool ok;
wxString text;
// empty field
m_text->Clear();
const long numChars_0 = 0;
wxASSERT(numChars_0 == text.Length());
XYPos coords_0[numChars_0+1] =
{ { 0, 0 } };
CPPUNIT_ASSERT_EQUAL( numChars_0, m_text->GetLastPosition() );
for ( long i = 0; i < (long)WXSIZEOF(coords_0); i++ )
{
long x, y;
ok = m_text->PositionToXY(i, &x, &y);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( coords_0[i].x, x );
CPPUNIT_ASSERT_EQUAL( coords_0[i].y, y );
}
ok = m_text->PositionToXY(WXSIZEOF(coords_0), NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
// one line
text = wxS("1234");
m_text->SetValue(text);
const long numChars_1 = 4;
wxASSERT( numChars_1 == text.Length() );
XYPos coords_1[numChars_1+1] =
{ { 0, 0 }, { 1, 0 }, { 2, 0}, { 3, 0 }, { 4, 0 } };
CPPUNIT_ASSERT_EQUAL( numChars_1, m_text->GetLastPosition() );
for ( long i = 0; i < (long)WXSIZEOF(coords_1); i++ )
{
long x, y;
ok = m_text->PositionToXY(i, &x, &y);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( coords_1[i].x, x );
CPPUNIT_ASSERT_EQUAL( coords_1[i].y, y );
}
ok = m_text->PositionToXY(WXSIZEOF(coords_1), NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
// few lines
text = wxS("123\nab\nX");
m_text->SetValue(text);
#if wxHAS_2CHAR_NEWLINES
// Take into account that every new line mark occupies
// two characters, not one.
const long numChars_msw_2 = 8 + 2;
// Note: Two new line characters refer to the same X-Y position.
XYPos coords_2_msw[numChars_msw_2 + 1] =
{ { 0, 0 },{ 1, 0 },{ 2, 0 },{ 3, 0 },{ 3, 0 },
{ 0, 1 },{ 1, 1 },{ 2, 1 },{ 2, 1 },
{ 0, 2 },{ 1, 2 } };
#endif // WXMSW
const long numChars_2 = 8;
wxASSERT(numChars_2 == text.Length());
XYPos coords_2[numChars_2 + 1] =
{ { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 },
{ 0, 1 }, { 1, 1 }, { 2, 1 },
{ 0, 2 }, { 1, 2 } };
const long &ref_numChars_2 =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? numChars_2 : numChars_msw_2;
#else
numChars_2;
#endif
XYPos *ref_coords_2 =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? coords_2 : coords_2_msw;
#else
coords_2;
#endif
CPPUNIT_ASSERT_EQUAL( ref_numChars_2, m_text->GetLastPosition() );
for ( long i = 0; i < ref_numChars_2+1; i++ )
{
long x, y;
ok = m_text->PositionToXY(i, &x, &y);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( ref_coords_2[i].x, x );
CPPUNIT_ASSERT_EQUAL( ref_coords_2[i].y, y );
}
ok = m_text->PositionToXY(ref_numChars_2 + 1, NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
// only empty lines
text = wxS("\n\n\n");
m_text->SetValue(text);
#if wxHAS_2CHAR_NEWLINES
// Take into account that every new line mark occupies
// two characters, not one.
const long numChars_msw_3 = 3 + 3;
// Note: Two new line characters refer to the same X-Y position.
XYPos coords_3_msw[numChars_msw_3 + 1] =
{ { 0, 0 },{ 0, 0 },
{ 0, 1 },{ 0, 1 },
{ 0, 2 },{ 0, 2 },
{ 0, 3 } };
#endif // WXMSW
const long numChars_3 = 3;
wxASSERT(numChars_3 == text.Length());
XYPos coords_3[numChars_3+1] =
{ { 0, 0 },
{ 0, 1 },
{ 0, 2 },
{ 0, 3 } };
const long &ref_numChars_3 =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? numChars_3 : numChars_msw_3;
#else
numChars_3;
#endif
XYPos *ref_coords_3 =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? coords_3 : coords_3_msw;
#else
coords_3;
#endif
CPPUNIT_ASSERT_EQUAL( ref_numChars_3, m_text->GetLastPosition() );
for ( long i = 0; i < ref_numChars_3+1; i++ )
{
long x, y;
ok = m_text->PositionToXY(i, &x, &y);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( ref_coords_3[i].x, x );
CPPUNIT_ASSERT_EQUAL( ref_coords_3[i].y, y );
}
ok = m_text->PositionToXY(ref_numChars_3 + 1, NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
// mixed empty/non-empty lines
text = wxS("123\na\n\nX\n\n");
m_text->SetValue(text);
#if wxHAS_2CHAR_NEWLINES
// Take into account that every new line mark occupies
// two characters, not one.
const long numChars_msw_4 = 10 + 5;
// Note: Two new line characters refer to the same X-Y position.
XYPos coords_4_msw[numChars_msw_4 + 1] =
{ { 0, 0 },{ 1, 0 },{ 2, 0 },{ 3, 0 },{ 3, 0 },
{ 0, 1 },{ 1, 1 },{ 1, 1 },
{ 0, 2 },{ 0, 2 },
{ 0, 3 },{ 1, 3 },{ 1, 3 },
{ 0, 4 },{ 0, 4 },
{ 0, 5 } };
#endif // WXMSW
const long numChars_4 = 10;
wxASSERT(numChars_4 == text.Length());
XYPos coords_4[numChars_4+1] =
{ { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 },
{ 0, 1 }, { 1, 1 },
{ 0, 2 },
{ 0, 3 }, { 1, 3 },
{ 0, 4 },
{ 0, 5 } };
const long &ref_numChars_4 =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? numChars_4 : numChars_msw_4;
#else
numChars_4;
#endif
XYPos *ref_coords_4 =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? coords_4 : coords_4_msw;
#else
coords_4;
#endif
CPPUNIT_ASSERT_EQUAL( ref_numChars_4, m_text->GetLastPosition() );
for ( long i = 0; i < ref_numChars_4+1; i++ )
{
long x, y;
ok = m_text->PositionToXY(i, &x, &y);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( ref_coords_4[i].x, x );
CPPUNIT_ASSERT_EQUAL( ref_coords_4[i].y, y );
}
ok = m_text->PositionToXY(ref_numChars_4 + 1, NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
}
void TextCtrlTestCase::XYToPositionMultiLine()
{
DoXYToPositionMultiLine(0);
}
#if wxUSE_RICHEDIT
void TextCtrlTestCase::XYToPositionMultiLineRich()
{
DoXYToPositionMultiLine(wxTE_RICH);
}
void TextCtrlTestCase::XYToPositionMultiLineRich2()
{
DoXYToPositionMultiLine(wxTE_RICH2);
}
#endif // wxUSE_RICHEDIT
void TextCtrlTestCase::DoXYToPositionMultiLine(long style)
{
delete m_text;
CreateText(style|wxTE_MULTILINE|wxTE_DONTWRAP);
#if wxHAS_2CHAR_NEWLINES
const bool isRichEdit = (style & (wxTE_RICH | wxTE_RICH2)) != 0;
#endif
wxString text;
// empty field
m_text->Clear();
const long maxLineLength_0 = 0+1;
const long numLines_0 = 1;
CPPUNIT_ASSERT_EQUAL( numLines_0, m_text->GetNumberOfLines() );
long pos_0[numLines_0+1][maxLineLength_0+1] =
{ { 0, -1 },
{ -1, -1 } };
for ( long y = 0; y < numLines_0+1; y++ )
for( long x = 0; x < maxLineLength_0+1; x++ )
{
long p = m_text->XYToPosition(x, y);
INFO("x=" << x << ", y=" << y);
CPPUNIT_ASSERT_EQUAL( pos_0[y][x], p );
}
// one line
text = wxS("1234");
m_text->SetValue(text);
const long maxLineLength_1 = 4+1;
const long numLines_1 = 1;
CPPUNIT_ASSERT_EQUAL( numLines_1, m_text->GetNumberOfLines() );
long pos_1[numLines_1+1][maxLineLength_1+1] =
{ { 0, 1, 2, 3, 4, -1 },
{ -1, -1, -1, -1, -1, -1 } };
for ( long y = 0; y < numLines_1+1; y++ )
for( long x = 0; x < maxLineLength_1+1; x++ )
{
long p = m_text->XYToPosition(x, y);
INFO("x=" << x << ", y=" << y);
CPPUNIT_ASSERT_EQUAL( pos_1[y][x], p );
}
// few lines
text = wxS("123\nab\nX");
m_text->SetValue(text);
const long maxLineLength_2 = 4;
const long numLines_2 = 3;
CPPUNIT_ASSERT_EQUAL( numLines_2, m_text->GetNumberOfLines() );
#if wxHAS_2CHAR_NEWLINES
// Note: New lines are occupied by two characters.
long pos_2_msw[numLines_2 + 1][maxLineLength_2 + 1] =
{ { 0, 1, 2, 3, -1 }, // New line occupies positions 3, 4
{ 5, 6, 7, -1, -1 }, // New line occupies positions 7, 8
{ 9, 10, -1, -1, -1 },
{ -1, -1, -1, -1, -1 } };
#endif // WXMSW
long pos_2[numLines_2+1][maxLineLength_2+1] =
{ { 0, 1, 2, 3, -1 },
{ 4, 5, 6, -1, -1 },
{ 7, 8, -1, -1, -1 },
{ -1, -1, -1, -1, -1 } };
long (&ref_pos_2)[numLines_2 + 1][maxLineLength_2 + 1] =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? pos_2 : pos_2_msw;
#else
pos_2;
#endif
for ( long y = 0; y < numLines_2+1; y++ )
for( long x = 0; x < maxLineLength_2+1; x++ )
{
long p = m_text->XYToPosition(x, y);
INFO("x=" << x << ", y=" << y);
CPPUNIT_ASSERT_EQUAL( ref_pos_2[y][x], p );
}
// only empty lines
text = wxS("\n\n\n");
m_text->SetValue(text);
const long maxLineLength_3 = 1;
const long numLines_3 = 4;
CPPUNIT_ASSERT_EQUAL( numLines_3, m_text->GetNumberOfLines() );
#if wxHAS_2CHAR_NEWLINES
// Note: New lines are occupied by two characters.
long pos_3_msw[numLines_3 + 1][maxLineLength_3 + 1] =
{ { 0, -1 }, // New line occupies positions 0, 1
{ 2, -1 }, // New line occupies positions 2, 3
{ 4, -1 }, // New line occupies positions 4, 5
{ 6, -1 },
{ -1, -1 } };
#endif // WXMSW
long pos_3[numLines_3+1][maxLineLength_3+1] =
{ { 0, -1 },
{ 1, -1 },
{ 2, -1 },
{ 3, -1 },
{ -1, -1 } };
long (&ref_pos_3)[numLines_3 + 1][maxLineLength_3 + 1] =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? pos_3 : pos_3_msw;
#else
pos_3;
#endif
for ( long y = 0; y < numLines_3+1; y++ )
for( long x = 0; x < maxLineLength_3+1; x++ )
{
long p = m_text->XYToPosition(x, y);
INFO("x=" << x << ", y=" << y);
CPPUNIT_ASSERT_EQUAL( ref_pos_3[y][x], p );
}
// mixed empty/non-empty lines
text = wxS("123\na\n\nX\n\n");
m_text->SetValue(text);
const long maxLineLength_4 = 4;
const long numLines_4 = 6;
CPPUNIT_ASSERT_EQUAL( numLines_4, m_text->GetNumberOfLines() );
#if wxHAS_2CHAR_NEWLINES
// Note: New lines are occupied by two characters.
long pos_4_msw[numLines_4 + 1][maxLineLength_4 + 1] =
{ { 0, 1, 2, 3, -1 }, // New line occupies positions 3, 4
{ 5, 6, -1, -1, -1 }, // New line occupies positions 6, 7
{ 8, -1, -1, -1, -1 }, // New line occupies positions 8, 9
{ 10, 11, -1, -1, -1 }, // New line occupies positions 11, 12
{ 13, -1, -1, -1, -1 }, // New line occupies positions 13, 14
{ 15, -1, -1, -1, -1 },
{ -1, -1, -1, -1, -1 } };
#endif // WXMSW
long pos_4[numLines_4+1][maxLineLength_4+1] =
{ { 0, 1, 2, 3, -1 },
{ 4, 5, -1, -1, -1 },
{ 6, -1, -1, -1, -1 },
{ 7, 8, -1, -1, -1 },
{ 9, -1, -1, -1, -1 },
{ 10, -1, -1, -1, -1 },
{ -1, -1, -1, -1, -1 } };
long (&ref_pos_4)[numLines_4 + 1][maxLineLength_4 + 1] =
#if wxHAS_2CHAR_NEWLINES
isRichEdit ? pos_4 : pos_4_msw;
#else
pos_4;
#endif
for ( long y = 0; y < numLines_4+1; y++ )
for( long x = 0; x < maxLineLength_4+1; x++ )
{
long p = m_text->XYToPosition(x, y);
INFO("x=" << x << ", y=" << y);
CPPUNIT_ASSERT_EQUAL( ref_pos_4[y][x], p );
}
}
void TextCtrlTestCase::PositionToXYSingleLine()
{
delete m_text;
CreateText(wxTE_DONTWRAP);
bool ok;
wxString text;
// empty field
m_text->Clear();
const long numChars_0 = 0;
CPPUNIT_ASSERT_EQUAL( numChars_0, m_text->GetLastPosition() );
for ( long i = 0; i <= numChars_0; i++ )
{
long x0, y0;
ok = m_text->PositionToXY(i, &x0, &y0);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( i, x0 );
CPPUNIT_ASSERT_EQUAL( 0, y0 );
}
ok = m_text->PositionToXY(numChars_0+1, NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
// pure one line
text = wxS("1234");
m_text->SetValue(text);
const long numChars_1 = text.Length();
CPPUNIT_ASSERT_EQUAL( numChars_1, m_text->GetLastPosition() );
for ( long i = 0; i <= numChars_1; i++ )
{
long x1, y1;
ok = m_text->PositionToXY(i, &x1, &y1);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( i, x1 );
CPPUNIT_ASSERT_EQUAL( 0, y1 );
}
ok = m_text->PositionToXY(numChars_1+1, NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
// with new line characters
text = wxS("123\nab\nX");
m_text->SetValue(text);
const long numChars_2 = text.Length();
CPPUNIT_ASSERT_EQUAL( numChars_2, m_text->GetLastPosition() );
for ( long i = 0; i <= numChars_2; i++ )
{
long x2, y2;
ok = m_text->PositionToXY(i, &x2, &y2);
CPPUNIT_ASSERT_EQUAL( true, ok );
CPPUNIT_ASSERT_EQUAL( i, x2 );
CPPUNIT_ASSERT_EQUAL( 0, y2 );
}
ok = m_text->PositionToXY(numChars_2+1, NULL, NULL);
CPPUNIT_ASSERT_EQUAL( false, ok );
}
void TextCtrlTestCase::XYToPositionSingleLine()
{
delete m_text;
CreateText(wxTE_DONTWRAP);
wxString text;
// empty field
m_text->Clear();
CPPUNIT_ASSERT_EQUAL( 1, m_text->GetNumberOfLines() );
for( long x = 0; x < m_text->GetLastPosition()+2; x++ )
{
long p0 = m_text->XYToPosition(x, 0);
if ( x <= m_text->GetLastPosition() )
CPPUNIT_ASSERT_EQUAL( x, p0 );
else
CPPUNIT_ASSERT_EQUAL( -1, p0 );
p0 = m_text->XYToPosition(x, 1);
CPPUNIT_ASSERT_EQUAL( -1, p0 );
}
// pure one line
text = wxS("1234");
m_text->SetValue(text);
CPPUNIT_ASSERT_EQUAL( 1, m_text->GetNumberOfLines() );
for( long x = 0; x < m_text->GetLastPosition()+2; x++ )
{
long p1 = m_text->XYToPosition(x, 0);
if ( x <= m_text->GetLastPosition() )
CPPUNIT_ASSERT_EQUAL( x, p1 );
else
CPPUNIT_ASSERT_EQUAL( -1, p1 );
p1 = m_text->XYToPosition(x, 1);
CPPUNIT_ASSERT_EQUAL( -1, p1 );
}
// with new line characters
text = wxS("123\nab\nX");
m_text->SetValue(text);
CPPUNIT_ASSERT_EQUAL( 1, m_text->GetNumberOfLines() );
for( long x = 0; x < m_text->GetLastPosition()+2; x++ )
{
long p2 = m_text->XYToPosition(x, 0);
if ( x <= m_text->GetLastPosition() )
CPPUNIT_ASSERT_EQUAL( x, p2 );
else
CPPUNIT_ASSERT_EQUAL( -1, p2 );
p2 = m_text->XYToPosition(x, 1);
CPPUNIT_ASSERT_EQUAL( -1, p2 );
}
}
TEST_CASE("wxTextCtrl::ProcessEnter", "[wxTextCtrl][enter]")
{
class TextCtrlCreator : public TextLikeControlCreator
{
public:
explicit TextCtrlCreator(int styleToAdd = 0)
: m_styleToAdd(styleToAdd)
{
}
virtual wxControl* Create(wxWindow* parent, int style) const wxOVERRIDE
{
return new wxTextCtrl(parent, wxID_ANY, wxString(),
wxDefaultPosition, wxDefaultSize,
style | m_styleToAdd);
}
virtual TextLikeControlCreator* CloneAsMultiLine() const wxOVERRIDE
{
return new TextCtrlCreator(wxTE_MULTILINE);
}
private:
int m_styleToAdd;
};
TestProcessEnter(TextCtrlCreator());
}
TEST_CASE("wxTextCtrl::GetBestSize", "[wxTextCtrl][best-size]")
{
struct GetBestSizeFor
{
wxSize operator()(const wxString& text) const
{
wxScopedPtr<wxTextCtrl>
t(new wxTextCtrl(wxTheApp->GetTopWindow(), wxID_ANY, text,
wxDefaultPosition, wxDefaultSize,
wxTE_MULTILINE));
return t->GetBestSize();
}
} getBestSizeFor;
wxString s;
const wxSize sizeEmpty = getBestSizeFor(s);
// Empty control should have some reasonable vertical size.
CHECK( sizeEmpty.y > 0 );
s += "1\n2\n3\n4\n5\n";
const wxSize sizeMedium = getBestSizeFor(s);
// Control with a few lines of text in it should be taller.
CHECK( sizeMedium.y > sizeEmpty.y );
s += "6\n7\n8\n9\n10\n";
const wxSize sizeLong = getBestSizeFor(s);
// And a control with many lines in it should be even more so.
CHECK( sizeLong.y > sizeMedium.y );
s += s;
s += s;
s += s;
const wxSize sizeVeryLong = getBestSizeFor(s);
// However there is a cutoff at 10 lines currently, so anything longer than
// that should still have the same best size.
CHECK( sizeVeryLong.y == sizeLong.y );
}
#if wxUSE_CLIPBOARD
TEST_CASE("wxTextCtrl::LongPaste", "[wxTextCtrl][clipboard][paste]")
{
long style = 0;
SECTION("Plain")
{
style = wxTE_MULTILINE;
}
// wxTE_RICH[2] style only makes any different under MSW, so don't bother
// testing it under the other platforms.
#ifdef __WXMSW__
SECTION("Rich")
{
style = wxTE_MULTILINE | wxTE_RICH;
}
SECTION("Rich v2")
{
style = wxTE_MULTILINE | wxTE_RICH2;
}
#endif // __WXMSW__
if ( !style )
{
// This can happen when explicitly selecting just a single section to
// execute -- this code still runs even if the corresponding section is
// skipped, so we have to explicitly skip it too in this case.
return;
}
wxScopedPtr<wxTextCtrl>
text(new wxTextCtrl(wxTheApp->GetTopWindow(), wxID_ANY, wxString(),
wxDefaultPosition, wxDefaultSize, style));
// This could actually be much higher, but it makes the test proportionally
// slower, so use a relatively small (but still requiring more space than
// the default maximum length under MSW) number here.
const int NUM_LINES = 10000;
{
wxClipboardLocker lock;
// Build a longish string.
wxString s;
s.reserve(NUM_LINES*5 + 10);
for ( int n = 0; n < NUM_LINES; ++n )
{
s += wxString::Format("%04d\n", n);
}
s += "THE END";
wxTheClipboard->AddData(new wxTextDataObject(s));
}
text->ChangeValue("THE BEGINNING\n");
text->SetInsertionPointEnd();
text->Paste();
const int numLines = text->GetNumberOfLines();
CHECK( numLines == NUM_LINES + 2 );
CHECK( text->GetLineText(numLines - 1) == "THE END" );
}
#endif // wxUSE_CLIPBOARD
TEST_CASE("wxTextCtrl::EventsOnCreate", "[wxTextCtrl][event]")
{
wxWindow* const parent = wxTheApp->GetTopWindow();
EventCounter updated(parent, wxEVT_TEXT);
wxScopedPtr<wxTextCtrl> text(new wxTextCtrl(parent, wxID_ANY, "Hello"));
// Creating the control shouldn't result in any wxEVT_TEXT events.
CHECK( updated.GetCount() == 0 );
// Check that modifying using SetValue() it does generate the event, just
// to verify that this test works (there are more detailed tests for this
// in TextEntryTestCase::TextChangeEvents()).
text->SetValue("Bye");
CHECK( updated.GetCount() == 1 );
}
TEST_CASE("wxTextCtrl::InitialCanUndo", "[wxTextCtrl][undo]")
{
wxWindow* const parent = wxTheApp->GetTopWindow();
const long styles[] = { 0, wxTE_RICH, wxTE_RICH2 };
for ( size_t n = 0; n < WXSIZEOF(styles); n++ )
{
const long style = styles[n];
#ifdef __MINGW32_TOOLCHAIN__
if ( style == wxTE_RICH2 )
{
// We can't call ITextDocument::Undo() in wxMSW code when using
// MinGW32, so this test would always fail with it.
WARN("Skipping test known to fail with MinGW-32.");
}
continue;
#endif // __MINGW32_TOOLCHAIN__
INFO("wxTextCtrl with style " << style);
wxScopedPtr<wxTextCtrl> text(new wxTextCtrl(parent, wxID_ANY, "",
wxDefaultPosition,
wxDefaultSize,
style));
CHECK( !text->CanUndo() );
}
}
// This test would always fail with MinGW-32 for the same reason as described
// above.
#ifndef __MINGW32_TOOLCHAIN__
TEST_CASE("wxTextCtrl::EmptyUndoBuffer", "[wxTextCtrl][undo]")
{
if ( wxIsRunningUnderWine() )
{
// Wine doesn't implement EM_GETOLEINTERFACE and related stuff currently
WARN("Skipping test known to fail under Wine.");
return;
}
wxScopedPtr<wxTextCtrl> text(new wxTextCtrl(wxTheApp->GetTopWindow(),
wxID_ANY, "",
wxDefaultPosition,
wxDefaultSize,
wxTE_MULTILINE | wxTE_RICH2));
text->AppendText("foo");
if ( !text->CanUndo() )
{
WARN("Skipping test as Undo() is not supported on this platform.");
return;
}
text->EmptyUndoBuffer();
CHECK_FALSE( text->CanUndo() );
CHECK_NOTHROW( text->Undo() );
CHECK( text->GetValue() == "foo" );
}
#endif // __MINGW32_TOOLCHAIN__
#endif //wxUSE_TEXTCTRL
Reference in New Issue View Git Blame Copy Permalink