This repository has been archived on 2024-12-16. You can view files and clone it, but cannot push or open issues or pull requests.
CodeBlocksPortable/wxWidgets-3.0.5/tests/streams/textstreamtest.cpp

291 lines
7.5 KiB
C++
Raw Normal View History

///////////////////////////////////////////////////////////////////////////////
// Name: tests/streams/textstreamtest.cpp
// Purpose: wxTextXXXStream unit test
// Author: Ryan Norton, Vince Harron
// Created: 2004-08-14
// Copyright: (c) 2004 Ryan Norton, (c) 2006 Vince Harron
///////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "testprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif // WX_PRECOMP
#include "wx/txtstrm.h"
#include "wx/wfstream.h"
#if wxUSE_LONGLONG
#include "wx/longlong.h"
#endif
#if wxUSE_UNICODE
#include "wx/mstream.h"
#endif // wxUSE_UNICODE
// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------
class TextStreamTestCase : public CppUnit::TestCase
{
public:
TextStreamTestCase();
private:
CPPUNIT_TEST_SUITE( TextStreamTestCase );
CPPUNIT_TEST( Endline );
CPPUNIT_TEST( MiscTests );
#if wxUSE_LONGLONG
CPPUNIT_TEST( TestLongLong );
CPPUNIT_TEST( TestLongLong );
#endif // wxUSE_LONGLONG
#if wxUSE_UNICODE
CPPUNIT_TEST( TestUTF8Input );
CPPUNIT_TEST( TestEmbeddedZerosUTF16LEInput );
CPPUNIT_TEST( TestEmbeddedZerosUTF16BEInput );
CPPUNIT_TEST( TestEmbeddedZerosUTF32LEInput );
CPPUNIT_TEST( TestEmbeddedZerosUTF32BEInput );
#endif // wxUSE_UNICODE
CPPUNIT_TEST_SUITE_END();
void Endline();
void MiscTests();
#if wxUSE_LONGLONG
void TestLongLong();
void TestULongLong();
#endif // wxUSE_LONGLONG
#if wxUSE_UNICODE
void TestUTF8Input();
void TestEmbeddedZerosUTF16LEInput();
void TestEmbeddedZerosUTF16BEInput();
void TestEmbeddedZerosUTF32LEInput();
void TestEmbeddedZerosUTF32BEInput();
void TestInput(const wxMBConv& conv,
const void* encodedText,
size_t encodedSize );
#endif // wxUSE_UNICODE
DECLARE_NO_COPY_CLASS(TextStreamTestCase)
};
// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( TextStreamTestCase );
// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TextStreamTestCase, "TextStreamTestCase" );
TextStreamTestCase::TextStreamTestCase()
{
}
#if defined(__WINDOWS__) || defined(__WXPM__)
# define NEWLINE "\r\n"
# define NEWLINELEN 2
#elif defined(__WXMAC__) && !defined(__DARWIN__)
# define NEWLINE "\r"
# define NEWLINELEN 1
#else
# define NEWLINE "\n"
# define NEWLINELEN 1
#endif
void TextStreamTestCase::Endline()
{
wxFileOutputStream* pOutFile = new wxFileOutputStream(wxT("test.txt"));
wxTextOutputStream* pOutText = new wxTextOutputStream(*pOutFile);
*pOutText << wxT("Test text") << endl
<< wxT("More Testing Text (There should be newline before this)");
delete pOutText;
delete pOutFile;
wxFileInputStream* pInFile = new wxFileInputStream(wxT("test.txt"));
char szIn[9 + NEWLINELEN];
pInFile->Read(szIn, 9 + NEWLINELEN);
CPPUNIT_ASSERT( memcmp(&szIn[9], NEWLINE, NEWLINELEN) == 0 );
delete pInFile;
}
void TextStreamTestCase::MiscTests()
{
wxString filename = wxT("testdata.fc");
wxFileInputStream fsIn(filename);
if ( !fsIn.IsOk() )
{
return;
}
wxTextInputStream tis(fsIn);
CPPUNIT_ASSERT_EQUAL("# this is the test data file for wxFileConfig tests", tis.ReadLine());
CPPUNIT_ASSERT_EQUAL("value1=one", tis.ReadLine());
CPPUNIT_ASSERT_EQUAL("# a comment here", tis.ReadLine());
CPPUNIT_ASSERT_EQUAL("value2=two", tis.ReadLine());
CPPUNIT_ASSERT_EQUAL("value\\ with\\ spaces\\ inside\\ it=nothing special", tis.ReadLine());
CPPUNIT_ASSERT_EQUAL("path=$PATH", tis.ReadLine());
}
#if wxUSE_LONGLONG
template <typename T>
static void DoTestRoundTrip(const T *values, size_t numValues)
{
{
wxFileOutputStream fileOut(wxT("test.txt"));
wxTextOutputStream textOut(fileOut);
for ( size_t n = 0; n < numValues; n++ )
{
textOut << values[n] << endl;
}
}
{
wxFileInputStream fileIn(wxT("test.txt"));
wxTextInputStream textIn(fileIn);
T value;
for ( size_t n = 0; n < numValues; n++ )
{
textIn >> value;
CPPUNIT_ASSERT( value == values[n] );
}
}
}
void TextStreamTestCase::TestLongLong()
{
static const wxLongLong llvalues[] =
{
0,
1,
-1,
0x12345678l,
-0x12345678l,
wxLL(0x123456789abcdef0),
wxLL(-0x123456789abcdef0),
};
DoTestRoundTrip(llvalues, WXSIZEOF(llvalues));
}
void TextStreamTestCase::TestULongLong()
{
static const wxULongLong ullvalues[] =
{
0,
1,
0x12345678l,
wxULL(0x123456789abcdef0),
};
DoTestRoundTrip(ullvalues, WXSIZEOF(ullvalues));
}
#endif // wxUSE_LONGLONG
#if wxUSE_UNICODE
static const wchar_t txtWchar[4] =
{
0x0041, // LATIN CAPITAL LETTER A
0x0100, // A WITH BREVE, LATIN SMALL LETTER
0x0041, // LATIN CAPITAL LETTER A
0x0100, // A WITH BREVE, LATIN SMALL LETTER
};
static const unsigned char txtUtf8[6] =
{
0x41, 0xc4, 0x80, 0x41, 0xc4, 0x80,
};
static const unsigned char txtUtf16le[8] =
{
0x41, 0x00, 0x00, 0x01, 0x41, 0x00, 0x00, 0x01,
};
static const unsigned char txtUtf16be[8] =
{
0x00, 0x41, 0x01, 0x00, 0x00, 0x41, 0x01, 0x00,
};
static const unsigned char txtUtf32le[16] =
{
0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
};
static const unsigned char txtUtf32be[16] =
{
0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x01, 0x00,
0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x01, 0x00,
};
void TextStreamTestCase::TestUTF8Input()
{
TestInput(wxConvUTF8, txtUtf8, sizeof(txtUtf8));
TestInput(wxCSConv(wxFONTENCODING_UTF8), txtUtf8, sizeof(txtUtf8));
}
void TextStreamTestCase::TestEmbeddedZerosUTF16LEInput()
{
TestInput(wxMBConvUTF16LE(), txtUtf16le, sizeof(txtUtf16le));
TestInput(wxCSConv(wxFONTENCODING_UTF16LE), txtUtf16le, sizeof(txtUtf16le));
}
void TextStreamTestCase::TestEmbeddedZerosUTF16BEInput()
{
TestInput(wxMBConvUTF16BE(), txtUtf16be, sizeof(txtUtf16be));
TestInput(wxCSConv(wxFONTENCODING_UTF16BE), txtUtf16be, sizeof(txtUtf16be));
}
void TextStreamTestCase::TestEmbeddedZerosUTF32LEInput()
{
TestInput(wxMBConvUTF32LE(), txtUtf32le, sizeof(txtUtf32le));
TestInput(wxCSConv(wxFONTENCODING_UTF32LE), txtUtf32le, sizeof(txtUtf32le));
}
void TextStreamTestCase::TestEmbeddedZerosUTF32BEInput()
{
TestInput(wxMBConvUTF32BE(), txtUtf32be, sizeof(txtUtf32be));
TestInput(wxCSConv(wxFONTENCODING_UTF32BE), txtUtf32be, sizeof(txtUtf32be));
}
void TextStreamTestCase::TestInput(const wxMBConv& conv,
const void *encodedText,
size_t encodedSize)
{
wxMemoryInputStream byteIn(encodedText, encodedSize);
wxTextInputStream textIn(byteIn, wxT("\n"), conv);
wxString temp;
while ( wxChar c = textIn.GetChar() )
{
temp.Append(c);
}
CPPUNIT_ASSERT_EQUAL( WXSIZEOF(txtWchar), temp.length() );
CPPUNIT_ASSERT_EQUAL( 0, memcmp(txtWchar, temp.wc_str(), sizeof(txtWchar)) );
}
#endif // wxUSE_UNICODE