[libt2n] / test / reconnect.cpp

/*
Copyright (C) 2004 by Intra2net AG

The software in this package is distributed under the GNU General
Public License version 2 (with a special exception described below).

A copy of GNU General Public License (GPL) is included in this distribution,
in the file COPYING.GPL.

As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.

However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.

This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.
*/
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <time.h>

#include <iostream>
#include <string>
#include <sstream>
#include <stdexcept>

#define BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>

#include <socket_client.hxx>
#include <socket_server.hxx>

#include "test_fixtures.hxx"

#include <config.h>

using namespace std;
using namespace libt2n;

BOOST_FIXTURE_TEST_SUITE(test_reconnect, KillChildOnShutdownFixture)

BOOST_AUTO_TEST_CASE(simple_reconnect)
{
    switch(child_pid=fork())
    {
        case -1:
        {
            BOOST_FAIL("fork error");
            break;
        }
        case 0:
        // child
        {
            try
            {
                socket_server ss("./socket");

                time_t t0 = time(NULL);

                // max 10 sec
                while (time(NULL) < t0 + 10 )
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;

                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);

                        if (data=="QUIT")
                            break;

                        if (data=="x")
                            con->write(string().insert(0,100,'X'));
                        else
                            con->write(string().insert(0,100,'Y'));
                    }
                }
            } catch(...)
            {
                std::cerr << "exception in child. ignoring\n";
            }

            // don't call atexit and stuff
            _exit(0);
        }

        default:
        // parent
        {
            // don't kill us on broken pipe
            signal(SIGPIPE, SIG_IGN);

            // wait till server is up
            sleep(1);
            socket_client_connection sc("./socket");

            sc.write("abc");

            string data;

            while (!sc.get_packet(data))
                sc.fill_buffer(1000000);

            sc.reconnect();

            sc.write("x");

            while (!sc.get_packet(data))
                sc.fill_buffer(1000000);

            BOOST_CHECK_EQUAL(string().insert(0,100,'X'),data);
        }
    }
}

BOOST_AUTO_TEST_CASE(reconnect_with_close)
{
    switch(child_pid=fork())
    {
        case -1:
        {
            BOOST_FAIL("fork error");
            break;
        }
        case 0:
        // child
        {
            try
            {
                socket_server ss("./socket");

                time_t t0 = time(NULL);

                // max 10 sec
                while (time(NULL) < t0 + 10 )
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;

                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);

                        if (data=="QUIT")
                            break;

                        if (data=="x")
                            con->write(string().insert(0,100,'X'));
                        else
                            con->write(string().insert(0,100,'Y'));
                    }
                }
            } catch(...)
            {
                std::cerr << "exception in child. ignoring\n";
            }

            // don't call atexit and stuff
            _exit(0);
        }

        default:
        // parent
        {
            // don't kill us on broken pipe
            signal(SIGPIPE, SIG_IGN);

            // wait till server is up
            sleep(1);
            socket_client_connection sc("./socket");

            sc.write("abc");

            string data;

            while (!sc.get_packet(data))
                sc.fill_buffer(1000000);

            sc.close();

            // empty buffer
            sc.get_packet(data);

            sc.reconnect();

            sc.write("x");

            while (!sc.get_packet(data))
                sc.fill_buffer(1000000);

            BOOST_CHECK_EQUAL(string().insert(0,100,'X'),data);
        }
    }
}

BOOST_AUTO_TEST_CASE(reconnect_buffer_complete)
{
    switch(child_pid=fork())
    {
        case -1:
        {
            BOOST_FAIL("fork error");
            break;
        }
        case 0:
        // child
        {
            try
            {
                socket_server ss("./socket");

                time_t t0 = time(NULL);

                // max 10 sec
                while (time(NULL) < t0 + 10 )
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;

                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);

                        if (data=="QUIT")
                            break;

                        if (data=="x")
                            con->write(string().insert(0,100,'X'));
                    }
                }
            } catch(...)
            {
                std::cerr << "exception in child. ignoring\n";
            }

            // don't call atexit and stuff
            _exit(0);
        }

        default:
        // parent
        {
            // don't kill us on broken pipe
            signal(SIGPIPE, SIG_IGN);

            // wait till server is up
            sleep(1);
            socket_client_connection sc("./socket");

            sc.write("x");

            string data;

            while (!sc.packet_available())
                sc.fill_buffer(1000000);

            sc.reconnect();

            BOOST_CHECK_MESSAGE(sc.get_packet(data) == true, "packet not there");

            BOOST_CHECK_MESSAGE(data == string().insert(0,100,'X'), "data incorrect");
        }
    }
}

