[wxWidgets.git] / tests / streams / stdstream.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/streams/stdstream.cpp
// Purpose:     Test wxStdInputStreamBuffer/wxStdOutputStreamBuffer
// Author:      Jonathan Liu <net147@gmail.com>
// RCS-ID:      $Id$
// Copyright:   (c) 2009 Jonathan Liu
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
// and "wx/cppunit.h"
#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#if wxUSE_STD_IOSTREAM

#include "wx/stdstream.h"

#include <string.h>
#include "wx/mstream.h"

// ==========================================================================
// Definitions
// ==========================================================================

const int TEST_SIZE = 384;

// ==========================================================================
// Test class
// ==========================================================================

class StdStreamTestCase : public CppUnit::TestCase
{
public:
    StdStreamTestCase();

private:
    CPPUNIT_TEST_SUITE( StdStreamTestCase );
        // Input buffer management and positioning
        CPPUNIT_TEST( InputBuffer_pubsetbuf );
        CPPUNIT_TEST( InputBuffer_pubseekoff );
        CPPUNIT_TEST( InputBuffer_pubseekpos );
        CPPUNIT_TEST( InputBuffer_pubsync );

        // Input functions
        CPPUNIT_TEST( InputBuffer_in_avail );
        CPPUNIT_TEST( InputBuffer_snextc );
        CPPUNIT_TEST( InputBuffer_sbumpc );
        CPPUNIT_TEST( InputBuffer_sgetc );
        CPPUNIT_TEST( InputBuffer_sgetn );
        CPPUNIT_TEST( InputBuffer_sputbackc );
        CPPUNIT_TEST( InputBuffer_sungetc );

        // Output buffer management and positioning
        CPPUNIT_TEST( OutputBuffer_pubsetbuf );
        CPPUNIT_TEST( OutputBuffer_pubseekoff );
        CPPUNIT_TEST( OutputBuffer_pubseekpos );
        CPPUNIT_TEST( OutputBuffer_pubsync );

        // Output functions
        CPPUNIT_TEST( OutputBuffer_sputc );
        CPPUNIT_TEST( OutputBuffer_sputn );
    CPPUNIT_TEST_SUITE_END();

    // Input buffer management and positioning
    void InputBuffer_pubsetbuf();
    void InputBuffer_pubseekoff();
    void InputBuffer_pubseekpos();
    void InputBuffer_pubsync();

    // Input functions
    void InputBuffer_in_avail();
    void InputBuffer_snextc();
    void InputBuffer_sbumpc();
    void InputBuffer_sgetc();
    void InputBuffer_sgetn();
    void InputBuffer_sputbackc();
    void InputBuffer_sungetc();

    // Output buffer management and positioning
    void OutputBuffer_pubsetbuf();
    void OutputBuffer_pubseekoff();
    void OutputBuffer_pubseekpos();
    void OutputBuffer_pubsync();

    // Output functions
    void OutputBuffer_sputc();
    void OutputBuffer_sputn();

    char m_testData[TEST_SIZE];

    DECLARE_NO_COPY_CLASS(StdStreamTestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( StdStreamTestCase );

// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( StdStreamTestCase,
                                       "StdStreamTestCase" );

// ==========================================================================
// Implementation
// ==========================================================================

StdStreamTestCase::StdStreamTestCase()
{
    for (int i = 0; i < TEST_SIZE; ++i)
        m_testData[i] = (i & 0xFF);
}

// --------------------------------------------------------------------------
// Input buffer management and positioning
// --------------------------------------------------------------------------

void StdStreamTestCase::InputBuffer_pubsetbuf()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);
    char testBuffer[TEST_SIZE];

    CPPUNIT_ASSERT(buffer.pubsetbuf(testBuffer, TEST_SIZE) == NULL);
}

