pcsx2/3rdparty/wxwidgets3.0/include/wx/testing.h

352 lines
9.6 KiB
C
Raw Normal View History

/////////////////////////////////////////////////////////////////////////////
// Name: wx/testing.h
// Purpose: helpers for GUI testing
// Author: Vaclav Slavik
// Created: 2012-08-28
// Copyright: (c) 2012 Vaclav Slavik
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TESTING_H_
#define _WX_TESTING_H_
#include "wx/debug.h"
#include "wx/string.h"
#include "wx/modalhook.h"
class WXDLLIMPEXP_FWD_CORE wxMessageDialogBase;
class WXDLLIMPEXP_FWD_CORE wxFileDialogBase;
// ----------------------------------------------------------------------------
// testing API
// ----------------------------------------------------------------------------
// Don't include this code when building the library itself
#ifndef WXBUILDING
#include "wx/beforestd.h"
#include <algorithm>
#include <iterator>
#include <queue>
#include "wx/afterstd.h"
#include "wx/cpp.h"
#include "wx/dialog.h"
#include "wx/msgdlg.h"
#include "wx/filedlg.h"
class wxTestingModalHook;
// Non-template base class for wxExpectModal<T> (via wxExpectModalBase).
// Only used internally.
class wxModalExpectation
{
public:
wxModalExpectation() : m_isOptional(false) {}
virtual ~wxModalExpectation() {}
bool IsOptional() const { return m_isOptional; }
virtual int Invoke(wxDialog *dlg) const = 0;
virtual wxString GetDescription() const = 0;
protected:
// Is this dialog optional, i.e. not required to be shown?
bool m_isOptional;
};
// This must be specialized for each type. The specialization MUST be derived
// from wxExpectModalBase<T>.
template<class T> class wxExpectModal {};
/**
Base class for wxExpectModal<T> specializations.
Every such specialization must be derived from wxExpectModalBase; there's
no other use for this class than to serve as wxExpectModal<T>'s base class.
T must be a class derived from wxDialog.
*/
template<class T>
class wxExpectModalBase : public wxModalExpectation
{
public:
typedef T DialogType;
typedef wxExpectModal<DialogType> ExpectationType;
/**
Returns a copy of the expectation where the expected dialog is marked
as optional.
Optional dialogs aren't required to appear, it's not an error if they
don't.
*/
ExpectationType Optional() const
{
ExpectationType e(*static_cast<const ExpectationType*>(this));
e.m_isOptional = true;
return e;
}
protected:
virtual int Invoke(wxDialog *dlg) const
{
DialogType *t = dynamic_cast<DialogType*>(dlg);
if ( t )
return OnInvoked(t);
else
return wxID_NONE; // not handled
}
/// Returns description of the expected dialog (by default, its class).
virtual wxString GetDescription() const
{
return wxCLASSINFO(T)->GetClassName();
}
/**
This method is called when ShowModal() was invoked on a dialog of type T.
@return Return value is used as ShowModal()'s return value.
*/
virtual int OnInvoked(DialogType *dlg) const = 0;
};
// wxExpectModal<T> specializations for common dialogs:
template<>
class wxExpectModal<wxMessageDialog> : public wxExpectModalBase<wxMessageDialog>
{
public:
wxExpectModal(int id)
{
switch ( id )
{
case wxYES:
m_id = wxID_YES;
break;
case wxNO:
m_id = wxID_NO;
break;
case wxCANCEL:
m_id = wxID_CANCEL;
break;
case wxOK:
m_id = wxID_OK;
break;
case wxHELP:
m_id = wxID_HELP;
break;
default:
m_id = id;
break;
}
}
protected:
virtual int OnInvoked(wxMessageDialog *WXUNUSED(dlg)) const
{
return m_id;
}
int m_id;
};
#if wxUSE_FILEDLG
template<>
class wxExpectModal<wxFileDialog> : public wxExpectModalBase<wxFileDialog>
{
public:
wxExpectModal(const wxString& path, int id = wxID_OK)
: m_path(path), m_id(id)
{
}
protected:
virtual int OnInvoked(wxFileDialog *dlg) const
{
dlg->SetPath(m_path);
return m_id;
}
wxString m_path;
int m_id;
};
#endif
// Implementation of wxModalDialogHook for use in testing, with
// wxExpectModal<T> and the wxTEST_DIALOG() macro. It is not intended for
// direct use, use the macro instead.
class wxTestingModalHook : public wxModalDialogHook
{
public:
wxTestingModalHook()
{
Register();
}
// Called to verify that all expectations were met. This cannot be done in
// the destructor, because ReportFailure() may throw (either because it's
// overriden or because wx's assertions handling is, globally). And
// throwing from the destructor would introduce all sort of problems,
// including messing up the order of errors in some cases.
void CheckUnmetExpectations()
{
while ( !m_expectations.empty() )
{
const wxModalExpectation *expect = m_expectations.front();
m_expectations.pop();
if ( expect->IsOptional() )
continue;
ReportFailure
(
wxString::Format
(
"Expected %s dialog was not shown.",
expect->GetDescription()
)
);
break;
}
}
void AddExpectation(const wxModalExpectation& e)
{
m_expectations.push(&e);
}
protected:
virtual int Enter(wxDialog *dlg)
{
while ( !m_expectations.empty() )
{
const wxModalExpectation *expect = m_expectations.front();
m_expectations.pop();
int ret = expect->Invoke(dlg);
if ( ret != wxID_NONE )
return ret; // dialog shown as expected
// not showing an optional dialog is OK, but showing an unexpected
// one definitely isn't:
if ( !expect->IsOptional() )
{
ReportFailure
(
wxString::Format
(
"A %s dialog was shown unexpectedly, expected %s.",
dlg->GetClassInfo()->GetClassName(),
expect->GetDescription()
)
);
return wxID_NONE;
}
// else: try the next expectation in the chain
}
ReportFailure
(
wxString::Format
(
"A dialog (%s) was shown unexpectedly.",
dlg->GetClassInfo()->GetClassName()
)
);
return wxID_NONE;
}
protected:
virtual void ReportFailure(const wxString& msg)
{
wxFAIL_MSG( msg );
}
private:
std::queue<const wxModalExpectation*> m_expectations;
wxDECLARE_NO_COPY_CLASS(wxTestingModalHook);
};
// Redefining this value makes it possible to customize the hook class,
// including e.g. its error reporting.
#define wxTEST_DIALOG_HOOK_CLASS wxTestingModalHook
#define WX_TEST_IMPL_ADD_EXPECTATION(pos, expect) \
const wxModalExpectation& wx_exp##pos = expect; \
wx_hook.AddExpectation(wx_exp##pos);
/**
Runs given code with all modal dialogs redirected to wxExpectModal<T>
hooks, instead of being shown to the user.
The first argument is any valid expression, typically a function call. The
remaining arguments are wxExpectModal<T> instances defining the dialogs
that are expected to be shown, in order of appearance.
Some typical examples:
@code
wxTEST_DIALOG
(
rc = dlg.ShowModal(),
wxExpectModal<wxFileDialog>(wxGetCwd() + "/test.txt")
);
@endcode
Sometimes, the code may show more than one dialog:
@code
wxTEST_DIALOG
(
RunSomeFunction(),
wxExpectModal<wxMessageDialog>(wxNO),
wxExpectModal<MyConfirmationDialog>(wxYES),
wxExpectModal<wxFileDialog>(wxGetCwd() + "/test.txt")
);
@endcode
Notice that wxExpectModal<T> has some convenience methods for further
tweaking the expectations. For example, it's possible to mark an expected
dialog as @em optional for situations when a dialog may be shown, but isn't
required to, by calling the Optional() method:
@code
wxTEST_DIALOG
(
RunSomeFunction(),
wxExpectModal<wxMessageDialog>(wxNO),
wxExpectModal<wxFileDialog>(wxGetCwd() + "/test.txt").Optional()
);
@endcode
@note By default, errors are reported with wxFAIL_MSG(). You may customize this by
implementing a class derived from wxTestingModalHook, overriding its
ReportFailure() method and redefining the wxTEST_DIALOG_HOOK_CLASS
macro to be the name of this class.
@note Custom dialogs are supported too. All you have to do is to specialize
wxExpectModal<> for your dialog type and implement its OnInvoked()
method.
*/
#ifdef HAVE_VARIADIC_MACROS
#define wxTEST_DIALOG(codeToRun, ...) \
{ \
wxTEST_DIALOG_HOOK_CLASS wx_hook; \
wxCALL_FOR_EACH(WX_TEST_IMPL_ADD_EXPECTATION, __VA_ARGS__) \
codeToRun; \
wx_hook.CheckUnmetExpectations(); \
}
#endif /* HAVE_VARIADIC_MACROS */
#endif // !WXBUILDING
#endif // _WX_TESTING_H_