BOOST_AUTO_TEST_CASE(reconnect_buffer_several_complete)
{
    const int packets=3;

    switch(child_pid=fork())
    {
        case -1:
        {
            BOOST_FAIL("fork error");
            break;
        }
        case 0:
        // child
        {
            try
            {
                socket_server ss("./socket");

                time_t t0 = time(NULL);

                // max 10 sec
                while (time(NULL) < t0 + 10 )
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;

                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);

                        if (data=="QUIT")
                            break;

                        if (data=="x")
                        {
                            for (int i=0; i<packets; i++)
                                con->write(string().insert(0,100,'X'));
                        }
                    }
                }
            } catch(...)
            {
                std::cerr << "exception in child. ignoring\n";
            }

            // don't call atexit and stuff
            _exit(0);
        }

        default:
        // parent
        {
            // don't kill us on broken pipe
            signal(SIGPIPE, SIG_IGN);

            // wait till server is up
            sleep(1);
            socket_client_connection sc("./socket");

            sc.write("x");

            // retrieve packets for 3 seconds
            time_t t0 = time(NULL);

            // max 3 sec
            while (time(NULL) < t0 + 3 )
                sc.fill_buffer(1000000);

            // we now should have packets complete packets in the buffer

            sc.reconnect();

            // are these packets still there?

            for (int i=0; i < packets; i++)
            {
                string data;

                ostringstream os;
                os << "packet " << i << " not there";

                BOOST_CHECK_MESSAGE(sc.get_packet(data) == true, os.str());

                os.str("");
                os << "packet " << i << " incorrect";

                BOOST_CHECK_MESSAGE(string().insert(0,100,'X') == data, os.str());
            }
        }
    }
}

BOOST_AUTO_TEST_CASE(reconnect_buffer_no_incomplete1)
{
    switch(child_pid=fork())
    {
        case -1:
        {
            BOOST_FAIL("fork error");
            break;
        }
        case 0:
        // child
        {
            try
            {
                socket_server ss("./socket");

                time_t t0 = time(NULL);

                // max 10 sec
                while (time(NULL) < t0 + 10 )
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;

                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);

                        if (data=="QUIT")
                            break;

                        if (data=="x")
                        {
                            con->write(string().insert(0,100,'X'));
                            send_raw_socket("aaaab",&ss,cid);
                        }
                    }
                }
            } catch(...)
            {
                std::cerr << "exception in child. ignoring\n";
            }

            // don't call atexit and stuff
            _exit(0);
        }

        default:
        // parent
        {
            // don't kill us on broken pipe
            signal(SIGPIPE, SIG_IGN);

            // wait till server is up
            sleep(1);
            socket_client_connection sc("./socket");

            sc.write("x");

            // retrieve packets for 3 seconds
            time_t t0 = time(NULL);

            // max 3 sec
            while (time(NULL) < t0 + 3 )
                sc.fill_buffer(1000000);

            // we now should have one complete packet and some stuff in the buffer

            string data;
            sc.get_packet(data);

            BOOST_CHECK_MESSAGE((sc.peek_packet(data))>0, "no incomplete packet");

            sc.reconnect();

            BOOST_CHECK_MESSAGE((int)sc.peek_packet(data) == 0, "incomplete packet not removed");
        }
    }
}