void StdStreamTestCase::InputBuffer_pubseekoff()
{
    const char *testData = "0123456789";
    wxMemoryInputStream stream(testData, 10);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT_EQUAL(2,
                         buffer.pubseekoff(2, std::ios_base::beg,
                                           std::ios_base::in));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(2, std::ios_base::beg,
                                           std::ios_base::out));

    CPPUNIT_ASSERT_EQUAL(4,
                         buffer.pubseekoff(2, std::ios_base::cur));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(2, std::ios_base::cur,
                                           std::ios_base::out));

    CPPUNIT_ASSERT_EQUAL(8,
                         buffer.pubseekoff(-2, std::ios_base::end));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(-2, std::ios_base::end,
                                           std::ios_base::out));

    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(3, std::ios_base::cur));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(3, std::ios_base::cur,
                                           std::ios_base::out));
}

void StdStreamTestCase::InputBuffer_pubseekpos()
{
    const char *testData = "0123456789";
    wxMemoryInputStream stream(testData, 10);
    wxStdInputStreamBuffer buffer(stream);

    for (int i = 9; i >= 0; --i)
    {
        if (i % 2 == 0)
            CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i));
        else
            CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i, std::ios_base::in));

        CPPUNIT_ASSERT_EQUAL('0' + i, buffer.sgetc());
    }
}

void StdStreamTestCase::InputBuffer_pubsync()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.pubsync() == 0);
}

// --------------------------------------------------------------------------
// Input functions
// --------------------------------------------------------------------------

void StdStreamTestCase::InputBuffer_in_avail()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.sgetc() != EOF);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());

    char data[TEST_SIZE / 2];

    buffer.sgetn(data, TEST_SIZE / 2);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE - TEST_SIZE / 2, buffer.in_avail());
}

void StdStreamTestCase::InputBuffer_snextc()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.sgetc() != EOF);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());

    char data[TEST_SIZE];

    data[0] = buffer.sgetc();

    for (int i = 1; i < TEST_SIZE; ++i)
        data[i] = buffer.snextc();

    CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
    CPPUNIT_ASSERT_EQUAL((int)(unsigned char) (m_testData[TEST_SIZE - 1]),
                         buffer.sbumpc());
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);
}

void StdStreamTestCase::InputBuffer_sbumpc()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.sgetc() != EOF);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());

    char data[TEST_SIZE];

    for (int i = 0; i < TEST_SIZE; ++i)
        data[i] = buffer.sbumpc();

    CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);
}

void StdStreamTestCase::InputBuffer_sgetc()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.sgetc() != EOF);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());

    char data[TEST_SIZE];

    for (int i = 0; i < TEST_SIZE; ++i) {
        data[i] = buffer.sgetc();
        buffer.sbumpc();
    }

    CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);
}

void StdStreamTestCase::InputBuffer_sgetn()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.sgetc() != EOF);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());

    char data[TEST_SIZE * 2];
    std::streamsize read = buffer.sgetn(data, TEST_SIZE * 2);

    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
    CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);
}

void StdStreamTestCase::InputBuffer_sputbackc()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.sgetc() != EOF);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());

    char data[TEST_SIZE];
    std::streamsize read = buffer.sgetn(data, TEST_SIZE);

    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
    CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);

    char putBackChar = m_testData[TEST_SIZE - 1] + 147;

    CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sputbackc(putBackChar));
    CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sgetc());
    CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sbumpc());
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);
}

void StdStreamTestCase::InputBuffer_sungetc()
{
    wxMemoryInputStream stream(m_testData, TEST_SIZE);
    wxStdInputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.sgetc() != EOF);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());

    char data[TEST_SIZE];
    std::streamsize read = buffer.sgetn(data, TEST_SIZE);

    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
    CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);

    CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sungetc());
    CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sgetc());
    CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sbumpc());
    CPPUNIT_ASSERT(buffer.sgetc() == EOF);
}

// --------------------------------------------------------------------------
// Output buffer management and positioning
// --------------------------------------------------------------------------

