[wxWidgets.git] / tests / events / keyboard.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/events/keyboard.cpp
// Purpose:     Test keyboard events
// Author:      Vadim Zeitlin
// Created:     2010-09-05
// Copyright:   (c) 2010 Vadim Zeitlin <vadim@wxwidgets.org>
///////////////////////////////////////////////////////////////////////////////

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

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// FIXME: As all the other tests involving wxUIActionSimulator, this one is
//        broken under OS X, the test window siply never gets any events.
#if wxUSE_UIACTIONSIMULATOR && !defined(__WXOSX__)

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/event.h"
    #include "wx/window.h"
#endif // WX_PRECOMP

#include "wx/uiaction.h"
#include "wx/vector.h"

namespace
{

// ----------------------------------------------------------------------------
// test window verifying the event generation
// ----------------------------------------------------------------------------

class KeyboardTestWindow : public wxWindow
{
public:
    KeyboardTestWindow(wxWindow *parent)
        : wxWindow(parent, wxID_ANY, wxPoint(0, 0), parent->GetClientSize())
    {
        Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(KeyboardTestWindow::OnKeyDown));
        Connect(wxEVT_CHAR, wxKeyEventHandler(KeyboardTestWindow::OnChar));
        Connect(wxEVT_KEY_UP, wxKeyEventHandler(KeyboardTestWindow::OnKeyUp));
    }

    unsigned GetKeyDownCount() const { return m_keyDownEvents.size(); }
    unsigned GetCharCount() const { return m_charEvents.size(); }
    unsigned GetKeyUpCount() const { return m_keyUpEvents.size(); }

    const wxKeyEvent& GetKeyDownEvent(unsigned n = 0) const
    {
        return m_keyDownEvents[n];
    }
    const wxKeyEvent& GetCharEvent(unsigned n = 0) const
    {
        return m_charEvents[n];
    }
    const wxKeyEvent& GetKeyUpEvent(unsigned n = 0) const
    {
        return m_keyUpEvents[n];
    }

    void ClearEvents()
    {
        m_keyDownEvents =
        m_charEvents =
        m_keyUpEvents = wxVector<wxKeyEvent>();
    }

private:
    void OnKeyDown(wxKeyEvent& event)
    {
        m_keyDownEvents.push_back(event);
        event.Skip();
    }

    void OnChar(wxKeyEvent& event)
    {
        m_charEvents.push_back(event);
        event.Skip();
    }

    void OnKeyUp(wxKeyEvent& event)
    {
        m_keyUpEvents.push_back(event);
        event.Skip();
    }

    wxVector<wxKeyEvent> m_keyDownEvents,
                         m_charEvents,
                         m_keyUpEvents;


    wxDECLARE_NO_COPY_CLASS(KeyboardTestWindow);
};

// Object describing the (main fields of) keyboard event.
struct KeyDesc
{
    KeyDesc(int keycode, int mods = 0)
        : m_keycode(keycode),
          m_mods(mods)
    {
    }

    int m_keycode;
    int m_mods;
};

// Helper for ModKeyDown().
int GetModForKey(int keycode)
{
    switch ( keycode )
    {
        case WXK_CONTROL:   return wxMOD_CONTROL;
        case WXK_SHIFT:     return wxMOD_SHIFT;
        case WXK_ALT:       return wxMOD_ALT;
        default:
            wxFAIL_MSG( "Unknown modifier key" );
    }

    return wxMOD_NONE;
}

// Helper function to allow writing just ModKeyDown(WXK_CONTROL) instead of
// more verbose KeyDesc(WXK_CONTROL, wxMOD_CONTROL).
KeyDesc ModKeyDown(int keycode)
{
    return KeyDesc(keycode, GetModForKey(keycode));
}

// Another helper provided for symmetry with ModKeyDown() only.
KeyDesc ModKeyUp(int keycode)
{
    return KeyDesc(keycode);
}

// Verify that the event object corresponds to our idea of what it should be.
void TestEvent(int line, const wxKeyEvent& ev, const KeyDesc& desc)
{
    // Construct the message we'll display if an assert fails.
    std::string msg;
    const wxEventType t = ev.GetEventType();
    if ( t == wxEVT_KEY_DOWN )
        msg = "key down";
    else if ( t == wxEVT_CHAR )
        msg = "char";
    else if ( t == wxEVT_KEY_UP )
        msg = "key up";
    else
        CPPUNIT_FAIL( "unknown event type" );

    msg += " event at line ";
    msg += wxString::Format("%d", line).mb_str();


    CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong key code in " + msg,
                                  desc.m_keycode,
                                  ev.GetKeyCode() );

