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

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