void StdStreamTestCase::OutputBuffer_pubsetbuf()
{
    wxMemoryOutputStream stream;
    wxStdOutputStreamBuffer buffer(stream);
    char testBuffer[TEST_SIZE];

    CPPUNIT_ASSERT(buffer.pubsetbuf(testBuffer, TEST_SIZE) == NULL);
}

void StdStreamTestCase::OutputBuffer_pubseekoff()
{
    char testData[] = "0123456789";
    wxMemoryOutputStream stream(testData, 10);
    wxStdOutputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT_EQUAL(2,
                         buffer.pubseekoff(2, std::ios_base::beg,
                                           std::ios_base::out));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(2, std::ios_base::beg,
                                           std::ios_base::in));

    CPPUNIT_ASSERT_EQUAL(4,
                         buffer.pubseekoff(2, std::ios_base::cur));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(2, std::ios_base::cur,
                                           std::ios_base::in));

    CPPUNIT_ASSERT_EQUAL(8,
                         buffer.pubseekoff(-2, std::ios_base::end));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(-2, std::ios_base::end,
                                           std::ios_base::in));

    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(3, std::ios_base::cur));
    CPPUNIT_ASSERT_EQUAL(-1,
                         buffer.pubseekoff(3, std::ios_base::cur,
                                           std::ios_base::in));
}

void StdStreamTestCase::OutputBuffer_pubseekpos()
{
    char testData[] = "0123456789";
    wxMemoryOutputStream stream(testData, 10);
    wxStdOutputStreamBuffer buffer(stream);

    for (int i = 9; i >= 0; --i)
    {
        if (i % 2 == 0)
        {
            CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i));
        }
        else
        {
            CPPUNIT_ASSERT_EQUAL(i,
                                 buffer.pubseekpos(i, std::ios_base::out));
        }

        CPPUNIT_ASSERT_EQUAL('0' + (9 - i), buffer.sputc('0' + (9 - i)));
    }

    CPPUNIT_ASSERT(memcmp(testData, "9876543210", 10) == 0);

    CPPUNIT_ASSERT_EQUAL(-1, buffer.pubseekpos(5, std::ios_base::in));
}

void StdStreamTestCase::OutputBuffer_pubsync()
{
    wxMemoryOutputStream stream;
    wxStdOutputStreamBuffer buffer(stream);

    CPPUNIT_ASSERT(buffer.pubsync() == 0);
}

// --------------------------------------------------------------------------
// Output functions
// --------------------------------------------------------------------------

void StdStreamTestCase::OutputBuffer_sputc()
{
    wxMemoryOutputStream stream;
    wxStdOutputStreamBuffer buffer(stream);

    for (int i = 0; i < TEST_SIZE; ++i)
        buffer.sputc(m_testData[i]);

    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, stream.GetSize());

    char result[TEST_SIZE];

    stream.CopyTo(result, TEST_SIZE);
    CPPUNIT_ASSERT(memcmp(result, m_testData, TEST_SIZE) == 0);
}

void StdStreamTestCase::OutputBuffer_sputn()
{
    wxMemoryOutputStream stream;
    wxStdOutputStreamBuffer buffer(stream);

    buffer.sputn(m_testData, TEST_SIZE);
    CPPUNIT_ASSERT_EQUAL(TEST_SIZE, stream.GetSize());

    char result[TEST_SIZE];

    stream.CopyTo(result, TEST_SIZE);
    CPPUNIT_ASSERT(memcmp(result, m_testData, TEST_SIZE) == 0);
}

#endif // wxUSE_STD_IOSTREAM
Commit	Line	Data
72a7c559 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/streams/stdstream.cpp
	3	// Purpose: Test wxStdInputStreamBuffer/wxStdOutputStreamBuffer
	4	// Author: Jonathan Liu <net147@gmail.com>
	5	// RCS-ID: $Id$
	6	// Copyright: (c) 2009 Jonathan Liu