#if wxUSE_UNICODE
    if ( desc.m_keycode < WXK_START )
    {
        // For Latin-1 our key code is the same as Unicode character value.
        CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong Unicode key in " + msg,
                                      (char)desc.m_keycode,
                                      (char)ev.GetUnicodeKey() );
    }
    else // Special key
    {
        // Key codes above WXK_START don't correspond to printable characters.
        CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong non-zero Unicode key in " + msg,
                                      0,
                                      (int)ev.GetUnicodeKey() );
    }
#endif // wxUSE_UNICODE

    CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong modifiers in " + msg,
                                  desc.m_mods,
                                  ev.GetModifiers() );
}

// Call TestEvent() passing it the line number from where it was called: this
// is useful for interpreting the assert failure messages.
#define ASSERT_KEY_EVENT_IS( ev, desc ) TestEvent(__LINE__, ev, desc)

} // anonymous namespace

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

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

    virtual void setUp();
    virtual void tearDown();

private:
    CPPUNIT_TEST_SUITE( KeyboardEventTestCase );
        CPPUNIT_TEST( NormalLetter );
        CPPUNIT_TEST( NormalSpecial );
        CPPUNIT_TEST( CtrlLetter );
        CPPUNIT_TEST( CtrlSpecial );
        CPPUNIT_TEST( ShiftLetter );
        CPPUNIT_TEST( ShiftSpecial );
    CPPUNIT_TEST_SUITE_END();

    void NormalLetter();
    void NormalSpecial();
    void CtrlLetter();
    void CtrlSpecial();
    void ShiftLetter();
    void ShiftSpecial();

    KeyboardTestWindow *m_win;

    wxDECLARE_NO_COPY_CLASS(KeyboardEventTestCase);
};

wxREGISTER_UNIT_TEST(KeyboardEvent);

void KeyboardEventTestCase::setUp()
{
    m_win = new KeyboardTestWindow(wxTheApp->GetTopWindow());
    m_win->SetFocus();
    wxYield(); // needed to show the new window

    // The window might get some key up events when it's being shown if the key
    // was pressed when the program was started and released after the window
    // was shown, e.g. this does happen in practice when launching the test
    // from command line. Simply discard all the spurious events so far.
    m_win->ClearEvents();
}

void KeyboardEventTestCase::tearDown()
{
    m_win->Destroy();
}

void KeyboardEventTestCase::NormalLetter()
{
    wxUIActionSimulator sim;
    sim.Char('a');
    wxYield();

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyDownCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(), 'A' );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(), 'a' );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyUpCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(), 'A' );
}

void KeyboardEventTestCase::NormalSpecial()
{
    wxUIActionSimulator sim;
    sim.Char(WXK_END);
    wxYield();

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyDownCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(), WXK_END );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(), WXK_END );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyUpCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(), WXK_END );
}

void KeyboardEventTestCase::CtrlLetter()
{
    wxUIActionSimulator sim;
    sim.Char('z', wxMOD_CONTROL);
    wxYield();

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
                         ModKeyDown(WXK_CONTROL) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
                         KeyDesc('Z', wxMOD_CONTROL) );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
                         KeyDesc('\x1a', wxMOD_CONTROL) );

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
                         KeyDesc('Z', wxMOD_CONTROL) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
                         ModKeyUp(WXK_CONTROL) );
}

void KeyboardEventTestCase::CtrlSpecial()
{
    wxUIActionSimulator sim;
    sim.Char(WXK_PAGEUP, wxMOD_CONTROL);
    wxYield();

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
                         ModKeyDown(WXK_CONTROL) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
                         KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
                         KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
                         KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
                         ModKeyUp(WXK_CONTROL) );
}

void KeyboardEventTestCase::ShiftLetter()
{
    wxUIActionSimulator sim;
    sim.Char('Q', wxMOD_SHIFT);
    wxYield();

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
                         ModKeyDown(WXK_SHIFT) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
                         KeyDesc('Q', wxMOD_SHIFT) );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
                         KeyDesc('Q', wxMOD_SHIFT) );

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
                         KeyDesc('Q', wxMOD_SHIFT) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
                         ModKeyUp(WXK_SHIFT) );
}