BOOST_AUTO_TEST_CASE(reconnect_buffer_no_incomplete2)
{
    switch(child_pid=fork())
    {
        case -1:
        {
            BOOST_FAIL("fork error");
            break;
        }
        case 0:
        // child
        {
            try
            {
                socket_server ss("./socket");

                time_t t0 = time(NULL);

                // max 10 sec
                while (time(NULL) < t0 + 10 )
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;

                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);

                        if (data=="QUIT")
                            break;

                        if (data=="x")
                        {
                            con->write(string().insert(0,100,'X'));

                            string blob=string().insert(0,100,'Y');

                            // one byte will be missing...
                            int size=blob.size()+1;
                            char sizetransfer[sizeof(int)+1];
                            memcpy(sizetransfer,(void*)&size,sizeof(int));
                            sizetransfer[sizeof(int)]=0;

                            string packet=string(sizetransfer)+blob;

                            send_raw_socket(packet,&ss,cid);
                        }
                    }
                }
            } catch(...)
            {
                std::cerr << "exception in child. ignoring\n";
            }

            // don't call atexit and stuff
            _exit(0);
        }

        default:
        // parent
        {
            // don't kill us on broken pipe
            signal(SIGPIPE, SIG_IGN);

            // wait till server is up
            sleep(1);
            socket_client_connection sc("./socket");

            sc.write("x");

            // retrieve packets for 3 seconds
            time_t t0 = time(NULL);

            // max 3 sec
            while (time(NULL) < t0 + 3 )
                sc.fill_buffer(1000000);

            // we now should have one complete packet and some stuff in the buffer

            sc.reconnect();

            string data;

            BOOST_CHECK_MESSAGE(sc.get_packet(data) == true, "packet not there");
            BOOST_CHECK_MESSAGE(string().insert(0,100,'X') == data, "data incorrect");

            BOOST_CHECK_MESSAGE((int)sc.peek_packet(data) == 0, "incomplete packet not removed");
        }
    }
}

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
	1	/*
	2	Copyright (C) 2004 by Intra2net AG
	3
	4	The software in this package is distributed under the GNU General
	5	Public License version 2 (with a special exception described below).
	6
	7	A copy of GNU General Public License (GPL) is included in this distribution,
	8	in the file COPYING.GPL.
	9
	10	As a special exception, if other files instantiate templates or use macros
	11	or inline functions from this file, or you compile this file and link it
	12	with other works to produce a work based on this file, this file
	13	does not by itself cause the resulting work to be covered
	14	by the GNU General Public License.
	15
	16	However the source code for this file must still be made available
	17	in accordance with section (3) of the GNU General Public License.
	18
	19	This exception does not invalidate any other reasons why a work based
	20	on this file might be covered by the GNU General Public License.
	21	*/
	22	#include <sys/types.h>
	23	#include <unistd.h>
	24	#include <errno.h>
	25	#include <signal.h>
	26	#include <stdio.h>
	27	#include <time.h>
	28
	29	#include <iostream>
	30	#include <string>
	31	#include <sstream>
	32	#include <stdexcept>
	33
	34	#define BOOST_TEST_DYN_LINK
	35	#include <boost/test/unit_test.hpp>
	36
	37	#include <socket_client.hxx>
	38	#include <socket_server.hxx>
	39
	40	#include "test_fixtures.hxx"
	41
	42	#include <config.h>
	43
	44	using namespace std;
	45	using namespace libt2n;
	46
	47	BOOST_FIXTURE_TEST_SUITE(test_reconnect, KillChildOnShutdownFixture)
	48
	49	BOOST_AUTO_TEST_CASE(simple_reconnect)
	50	{
	51	switch(child_pid=fork())
	52	{
	53	case -1:
	54	{
	55	BOOST_FAIL("fork error");
	56	break;
	57	}
	58	case 0:
	59	// child
	60	{
	61	try
	62	{
	63	socket_server ss("./socket");
	64
	65	time_t t0 = time(NULL);
	66
	67	// max 10 sec
	68	while (time(NULL) < t0 + 10 )
	69	{
	70	ss.fill_buffer(1000000);
	71
	72	string data;
	73	unsigned int cid;
	74
	75	if(ss.get_packet(data,cid))
	76	{
	77	server_connection* con=ss.get_connection(cid);
	78
	79	if (data=="QUIT")
	80	break;
	81
	82	if (data=="x")
	83	con->write(string().insert(0,100,'X'));
	84	else
	85	con->write(string().insert(0,100,'Y'));
	86	}
	87	}
	88	} catch(...)
	89	{
	90	std::cerr << "exception in child. ignoring\n";
	91	}
	92
	93	// don't call atexit and stuff
	94	_exit(0);
	95	}
	96
	97	default:
	98	// parent
	99	{
	100	// don't kill us on broken pipe
	101	signal(SIGPIPE, SIG_IGN);
	102
	103	// wait till server is up
	104	sleep(1);
	105	socket_client_connection sc("./socket");
	106
	107	sc.write("abc");
	108
	109	string data;
	110
	111	while (!sc.get_packet(data))
	112	sc.fill_buffer(1000000);
	113
	114	sc.reconnect();
	115
	116	sc.write("x");
	117
	118	while (!sc.get_packet(data))
	119	sc.fill_buffer(1000000);
	120
	121	BOOST_CHECK_EQUAL(string().insert(0,100,'X'),data);
	122	}
	123	}
	124	}
	125
	126	BOOST_AUTO_TEST_CASE(reconnect_with_close)
	127	{
	128	switch(child_pid=fork())
	129	{
	130	case -1:
	131	{
	132	BOOST_FAIL("fork error");
	133	break;
	134	}
	135	case 0:
	136	// child
	137	{
	138	try
	139	{
	140	socket_server ss("./socket");
	141
	142	time_t t0 = time(NULL);
	143
	144	// max 10 sec
	145	while (time(NULL) < t0 + 10 )
	146	{
	147	ss.fill_buffer(1000000);
	148
	149	string data;
	150	unsigned int cid;
	151
	152	if(ss.get_packet(data,cid))
	153	{
	154	server_connection* con=ss.get_connection(cid);
	155
	156	if (data=="QUIT")
	157	break;
	158
	159	if (data=="x")
	160	con->write(string().insert(0,100,'X'));
	161	else
	162	con->write(string().insert(0,100,'Y'));
	163	}
	164	}
	165	} catch(...)
	166	{
	167	std::cerr << "exception in child. ignoring\n";
	168	}
	169
	170	// don't call atexit and stuff
	171	_exit(0);
	172	}
	173
	174	default:
	175	// parent
	176	{
	177	// don't kill us on broken pipe
	178	signal(SIGPIPE, SIG_IGN);
	179
	180	// wait till server is up
	181	sleep(1);
	182	socket_client_connection sc("./socket");
	183
	184	sc.write("abc");
	185
	186	string data;
	187
	188	while (!sc.get_packet(data))
	189	sc.fill_buffer(1000000);
	190
	191	sc.close();
	192
	193	// empty buffer
	194	sc.get_packet(data);
	195
	196	sc.reconnect();
	197
	198	sc.write("x");
	199
	200	while (!sc.get_packet(data))
	201	sc.fill_buffer(1000000);
	202
	203	BOOST_CHECK_EQUAL(string().insert(0,100,'X'),data);
	204	}
	205	}
	206	}
	207
	208	BOOST_AUTO_TEST_CASE(reconnect_buffer_complete)
	209	{
	210	switch(child_pid=fork())
	211	{
	212	case -1:
	213	{
	214	BOOST_FAIL("fork error");
	215	break;
	216	}
	217	case 0:
	218	// child
	219	{
	220	try
	221	{
	222	socket_server ss("./socket");
	223
	224	time_t t0 = time(NULL);
	225
	226	// max 10 sec
	227	while (time(NULL) < t0 + 10 )
	228	{
	229	ss.fill_buffer(1000000);
	230
	231	string data;
	232	unsigned int cid;
	233
	234	if(ss.get_packet(data,cid))
	235	{
	236	server_connection* con=ss.get_connection(cid);
	237
	238	if (data=="QUIT")
	239	break;
	240
	241	if (data=="x")
	242	con->write(string().insert(0,100,'X'));
	243	}
	244	}
	245	} catch(...)
	246	{
	247	std::cerr << "exception in child. ignoring\n";
	248	}
	249
	250	// don't call atexit and stuff
	251	_exit(0);
	252	}
	253
	254	default:
	255	// parent
	256	{
	257	// don't kill us on broken pipe
	258	signal(SIGPIPE, SIG_IGN);
	259
	260	// wait till server is up
	261	sleep(1);
	262	socket_client_connection sc("./socket");
	263
	264	sc.write("x");
	265
	266	string data;
	267
	268	while (!sc.packet_available())
	269	sc.fill_buffer(1000000);
	270
	271	sc.reconnect();
	272
	273	BOOST_CHECK_MESSAGE(sc.get_packet(data) == true, "packet not there");
	274
	275	BOOST_CHECK_MESSAGE(data == string().insert(0,100,'X'), "data incorrect");
	276	}
	277	}
	278	}
	279
	280	BOOST_AUTO_TEST_CASE(reconnect_buffer_several_complete)
	281	{
	282	const int packets=3;
	283
	284	switch(child_pid=fork())
	285	{
	286	case -1:
	287	{
	288	BOOST_FAIL("fork error");
	289	break;
	290	}
	291	case 0:
	292	// child
	293	{
	294	try
	295	{
	296	socket_server ss("./socket");
	297
	298	time_t t0 = time(NULL);
	299
	300	// max 10 sec
	301	while (time(NULL) < t0 + 10 )
	302	{
	303	ss.fill_buffer(1000000);
	304
	305	string data;
	306	unsigned int cid;
	307
	308	if(ss.get_packet(data,cid))
	309	{
	310	server_connection* con=ss.get_connection(cid);
	311
	312	if (data=="QUIT")
	313	break;
	314
	315	if (data=="x")
	316	{
	317	for (int i=0; i<packets; i++)
	318	con->write(string().insert(0,100,'X'));
	319	}
	320	}
	321	}
	322	} catch(...)
	323	{
	324	std::cerr << "exception in child. ignoring\n";
	325	}
	326
	327	// don't call atexit and stuff
	328	_exit(0);
	329	}
	330
	331	default:
	332	// parent
	333	{
	334	// don't kill us on broken pipe
	335	signal(SIGPIPE, SIG_IGN);
	336
	337	// wait till server is up
	338	sleep(1);
	339	socket_client_connection sc("./socket");
	340
	341	sc.write("x");
	342
	343	// retrieve packets for 3 seconds
	344	time_t t0 = time(NULL);
	345
	346	// max 3 sec
	347	while (time(NULL) < t0 + 3 )
	348	sc.fill_buffer(1000000);
	349
	350	// we now should have packets complete packets in the buffer
	351
	352	sc.reconnect();
	353
	354	// are these packets still there?
	355
	356	for (int i=0; i < packets; i++)
	357	{
	358	string data;
	359
	360	ostringstream os;
	361	os << "packet " << i << " not there";
	362
	363	BOOST_CHECK_MESSAGE(sc.get_packet(data) == true, os.str());
	364
	365	os.str("");
	366	os << "packet " << i << " incorrect";
	367
	368	BOOST_CHECK_MESSAGE(string().insert(0,100,'X') == data, os.str());
	369	}
	370	}
	371	}
	372	}
	373
	374	BOOST_AUTO_TEST_CASE(reconnect_buffer_no_incomplete1)
	375	{
	376	switch(child_pid=fork())
	377	{
	378	case -1:
	379	{
	380	BOOST_FAIL("fork error");
	381	break;
	382	}
	383	case 0:
	384	// child
	385	{
	386	try
	387	{
	388	socket_server ss("./socket");
	389
	390	time_t t0 = time(NULL);
	391
	392	// max 10 sec
	393	while (time(NULL) < t0 + 10 )
	394	{
	395	ss.fill_buffer(1000000);
	396
	397	string data;
	398	unsigned int cid;
	399
	400	if(ss.get_packet(data,cid))
	401	{
	402	server_connection* con=ss.get_connection(cid);
	403
	404	if (data=="QUIT")
	405	break;
	406
	407	if (data=="x")
	408	{
	409	con->write(string().insert(0,100,'X'));
	410	send_raw_socket("aaaab",&ss,cid);
	411	}
	412	}
	413	}
	414	} catch(...)
	415	{
	416	std::cerr << "exception in child. ignoring\n";
	417	}
	418
	419	// don't call atexit and stuff
	420	_exit(0);
	421	}
	422
	423	default:
	424	// parent
	425	{
	426	// don't kill us on broken pipe
	427	signal(SIGPIPE, SIG_IGN);
	428
	429	// wait till server is up
	430	sleep(1);
	431	socket_client_connection sc("./socket");
	432
	433	sc.write("x");
	434
	435	// retrieve packets for 3 seconds
	436	time_t t0 = time(NULL);
	437
	438	// max 3 sec
	439	while (time(NULL) < t0 + 3 )
	440	sc.fill_buffer(1000000);
	441
	442	// we now should have one complete packet and some stuff in the buffer
	443
	444	string data;
	445	sc.get_packet(data);
	446
	447	BOOST_CHECK_MESSAGE((sc.peek_packet(data))>0, "no incomplete packet");
	448
	449	sc.reconnect();
	450
	451	BOOST_CHECK_MESSAGE((int)sc.peek_packet(data) == 0, "incomplete packet not removed");
	452	}
	453	}
	454	}
	455
	456	BOOST_AUTO_TEST_CASE(reconnect_buffer_no_incomplete2)
	457	{
	458	switch(child_pid=fork())
	459	{
	460	case -1:
	461	{
	462	BOOST_FAIL("fork error");
	463	break;
	464	}
	465	case 0:
	466	// child
	467	{
	468	try
	469	{
	470	socket_server ss("./socket");
	471
	472	time_t t0 = time(NULL);
	473
	474	// max 10 sec
	475	while (time(NULL) < t0 + 10 )
	476	{
	477	ss.fill_buffer(1000000);
	478
	479	string data;
	480	unsigned int cid;
	481
	482	if(ss.get_packet(data,cid))
	483	{
	484	server_connection* con=ss.get_connection(cid);
	485
	486	if (data=="QUIT")
	487	break;
	488
	489	if (data=="x")
	490	{
	491	con->write(string().insert(0,100,'X'));
	492
	493	string blob=string().insert(0,100,'Y');
	494
	495	// one byte will be missing...
	496	int size=blob.size()+1;
	497	char sizetransfer[sizeof(int)+1];
	498	memcpy(sizetransfer,(void*)&size,sizeof(int));
	499	sizetransfer[sizeof(int)]=0;
	500
	501	string packet=string(sizetransfer)+blob;
	502
	503	send_raw_socket(packet,&ss,cid);
	504	}
	505	}
	506	}
	507	} catch(...)
	508	{
	509	std::cerr << "exception in child. ignoring\n";
	510	}
	511
	512	// don't call atexit and stuff
	513	_exit(0);
	514	}
	515
	516	default:
	517	// parent
	518	{
	519	// don't kill us on broken pipe
	520	signal(SIGPIPE, SIG_IGN);
	521
	522	// wait till server is up
	523	sleep(1);
	524	socket_client_connection sc("./socket");
	525
	526	sc.write("x");
	527
	528	// retrieve packets for 3 seconds
	529	time_t t0 = time(NULL);
	530
	531	// max 3 sec
	532	while (time(NULL) < t0 + 3 )
	533	sc.fill_buffer(1000000);
	534
	535	// we now should have one complete packet and some stuff in the buffer
	536
	537	sc.reconnect();
	538
	539	string data;
	540
	541	BOOST_CHECK_MESSAGE(sc.get_packet(data) == true, "packet not there");
	542	BOOST_CHECK_MESSAGE(string().insert(0,100,'X') == data, "data incorrect");
	543
	544	BOOST_CHECK_MESSAGE((int)sc.peek_packet(data) == 0, "incomplete packet not removed");
	545	}
	546	}
	547	}
	548
	549	BOOST_AUTO_TEST_SUITE_END()