extern wxString wxConvertFormat(const wxChar *format);
#endif
-using namespace std;
-using namespace CppUnit;
-
+using CppUnit::TestCase;
+using std::string;
///////////////////////////////////////////////////////////////////////////////
// The test case
//
// To run all the regex tests:
// test regex
-//
+//
// Some tests must be skipped since they use features which we do not make
// available through wxRegEx. To see the list of tests that have been skipped
// turn on verbose logging, e.g.:
// test --verbose regex
-//
+//
// The tests here are for the builtin library, tests for wxRegEx in general
// should go in wxregex.cpp
//
// The tests are generated from Henry Spencer's reg.test, additional test
// can be added in wxreg.test. These test files are then turned into a C++
// include file 'regex.inc' (included below) using a script 'regex.pl'.
-//
+//
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#include "wx/regex.h"
#include "wx/cppunit.h"
-#include <stdexcept>
+#include <string>
+#include <vector>
-using namespace std;
-using namespace CppUnit;
+using CppUnit::Test;
+using CppUnit::TestCase;
+using CppUnit::TestSuite;
+using CppUnit::Exception;
+
+using std::vector;
+using std::string;
// many of the tests are specific to the builtin regex lib, so only attempts
// to do them when using the builtin regex lib.
}
failIf(badconv, _T("cannot convert to default character encoding"));
-
+
// the flags need further parsing...
parseFlags(m_flags);
{
size_t nLen1 = wxWcslen(s1);
size_t nLen2 = wxWcslen(s2);
-
+
if (nLen1 != nLen2)
return nLen1 - nLen2;
-
+
return wxMemcmp(s1, s2, nLen1);
}
doTest(wxRE_ADVANCED);
#endif
}
-
+
// Try the test for a single flavour of expression
//
void RegExTestCase::doTest(int flavor)
for (it = m_expected.begin(); it != m_expected.end(); ++it)
str << _T(" ") << quote(*it);
-
+
if (str.length() > 77)
str = str.substr(0, 74) + _T("...");
for (size_t i = 0; i < arg.length(); i++) {
wxUChar ch = arg[i];
const wxChar *p = wxStrchr(needEscape, ch);
-
+
if (p)
str += wxString::Format(_T("\\%c"), escapes[p - needEscape]);
else if (wxIscntrl(ch))
expected_results.push_back(expected);
va_end(ap);
-
+
try {
addTest(new RegExTestCase(
name, mode, id, flags, pattern, data, expected_results));
#include "wx/tokenzr.h"
#include <string>
-using namespace std;
-using namespace CppUnit;
+using CppUnit::Test;
+using CppUnit::TestCase;
+using CppUnit::TestSuite;
+using std::string;
///////////////////////////////////////////////////////////////////////////////
m_expected(expected),
m_count(count),
m_flags(flags)
- { }
+ { }
protected:
void runTest();
#include "wx/cppunit.h"
#include "bstream.h"
-using namespace CppUnit;
+using CppUnit::TestSuite;
+using CppUnit::Test;
///////////////////////////////////////////////////////////////////////////////
// Streams main test suite, it houses all stream test suites.
class StreamCase : public TestSuite
{
public:
- StreamCase()
- :TestSuite(STREAM_TEST_NAME)
+ StreamCase()
+ :TestSuite(STREAM_TEST_NAME)
{ /* Nothing extra */ }
static Test *suite();
};
/*
* Register all sub stream test suites.
*/
-
+
STREAM_REGISTER_SUB_SUITE(memStream);
STREAM_REGISTER_SUB_SUITE(strStream);
STREAM_REGISTER_SUB_SUITE(fileStream);
STREAM_REGISTER_SUB_SUITE(ffileStream);
STREAM_REGISTER_SUB_SUITE(zlibStream);
- /*
+ /*
** Add more stream subtests here
*/
#define _WX_TESTBSTREAM_H__
#include "wx/cppunit.h"
-using namespace CppUnit;
///////////////////////////////////////////////////////////////////////////////
// Some macros preventing us from typing too much ;-)
#define COMPOSE_TEST_NAME(Name) \
STREAM_TEST_NAME "." #Name
#define STREAM_REGISTER_SUB_SUITE(Name) \
- extern Test* Get##Name##Suite(); \
+ extern CppUnit::Test* Get##Name##Suite(); \
suite->addTest(Get##Name##Suite())
#define STREAM_IMPLEMENT_SUB_REGISTRATION_ROUTINE(Name) \
- Test* Get##Name##Suite() { return Name::suite(); }
+ CppUnit::Test* Get##Name##Suite() { return Name::suite(); }
#define STREAM_TEST_SUBSUITE_NAMED_REGISTRATION(Name) \
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( Name, COMPOSE_TEST_NAME(Name) ); \
STREAM_IMPLEMENT_SUB_REGISTRATION_ROUTINE( Name )
// Template class that implements a test for all base stream functions.
//
-template <class TStreamIn, class TStreamOut> class BaseStreamTestCase : public TestCase
+template <class TStreamIn, class TStreamOut> class BaseStreamTestCase : public CppUnit::TestCase
{
protected:
typedef BaseStreamTestCase<TStreamIn, TStreamOut> StreamTestCase;
#include "bstream.h"
-using namespace std;
-using namespace CppUnit;
-
#define DATABUFFER_SIZE 1024
static const wxString FILENAME_FFILEINSTREAM = _T("ffileinstream.test");
private:
// Implement base class functions.
- virtual wxFFileInputStream *DoCreateInStream();
+ virtual wxFFileInputStream *DoCreateInStream();
virtual wxFFileOutputStream *DoCreateOutStream();
virtual void DoDeleteOutStream();
::wxRemoveFile(FILENAME_FFILEOUTSTREAM);
}
-wxFFileInputStream *ffileStream::DoCreateInStream()
-{
+wxFFileInputStream *ffileStream::DoCreateInStream()
+{
wxFFileInputStream *pFileInStream = new wxFFileInputStream(GetInFileName());
CPPUNIT_ASSERT(pFileInStream->IsOk());
return pFileInStream;
}
wxFFileOutputStream *ffileStream::DoCreateOutStream()
-{
+{
wxFFileOutputStream *pFileOutStream = new wxFFileOutputStream(FILENAME_FFILEOUTSTREAM);
CPPUNIT_ASSERT(pFileOutStream->IsOk());
return pFileOutStream;
// Make sure we have a input file...
char buf[DATABUFFER_SIZE];
wxFFileOutputStream out(FILENAME_FFILEINSTREAM);
-
+
// Init the data buffer.
for (size_t i = 0; i < DATABUFFER_SIZE; i++)
buf[i] = (i % 0xFF);
#include "bstream.h"
-using namespace std;
-using namespace CppUnit;
-
#define DATABUFFER_SIZE 1024
static const wxString FILENAME_FILEINSTREAM = _T("fileinstream.test");
private:
// Implement base class functions.
- virtual wxFileInputStream *DoCreateInStream();
+ virtual wxFileInputStream *DoCreateInStream();
virtual wxFileOutputStream *DoCreateOutStream();
virtual void DoDeleteOutStream();
::wxRemoveFile(FILENAME_FILEOUTSTREAM);
}
-wxFileInputStream *fileStream::DoCreateInStream()
-{
+wxFileInputStream *fileStream::DoCreateInStream()
+{
wxFileInputStream *pFileInStream = new wxFileInputStream(GetInFileName());
CPPUNIT_ASSERT(pFileInStream->IsOk());
return pFileInStream;
}
wxFileOutputStream *fileStream::DoCreateOutStream()
-{
+{
wxFileOutputStream *pFileOutStream = new wxFileOutputStream(FILENAME_FILEOUTSTREAM);
CPPUNIT_ASSERT(pFileOutStream->IsOk());
return pFileOutStream;
// Make sure we have a input file...
char buf[DATABUFFER_SIZE];
wxFileOutputStream out(FILENAME_FILEINSTREAM);
-
+
// Init the data buffer.
for (size_t i = 0; i < DATABUFFER_SIZE; i++)
buf[i] = (i % 0xFF);
#include "bstream.h"
-using namespace std;
-using namespace CppUnit;
-
#define DATABUFFER_SIZE 256
///////////////////////////////////////////////////////////////////////////////
private:
// Implement base class functions.
- virtual wxMemoryInputStream *DoCreateInStream();
+ virtual wxMemoryInputStream *DoCreateInStream();
virtual wxMemoryOutputStream *DoCreateOutStream();
private:
return m_DataBuffer;
}
-wxMemoryInputStream *memStream::DoCreateInStream()
-{
+wxMemoryInputStream *memStream::DoCreateInStream()
+{
wxMemoryInputStream *pMemInStream = new wxMemoryInputStream(GetDataBuffer(), DATABUFFER_SIZE);
CPPUNIT_ASSERT(pMemInStream->IsOk());
return pMemInStream;
}
wxMemoryOutputStream *memStream::DoCreateOutStream()
-{
+{
wxMemoryOutputStream *pMemOutStream = new wxMemoryOutputStream();
CPPUNIT_ASSERT(pMemOutStream->IsOk());
return pMemOutStream;
#include "bstream.h"
-using namespace std;
-using namespace CppUnit;
-
///////////////////////////////////////////////////////////////////////////////
// The test case
//
private:
// Implement base class functions.
- virtual wxStringInputStream *DoCreateInStream();
+ virtual wxStringInputStream *DoCreateInStream();
virtual wxStringOutputStream *DoCreateOutStream();
wxString m_str;
{
}
-wxStringInputStream *strStream::DoCreateInStream()
-{
+wxStringInputStream *strStream::DoCreateInStream()
+{
wxStringInputStream *pStrInStream = new wxStringInputStream(m_str);
CPPUNIT_ASSERT(pStrInStream->IsOk());
return pStrInStream;
}
wxStringOutputStream *strStream::DoCreateOutStream()
-{
+{
wxStringOutputStream *pStrOutStream = new wxStringOutputStream();
CPPUNIT_ASSERT(pStrOutStream->IsOk());
return pStrOutStream;
#include "bstream.h"
-using namespace std;
-using namespace CppUnit;
+using std::string;
#define WXTEST_WITH_GZIP_CONDITION(testMethod) \
WXTEST_WITH_CONDITION( COMPOSE_TEST_NAME(zlibStream), wxZlibInputStream::CanHandleGZip() && wxZlibOutputStream::CanHandleGZip(), testMethod )
void TestStream_ZLibGZip();
// Try to decompress bad data.
void Decompress_BadData();
- // Decompress data that was compress by an external app.
+ // Decompress data that was compress by an external app.
// (like test wx 2.4.2, 2.5.1 and gzip data)
// Note: This test is limited in testing range!
#if WXWIN_COMPATIBILITY_2_4
#endif
void Decompress_wx251_zlib114_Data_NoHeader();
void Decompress_wx251_zlib114_Data_ZLib();
- void Decompress_gzip135Data();
+ void Decompress_gzip135Data();
-private:
+private:
const char *GetDataBuffer();
const unsigned char *GetCompressedData();
void doTestStreamData(int input_flag, int output_flag, int compress_level);
private:
// Implement base class functions.
- virtual wxZlibInputStream *DoCreateInStream();
+ virtual wxZlibInputStream *DoCreateInStream();
virtual wxZlibOutputStream *DoCreateOutStream();
virtual void DoDeleteInStream();
virtual void DoDeleteOutStream();
- // Helper that can be used to create new wx compatibility tests...
+ // Helper that can be used to create new wx compatibility tests...
// Otherwise not used by the tests.
void genExtTestData(wxTextOutputStream &out, const char *buf, int flag);
void zlibStream::TestStream_ZLibGZip()
{
- // Only use default compression level, as this test is
+ // Only use default compression level, as this test is
// for testing if the streams can determine the stream type info them self...
doTestStreamData(wxZLIB_AUTO, wxZLIB_ZLIB, wxZ_DEFAULT_COMPRESSION);
doTestStreamData(wxZLIB_AUTO, wxZLIB_GZIP, wxZ_DEFAULT_COMPRESSION);
wxMemoryInputStream memstream_in(GetDataBuffer(), DATABUFFER_SIZE);
CPPUNIT_ASSERT(memstream_in.IsOk());
wxZlibInputStream zstream_in(memstream_in);
- CPPUNIT_ASSERT(zstream_in.IsOk()); // We did not yet read from the stream
+ CPPUNIT_ASSERT(zstream_in.IsOk()); // We did not yet read from the stream
// so it should still be OK.
// Try to force the stream to go to bad status.
CPPUNIT_ASSERT(!zstream_in.Eof());
#if WXWIN_COMPATIBILITY_2_4
void zlibStream::Decompress_wx24Data()
{
- // The wx24_value was used in a wxWidgets 2.4(.2)
+ // The wx24_value was used in a wxWidgets 2.4(.2)
// application to produce wx24_data, using wxZlibOutputStream.
const unsigned char wx24_data[] = {120,156,242,72,205,201,201,87,40,207,47,202,73,97,0,0,0,0,255,255,0};
const char *wx24_value = "Hello world";
zstream_out.Write(buf, strlen(buf));
}
- // Copy the to the
+ // Copy the to the
m_SizeCompressedData = memstream_out.GetSize();
m_pCompressedData = new unsigned char[m_SizeCompressedData];
memstream_out.CopyTo(m_pCompressedData, m_SizeCompressedData);
}
- CPPUNIT_ASSERT(m_pCompressedData != NULL);
+ CPPUNIT_ASSERT(m_pCompressedData != NULL);
return m_pCompressedData;
}
fstream_out.PutC(' ');
}
- { // Part two: Verify that the compressed data when uncompressed
+ { // Part two: Verify that the compressed data when uncompressed
// matches the original data.
wxFileInputStream fstream_in(FILENAME_GZ);
CPPUNIT_ASSERT(fstream_in.IsOk());
for (fail_pos = 0; !zstream_in.Eof(); fail_pos++)
{
last_value = zstream_in.GetC();
- if (zstream_in.LastRead() != 1 ||
+ if (zstream_in.LastRead() != 1 ||
last_value != pbuf[fail_pos])
break;
}
// Check state of the verify action.
if (fail_pos != DATABUFFER_SIZE || !bWasEOF)
{
- wxString msg(wxString::Format(_T("Wrong data item at pos %d (Org_val %d != Zlib_val %d), with compression level %d"),
+ wxString msg(wxString::Format(_T("Wrong data item at pos %d (Org_val %d != Zlib_val %d), with compression level %d"),
fail_pos, GetDataBuffer()[fail_pos], last_value, compress_level));
CPPUNIT_FAIL(string(msg.mb_str()));
}
wxLogError(_T("gzip data seems to not be gzip data!"));
break;
case wxZLIB_AUTO:
- if (!(data_size >= 1 && data[0] == 0x78) ||
+ if (!(data_size >= 1 && data[0] == 0x78) ||
!(data_size >= 2 && data[0] == 0x1F && data[1] == 0x8B))
wxLogError(_T("Data seems to not be zlib or gzip data!"));
default:
// Move one item along in the stream.
(void)zstream_in.GetC();
i++;
-
+
// Check if we are in an infinite loop by multiplying value_size
// by 5 to have a *much* bigger range then the real range.
- // Note: Incase you ask your self, why 5, the answer is no reason...
- // it is not to big and not to small a size, nothing more
+ // Note: Incase you ask your self, why 5, the answer is no reason...
+ // it is not to big and not to small a size, nothing more
// nothing less to it.
- if (i > (value_size*5))
+ if (i > (value_size*5))
{
// Note: Please make sure Input_Eof test passed.
CPPUNIT_FAIL("Infinite stream detected, breaking the infinite loop");
}
}
- CPPUNIT_ASSERT_MESSAGE("Could not decompress the compressed data, original and restored value did not match.",
+ CPPUNIT_ASSERT_MESSAGE("Could not decompress the compressed data, original and restored value did not match.",
i == value_size && bValueEq);
}
-wxZlibInputStream *zlibStream::DoCreateInStream()
-{
+wxZlibInputStream *zlibStream::DoCreateInStream()
+{
const unsigned char *buf = GetCompressedData();
m_pTmpMemInStream = new wxMemoryInputStream(buf, m_SizeCompressedData);
CPPUNIT_ASSERT(m_pTmpMemInStream->IsOk());
return pzstream_in;
}
wxZlibOutputStream *zlibStream::DoCreateOutStream()
-{
+{
m_pTmpMemOutStream = new wxMemoryOutputStream();
CPPUNIT_ASSERT(m_pTmpMemOutStream->IsOk());
wxZlibOutputStream *pzstream_out = new wxZlibOutputStream(*m_pTmpMemOutStream);
CPPUNIT_ASSERT(pzstream_out->IsOk());
return pzstream_out;
}
-void zlibStream::DoDeleteInStream()
-{
+void zlibStream::DoDeleteInStream()
+{
delete m_pTmpMemInStream;
m_pTmpMemInStream = NULL;
}
-void zlibStream::DoDeleteOutStream()
-{
+void zlibStream::DoDeleteOutStream()
+{
delete m_pTmpMemOutStream;
m_pTmpMemOutStream = NULL;
}
{
unsigned char *data;
size_t size;
-
+
{ // Gen data
wxMemoryOutputStream memstream_out;
{
}
if (flag == wxZLIB_NO_HEADER)
memstream_out.PutC(' ');
-
+
size = memstream_out.GetSize();
data = new unsigned char[size];
memstream_out.CopyTo(data, size);
out << _T("void zlibStream::Decompress_wxXXXData()") << _T("\n");
out << _T("{") << _T("\n") << _T(" const unsigned char data[] = {");
-
+
size_t i;
for (i = 0; i < size; i++)
{
out << wxString::Format(_T("%d,"), data[i]);
else
out << wxString::Format(_T("%d"), data[i]);
- }
+ }
delete [] data;
out << _T("};") << _T("\n");
#include "wx/cppunit.h"
#include <iostream>
-using namespace std;
-using namespace CppUnit;
+using CppUnit::Test;
+using CppUnit::TestSuite;
+using CppUnit::TestFactoryRegistry;
+using CppUnit::TextUi::TestRunner;
+
+using std::string;
+using std::vector;
+using std::auto_ptr;
+using std::cout;
// The application class
//
bool TestApp::OnInit()
{
cout << "Test program for wxWidgets\n"
- << "build: " << WX_BUILD_OPTIONS_SIGNATURE << endl;
+ << "build: " << WX_BUILD_OPTIONS_SIGNATURE << std::endl;
return wxAppConsole::OnInit();
};
m_registries.push_back(string(parser.GetParam(i).mb_str()));
else
m_registries.push_back("");
-
+
m_longlist = parser.Found(_T("longlist"));
m_list = m_longlist || parser.Found(_T("list"));
//
int TestApp::OnRun()
{
- TextUi::TestRunner runner;
+ TestRunner runner;
for (size_t i = 0; i < m_registries.size(); i++) {
auto_ptr<Test> test(m_registries[i].empty() ?
#if wxUSE_LOG
// Switch off logging unless --verbose
- wxLog::EnableLogging(wxLog::GetVerbose());
-#endif // wxUSE_LOG
-
- return m_list || runner.run("", false, true,
-#if wxUSE_LOG
- !wxLog::GetVerbose()
+ bool verbose = wxLog::GetVerbose();
+ wxLog::EnableLogging(verbose);
#else
- true
-#endif // wxUSE_LOG
- ) ? EXIT_SUCCESS : EXIT_FAILURE;
+ bool verbose = false;
+#endif
+
+ return ( m_list || runner.run("", false, true, !verbose) )
+ ? EXIT_SUCCESS
+ : EXIT_FAILURE;
}
// List the tests
projects / wxWidgets.git / commitdiff