void KeyboardEventTestCase::ShiftSpecial()
{
    wxUIActionSimulator sim;
    sim.Char(WXK_F3, wxMOD_SHIFT);
    wxYield();

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
                         ModKeyDown(WXK_SHIFT) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
                         KeyDesc(WXK_F3, wxMOD_SHIFT) );

    CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
                         KeyDesc(WXK_F3, wxMOD_SHIFT) );

    CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
                         KeyDesc(WXK_F3, wxMOD_SHIFT) );
    ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
                         ModKeyUp(WXK_SHIFT) );
}

#endif // wxUSE_UIACTIONSIMULATOR
Commit	Line	Data
042ddf5d VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/events/keyboard.cpp
	3	// Purpose: Test keyboard events
	4	// Author: Vadim Zeitlin
	5	// Created: 2010-09-05
042ddf5d VZ	6	// Copyright: (c) 2010 Vadim Zeitlin <vadim@wxwidgets.org>
	7	///////////////////////////////////////////////////////////////////////////////
	8
	9	// ----------------------------------------------------------------------------
	10	// headers
	11	// ----------------------------------------------------------------------------
	12
	13	#include "testprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
4a695c46 VZ	19	// FIXME: As all the other tests involving wxUIActionSimulator, this one is
	20	// broken under OS X, the test window siply never gets any events.
	21	#if wxUSE_UIACTIONSIMULATOR && !defined(__WXOSX__)
042ddf5d VZ	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/app.h"
	25	#include "wx/event.h"
	26	#include "wx/window.h"
	27	#endif // WX_PRECOMP
	28
	29	#include "wx/uiaction.h"
	30	#include "wx/vector.h"
	31
	32	namespace
	33	{
	34
	35	// ----------------------------------------------------------------------------
	36	// test window verifying the event generation
	37	// ----------------------------------------------------------------------------
	38
	39	class KeyboardTestWindow : public wxWindow
	40	{
	41	public:
	42	KeyboardTestWindow(wxWindow *parent)
4a695c46	43	: wxWindow(parent, wxID_ANY, wxPoint(0, 0), parent->GetClientSize())
042ddf5d VZ	44	{
	45	Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(KeyboardTestWindow::OnKeyDown));
	46	Connect(wxEVT_CHAR, wxKeyEventHandler(KeyboardTestWindow::OnChar));
	47	Connect(wxEVT_KEY_UP, wxKeyEventHandler(KeyboardTestWindow::OnKeyUp));
	48	}
	49
	50	unsigned GetKeyDownCount() const { return m_keyDownEvents.size(); }
	51	unsigned GetCharCount() const { return m_charEvents.size(); }
	52	unsigned GetKeyUpCount() const { return m_keyUpEvents.size(); }
	53
	54	const wxKeyEvent& GetKeyDownEvent(unsigned n = 0) const
	55	{
	56	return m_keyDownEvents[n];
	57	}
	58	const wxKeyEvent& GetCharEvent(unsigned n = 0) const
	59	{
	60	return m_charEvents[n];
	61	}
	62	const wxKeyEvent& GetKeyUpEvent(unsigned n = 0) const
	63	{
	64	return m_keyUpEvents[n];
	65	}
	66
	67	void ClearEvents()
	68	{
	69	m_keyDownEvents =
	70	m_charEvents =
	71	m_keyUpEvents = wxVector<wxKeyEvent>();
	72	}
	73
	74	private:
	75	void OnKeyDown(wxKeyEvent& event)
	76	{
	77	m_keyDownEvents.push_back(event);
	78	event.Skip();
	79	}
	80
	81	void OnChar(wxKeyEvent& event)
	82	{
	83	m_charEvents.push_back(event);
	84	event.Skip();
	85	}
	86
	87	void OnKeyUp(wxKeyEvent& event)
	88	{
	89	m_keyUpEvents.push_back(event);
	90	event.Skip();
	91	}
	92
	93	wxVector<wxKeyEvent> m_keyDownEvents,
	94	m_charEvents,
	95	m_keyUpEvents;
	96
	97
	98	wxDECLARE_NO_COPY_CLASS(KeyboardTestWindow);
	99	};
	100
	101	// Object describing the (main fields of) keyboard event.
	102	struct KeyDesc
	103	{
	104	KeyDesc(int keycode, int mods = 0)
	105	: m_keycode(keycode),
	106	m_mods(mods)
	107	{
108	}
109
110	int m_keycode;
111	int m_mods;
112	};
113
d0fb62a6	114	// Helper for ModKeyDown().
042ddf5d VZ	115	int GetModForKey(int keycode)
	116	{
	117	switch ( keycode )
	118	{
	119	case WXK_CONTROL: return wxMOD_CONTROL;
	120	case WXK_SHIFT: return wxMOD_SHIFT;
	121	case WXK_ALT: return wxMOD_ALT;
	122	default:
	123	wxFAIL_MSG( "Unknown modifier key" );
	124	}
	125
	126	return wxMOD_NONE;
	127	}
	128