526954c5	7	// Licence: wxWindows licence
72a7c559 VZ	8	///////////////////////////////////////////////////////////////////////////////
	9
	10	// For compilers that support precompilation, includes "wx/wx.h".
	11	// and "wx/cppunit.h"
	12	#include "testprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	// for all others, include the necessary headers
	19	#ifndef WX_PRECOMP
	20	#include "wx/wx.h"
	21	#endif
	22
	23	#if wxUSE_STD_IOSTREAM
	24
	25	#include "wx/stdstream.h"
	26
	27	#include <string.h>
	28	#include "wx/mstream.h"
	29
72a7c559 VZ	30	// ==========================================================================
	31	// Definitions
	32	// ==========================================================================
	33
	34	const int TEST_SIZE = 384;
	35
	36	// ==========================================================================
	37	// Test class
	38	// ==========================================================================
	39
	40	class StdStreamTestCase : public CppUnit::TestCase
	41	{
	42	public:
	43	StdStreamTestCase();
	44
	45	private:
	46	CPPUNIT_TEST_SUITE( StdStreamTestCase );
	47	// Input buffer management and positioning
	48	CPPUNIT_TEST( InputBuffer_pubsetbuf );
	49	CPPUNIT_TEST( InputBuffer_pubseekoff );
	50	CPPUNIT_TEST( InputBuffer_pubseekpos );
	51	CPPUNIT_TEST( InputBuffer_pubsync );
	52
	53	// Input functions
	54	CPPUNIT_TEST( InputBuffer_in_avail );
	55	CPPUNIT_TEST( InputBuffer_snextc );
	56	CPPUNIT_TEST( InputBuffer_sbumpc );
	57	CPPUNIT_TEST( InputBuffer_sgetc );
	58	CPPUNIT_TEST( InputBuffer_sgetn );
	59	CPPUNIT_TEST( InputBuffer_sputbackc );
	60	CPPUNIT_TEST( InputBuffer_sungetc );
	61
	62	// Output buffer management and positioning
	63	CPPUNIT_TEST( OutputBuffer_pubsetbuf );
	64	CPPUNIT_TEST( OutputBuffer_pubseekoff );
	65	CPPUNIT_TEST( OutputBuffer_pubseekpos );
	66	CPPUNIT_TEST( OutputBuffer_pubsync );
	67
	68	// Output functions
	69	CPPUNIT_TEST( OutputBuffer_sputc );
	70	CPPUNIT_TEST( OutputBuffer_sputn );
	71	CPPUNIT_TEST_SUITE_END();
	72
	73	// Input buffer management and positioning
	74	void InputBuffer_pubsetbuf();
	75	void InputBuffer_pubseekoff();
	76	void InputBuffer_pubseekpos();
	77	void InputBuffer_pubsync();
	78
	79	// Input functions
	80	void InputBuffer_in_avail();
	81	void InputBuffer_snextc();
	82	void InputBuffer_sbumpc();
	83	void InputBuffer_sgetc();
	84	void InputBuffer_sgetn();
	85	void InputBuffer_sputbackc();
	86	void InputBuffer_sungetc();
	87
	88	// Output buffer management and positioning
	89	void OutputBuffer_pubsetbuf();
	90	void OutputBuffer_pubseekoff();
	91	void OutputBuffer_pubseekpos();
	92	void OutputBuffer_pubsync();
	93
94	// Output functions
95	void OutputBuffer_sputc();
96	void OutputBuffer_sputn();
97
98	char m_testData[TEST_SIZE];
99
100	DECLARE_NO_COPY_CLASS(StdStreamTestCase)
101	};
102
103	// register in the unnamed registry so that these tests are run by default
104	CPPUNIT_TEST_SUITE_REGISTRATION( StdStreamTestCase );
105
e3778b4d	106	// also include in its own registry so that these tests can be run alone
72a7c559 VZ	107	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( StdStreamTestCase,
	108	"StdStreamTestCase" );
	109
	110	// ==========================================================================
	111	// Implementation
	112	// ==========================================================================
	113
	114	StdStreamTestCase::StdStreamTestCase()
	115	{
	116	for (int i = 0; i < TEST_SIZE; ++i)
	117	m_testData[i] = (i & 0xFF);
	118	}
	119
	120	// --------------------------------------------------------------------------
	121	// Input buffer management and positioning
	122	// --------------------------------------------------------------------------
	123
	124	void StdStreamTestCase::InputBuffer_pubsetbuf()
	125	{
	126	wxMemoryInputStream stream(m_testData, TEST_SIZE);
	127	wxStdInputStreamBuffer buffer(stream);
	128	char testBuffer[TEST_SIZE];
	129
	130	CPPUNIT_ASSERT(buffer.pubsetbuf(testBuffer, TEST_SIZE) == NULL);
	131	}
	132
	133	void StdStreamTestCase::InputBuffer_pubseekoff()
	134	{
	135	const char *testData = "0123456789";
	136	wxMemoryInputStream stream(testData, 10);
	137	wxStdInputStreamBuffer buffer(stream);
	138
	139	CPPUNIT_ASSERT_EQUAL(2,
	140	buffer.pubseekoff(2, std::ios_base::beg,
	141	std::ios_base::in));
	142	CPPUNIT_ASSERT_EQUAL(-1,
	143	buffer.pubseekoff(2, std::ios_base::beg,
	144	std::ios_base::out));
	145
	146	CPPUNIT_ASSERT_EQUAL(4,
	147	buffer.pubseekoff(2, std::ios_base::cur));
	148	CPPUNIT_ASSERT_EQUAL(-1,
	149	buffer.pubseekoff(2, std::ios_base::cur,
	150	std::ios_base::out));
	151
	152	CPPUNIT_ASSERT_EQUAL(8,
	153	buffer.pubseekoff(-2, std::ios_base::end));
	154	CPPUNIT_ASSERT_EQUAL(-1,
	155	buffer.pubseekoff(-2, std::ios_base::end,
	156	std::ios_base::out));
	157
	158	CPPUNIT_ASSERT_EQUAL(-1,
	159	buffer.pubseekoff(3, std::ios_base::cur));
	160	CPPUNIT_ASSERT_EQUAL(-1,
	161	buffer.pubseekoff(3, std::ios_base::cur,
	162	std::ios_base::out));
	163	}
	164
	165	void StdStreamTestCase::InputBuffer_pubseekpos()
	166	{
	167	const char *testData = "0123456789";
	168	wxMemoryInputStream stream(testData, 10);
	169	wxStdInputStreamBuffer buffer(stream);
	170
171	for (int i = 9; i >= 0; --i)
172	{
173	if (i % 2 == 0)
174	CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i));
175	else
176	CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i, std::ios_base::in));
177
178	CPPUNIT_ASSERT_EQUAL('0' + i, buffer.sgetc());
179	}
180	}
181
182	void StdStreamTestCase::InputBuffer_pubsync()
183	{
184	wxMemoryInputStream stream(m_testData, TEST_SIZE);
185	wxStdInputStreamBuffer buffer(stream);
186
187	CPPUNIT_ASSERT(buffer.pubsync() == 0);
188	}
189
190	// --------------------------------------------------------------------------
191	// Input functions
192	// --------------------------------------------------------------------------
193
194	void StdStreamTestCase::InputBuffer_in_avail()
195	{
196	wxMemoryInputStream stream(m_testData, TEST_SIZE);
197	wxStdInputStreamBuffer buffer(stream);
198
199	CPPUNIT_ASSERT(buffer.sgetc() != EOF);
200	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
201
202	char data[TEST_SIZE / 2];
203
204	buffer.sgetn(data, TEST_SIZE / 2);
205	CPPUNIT_ASSERT_EQUAL(TEST_SIZE - TEST_SIZE / 2, buffer.in_avail());
206	}
207
208	void StdStreamTestCase::InputBuffer_snextc()
209	{
210	wxMemoryInputStream stream(m_testData, TEST_SIZE);
211	wxStdInputStreamBuffer buffer(stream);
212
213	CPPUNIT_ASSERT(buffer.sgetc() != EOF);
214	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
215
216	char data[TEST_SIZE];
217
218	data[0] = buffer.sgetc();
219
220	for (int i = 1; i < TEST_SIZE; ++i)
221	data[i] = buffer.snextc();
222
223	CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
224	CPPUNIT_ASSERT_EQUAL((int)(unsigned char) (m_testData[TEST_SIZE - 1]),
225	buffer.sbumpc());
226	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
227	}
228
229	void StdStreamTestCase::InputBuffer_sbumpc()
230	{
231	wxMemoryInputStream stream(m_testData, TEST_SIZE);
232	wxStdInputStreamBuffer buffer(stream);
233
234	CPPUNIT_ASSERT(buffer.sgetc() != EOF);
235	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
236
237	char data[TEST_SIZE];
238
239	for (int i = 0; i < TEST_SIZE; ++i)
240	data[i] = buffer.sbumpc();
241
242	CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
243	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
244	}
245
246	void StdStreamTestCase::InputBuffer_sgetc()
247	{
248	wxMemoryInputStream stream(m_testData, TEST_SIZE);
249	wxStdInputStreamBuffer buffer(stream);
250
251	CPPUNIT_ASSERT(buffer.sgetc() != EOF);
252	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
253
254	char data[TEST_SIZE];
255
256	for (int i = 0; i < TEST_SIZE; ++i) {
257	data[i] = buffer.sgetc();
258	buffer.sbumpc();
259	}
260
261	CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
262	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
263	}
264
265	void StdStreamTestCase::InputBuffer_sgetn()
266	{
267	wxMemoryInputStream stream(m_testData, TEST_SIZE);
268	wxStdInputStreamBuffer buffer(stream);
269
270	CPPUNIT_ASSERT(buffer.sgetc() != EOF);
271	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
272
273	char data[TEST_SIZE * 2];
274	std::streamsize read = buffer.sgetn(data, TEST_SIZE * 2);
275
276	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
277	CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
278	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
279	}
280
281	void StdStreamTestCase::InputBuffer_sputbackc()
282	{
283	wxMemoryInputStream stream(m_testData, TEST_SIZE);
284	wxStdInputStreamBuffer buffer(stream);
285
286	CPPUNIT_ASSERT(buffer.sgetc() != EOF);
287	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
288
289	char data[TEST_SIZE];
290	std::streamsize read = buffer.sgetn(data, TEST_SIZE);
291
292	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
293	CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
294	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
295
296	char putBackChar = m_testData[TEST_SIZE - 1] + 147;
297
298	CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sputbackc(putBackChar));
299	CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sgetc());
300	CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sbumpc());
301	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
302	}
303
304	void StdStreamTestCase::InputBuffer_sungetc()
305	{
306	wxMemoryInputStream stream(m_testData, TEST_SIZE);
307	wxStdInputStreamBuffer buffer(stream);
308
309	CPPUNIT_ASSERT(buffer.sgetc() != EOF);
310	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
311
312	char data[TEST_SIZE];
313	std::streamsize read = buffer.sgetn(data, TEST_SIZE);
314
315	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
316	CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
317	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
318
319	CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sungetc());
320	CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sgetc());
321	CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sbumpc());
322	CPPUNIT_ASSERT(buffer.sgetc() == EOF);
323	}
324
325	// --------------------------------------------------------------------------
326	// Output buffer management and positioning
327	// --------------------------------------------------------------------------
328
329	void StdStreamTestCase::OutputBuffer_pubsetbuf()
330	{
331	wxMemoryOutputStream stream;
332	wxStdOutputStreamBuffer buffer(stream);
333	char testBuffer[TEST_SIZE];
334
335	CPPUNIT_ASSERT(buffer.pubsetbuf(testBuffer, TEST_SIZE) == NULL);
336	}
337
338	void StdStreamTestCase::OutputBuffer_pubseekoff()
339	{
340	char testData[] = "0123456789";
341	wxMemoryOutputStream stream(testData, 10);
342	wxStdOutputStreamBuffer buffer(stream);
343
344	CPPUNIT_ASSERT_EQUAL(2,
345	buffer.pubseekoff(2, std::ios_base::beg,
346	std::ios_base::out));
347	CPPUNIT_ASSERT_EQUAL(-1,
348	buffer.pubseekoff(2, std::ios_base::beg,
349	std::ios_base::in));
350
351	CPPUNIT_ASSERT_EQUAL(4,
352	buffer.pubseekoff(2, std::ios_base::cur));
353	CPPUNIT_ASSERT_EQUAL(-1,
354	buffer.pubseekoff(2, std::ios_base::cur,
355	std::ios_base::in));
356
357	CPPUNIT_ASSERT_EQUAL(8,
358	buffer.pubseekoff(-2, std::ios_base::end));
359	CPPUNIT_ASSERT_EQUAL(-1,
360	buffer.pubseekoff(-2, std::ios_base::end,
361	std::ios_base::in));
362
363	CPPUNIT_ASSERT_EQUAL(-1,
364	buffer.pubseekoff(3, std::ios_base::cur));
365	CPPUNIT_ASSERT_EQUAL(-1,
366	buffer.pubseekoff(3, std::ios_base::cur,
367	std::ios_base::in));
368	}
369
370	void StdStreamTestCase::OutputBuffer_pubseekpos()
371	{
372	char testData[] = "0123456789";
373	wxMemoryOutputStream stream(testData, 10);
374	wxStdOutputStreamBuffer buffer(stream);
375
376	for (int i = 9; i >= 0; --i)
377	{
378	if (i % 2 == 0)
379	{
380	CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i));
381	}
382	else
383	{
384	CPPUNIT_ASSERT_EQUAL(i,
385	buffer.pubseekpos(i, std::ios_base::out));
386	}
387
388	CPPUNIT_ASSERT_EQUAL('0' + (9 - i), buffer.sputc('0' + (9 - i)));
389	}
390
391	CPPUNIT_ASSERT(memcmp(testData, "9876543210", 10) == 0);
392
393	CPPUNIT_ASSERT_EQUAL(-1, buffer.pubseekpos(5, std::ios_base::in));
394	}
395
396	void StdStreamTestCase::OutputBuffer_pubsync()
397	{
398	wxMemoryOutputStream stream;
399	wxStdOutputStreamBuffer buffer(stream);
400
401	CPPUNIT_ASSERT(buffer.pubsync() == 0);
402	}
403
404	// --------------------------------------------------------------------------
405	// Output functions
406	// --------------------------------------------------------------------------
407
408	void StdStreamTestCase::OutputBuffer_sputc()
409	{
410	wxMemoryOutputStream stream;
411	wxStdOutputStreamBuffer buffer(stream);
412
413	for (int i = 0; i < TEST_SIZE; ++i)
414	buffer.sputc(m_testData[i]);
415
416	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, stream.GetSize());
417
418	char result[TEST_SIZE];
419
420	stream.CopyTo(result, TEST_SIZE);
421	CPPUNIT_ASSERT(memcmp(result, m_testData, TEST_SIZE) == 0);
422	}
423
424	void StdStreamTestCase::OutputBuffer_sputn()
425	{
426	wxMemoryOutputStream stream;
427	wxStdOutputStreamBuffer buffer(stream);
428
429	buffer.sputn(m_testData, TEST_SIZE);
430	CPPUNIT_ASSERT_EQUAL(TEST_SIZE, stream.GetSize());
431
432	char result[TEST_SIZE];
433
434	stream.CopyTo(result, TEST_SIZE);
435	CPPUNIT_ASSERT(memcmp(result, m_testData, TEST_SIZE) == 0);
436	}
437
438	#endif // wxUSE_STD_IOSTREAM