3f66f6a5b3
This keyword is not expanded by Git which means it's not replaced with the correct revision value in the releases made using git-based scripts and it's confusing to have lines with unexpanded "$Id$" in the released files. As expanding them with Git is not that simple (it could be done with git archive and export-subst attribute) and there are not many benefits in having them in the first place, just remove all these lines. If nothing else, this will make an eventual transition to Git simpler. Closes #14487. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@74602 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
352 lines
9.6 KiB
C++
352 lines
9.6 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// 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_
|