d0fb62a6 VZ	129	// Helper function to allow writing just ModKeyDown(WXK_CONTROL) instead of
d0fb62a6 VZ	130	// more verbose KeyDesc(WXK_CONTROL, wxMOD_CONTROL).
042ddf5d VZ	131	KeyDesc ModKeyDown(int keycode)
	132	{
	133	return KeyDesc(keycode, GetModForKey(keycode));
	134	}
	135
d0fb62a6	136	// Another helper provided for symmetry with ModKeyDown() only.
042ddf5d VZ	137	KeyDesc ModKeyUp(int keycode)
	138	{
	139	return KeyDesc(keycode);
	140	}
	141
042ddf5d VZ	142	// Verify that the event object corresponds to our idea of what it should be.
	143	void TestEvent(int line, const wxKeyEvent& ev, const KeyDesc& desc)
	144	{
	145	// Construct the message we'll display if an assert fails.
	146	std::string msg;
	147	const wxEventType t = ev.GetEventType();
	148	if ( t == wxEVT_KEY_DOWN )
	149	msg = "key down";
	150	else if ( t == wxEVT_CHAR )
	151	msg = "char";
	152	else if ( t == wxEVT_KEY_UP )
	153	msg = "key up";
	154	else
	155	CPPUNIT_FAIL( "unknown event type" );
	156
	157	msg += " event at line ";
	158	msg += wxString::Format("%d", line).mb_str();
	159
	160
	161	CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong key code in " + msg,
	162	desc.m_keycode,
	163	ev.GetKeyCode() );
	164
	165	#if wxUSE_UNICODE
7333c0ef	166	if ( desc.m_keycode < WXK_START )
042ddf5d	167	{
7333c0ef VZ	168	// For Latin-1 our key code is the same as Unicode character value.
	169	CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong Unicode key in " + msg,
	170	(char)desc.m_keycode,
	171	(char)ev.GetUnicodeKey() );
042ddf5d	172	}
7333c0ef	173	else // Special key
042ddf5d	174	{
7333c0ef	175	// Key codes above WXK_START don't correspond to printable characters.
042ddf5d VZ	176	CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong non-zero Unicode key in " + msg,
	177	0,
	178	(int)ev.GetUnicodeKey() );
	179	}
	180	#endif // wxUSE_UNICODE
	181
	182	CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong modifiers in " + msg,
	183	desc.m_mods,
	184	ev.GetModifiers() );
	185	}
	186
	187	// Call TestEvent() passing it the line number from where it was called: this
	188	// is useful for interpreting the assert failure messages.
	189	#define ASSERT_KEY_EVENT_IS( ev, desc ) TestEvent(__LINE__, ev, desc)
	190
	191	} // anonymous namespace
	192
	193	// --------------------------------------------------------------------------
	194	// test class
	195	// --------------------------------------------------------------------------
	196
	197	class KeyboardEventTestCase : public CppUnit::TestCase
	198	{
	199	public:
	200	KeyboardEventTestCase() {}
	201
	202	virtual void setUp();
	203	virtual void tearDown();
	204
	205	private:
	206	CPPUNIT_TEST_SUITE( KeyboardEventTestCase );
	207	CPPUNIT_TEST( NormalLetter );
	208	CPPUNIT_TEST( NormalSpecial );
	209	CPPUNIT_TEST( CtrlLetter );
	210	CPPUNIT_TEST( CtrlSpecial );
	211	CPPUNIT_TEST( ShiftLetter );
	212	CPPUNIT_TEST( ShiftSpecial );
	213	CPPUNIT_TEST_SUITE_END();
	214
	215	void NormalLetter();
	216	void NormalSpecial();
	217	void CtrlLetter();
	218	void CtrlSpecial();
	219	void ShiftLetter();
	220	void ShiftSpecial();
	221
	222	KeyboardTestWindow *m_win;
	223
	224	wxDECLARE_NO_COPY_CLASS(KeyboardEventTestCase);
	225	};
	226
	227	wxREGISTER_UNIT_TEST(KeyboardEvent);
	228
	229	void KeyboardEventTestCase::setUp()
	230	{
	231	m_win = new KeyboardTestWindow(wxTheApp->GetTopWindow());
	232	m_win->SetFocus();
	233	wxYield(); // needed to show the new window
	234
	235	// The window might get some key up events when it's being shown if the key
	236	// was pressed when the program was started and released after the window
	237	// was shown, e.g. this does happen in practice when launching the test
	238	// from command line. Simply discard all the spurious events so far.
	239	m_win->ClearEvents();
240	}
241
242	void KeyboardEventTestCase::tearDown()
243	{
244	m_win->Destroy();
245	}
246
247	void KeyboardEventTestCase::NormalLetter()
248	{
249	wxUIActionSimulator sim;
250	sim.Char('a');
251	wxYield();
252
253	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyDownCount() );
254	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(), 'A' );
255
256	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
257	ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(), 'a' );
258
259	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyUpCount() );
260	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(), 'A' );
261	}
262
263	void KeyboardEventTestCase::NormalSpecial()
264	{
265	wxUIActionSimulator sim;
266	sim.Char(WXK_END);
267	wxYield();
268
269	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyDownCount() );
270	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(), WXK_END );
271
272	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
273	ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(), WXK_END );
274
275	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyUpCount() );
276	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(), WXK_END );
277	}
278
279	void KeyboardEventTestCase::CtrlLetter()
280	{
281	wxUIActionSimulator sim;
282	sim.Char('z', wxMOD_CONTROL);
283	wxYield();
284
285	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
286	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
287	ModKeyDown(WXK_CONTROL) );
288	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
289	KeyDesc('Z', wxMOD_CONTROL) );
290
291	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
292	ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
293	KeyDesc('\x1a', wxMOD_CONTROL) );
294
295	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
296	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
297	KeyDesc('Z', wxMOD_CONTROL) );
298	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
299	ModKeyUp(WXK_CONTROL) );
300	}
301
302	void KeyboardEventTestCase::CtrlSpecial()
303	{
304	wxUIActionSimulator sim;
305	sim.Char(WXK_PAGEUP, wxMOD_CONTROL);
306	wxYield();
307
308	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
309	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
310	ModKeyDown(WXK_CONTROL) );
311	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
312	KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );
313
314	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
315	ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
316	KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );
317
318	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
319	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
320	KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );
321	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
322	ModKeyUp(WXK_CONTROL) );
323	}
324
325	void KeyboardEventTestCase::ShiftLetter()
326	{
327	wxUIActionSimulator sim;
328	sim.Char('Q', wxMOD_SHIFT);
329	wxYield();
330
331	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
332	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
333	ModKeyDown(WXK_SHIFT) );
334	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
335	KeyDesc('Q', wxMOD_SHIFT) );
336
337	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
338	ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
339	KeyDesc('Q', wxMOD_SHIFT) );
340
341	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
342	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
343	KeyDesc('Q', wxMOD_SHIFT) );
344	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
345	ModKeyUp(WXK_SHIFT) );
346	}
347
348	void KeyboardEventTestCase::ShiftSpecial()
349	{
350	wxUIActionSimulator sim;
073d9e0f	351	sim.Char(WXK_F3, wxMOD_SHIFT);
042ddf5d VZ	352	wxYield();
	353
	354	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
	355	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
	356	ModKeyDown(WXK_SHIFT) );
	357	ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
073d9e0f	358	KeyDesc(WXK_F3, wxMOD_SHIFT) );
042ddf5d VZ	359
	360	CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
	361	ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
073d9e0f	362	KeyDesc(WXK_F3, wxMOD_SHIFT) );
042ddf5d VZ	363
	364	CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
	365	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
073d9e0f	366	KeyDesc(WXK_F3, wxMOD_SHIFT) );
042ddf5d VZ	367	ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
	368	ModKeyUp(WXK_SHIFT) );
	369	}
	370
	371	#endif // wxUSE_UIACTIONSIMULATOR