[libt2n] / test / callback.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 <iostream>
#include <string>
#include <sstream>
#include <stdexcept>
#include <vector>

#include <boost/bind.hpp>

#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
#include <cppunit/extensions/HelperMacros.h>

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

using namespace std;
using namespace libt2n;
using namespace CppUnit;

class test_callback : public TestFixture
{
    CPPUNIT_TEST_SUITE(test_callback);

    CPPUNIT_TEST(ServerNewConnCallback);
    CPPUNIT_TEST(ServerConnClosedCallback);
    CPPUNIT_TEST(ServerConnDeletedCallback);
    CPPUNIT_TEST(ServerCallbackOrder);
    CPPUNIT_TEST(ClientConnClosedCallback);
    CPPUNIT_TEST(ClientConnDeletedCallback);

    CPPUNIT_TEST_SUITE_END();

    std::vector<bool> callback_done;

    pid_t child_pid;

    public:

    void setUp()
    {
        callback_done.resize(__events_end);
    }

    void tearDown()
    {
        callback_done.clear();

        // make sure the server-child is dead before the next test runs
        kill(child_pid,SIGKILL);
        sleep(1);
    }

    void callback_func(callback_event_type ev, int conn_id)
    {
        // we don't care for the conn_id, we just mark the callback as done
        if (callback_done[ev])
            throw runtime_error("callback already done for this event");

        callback_done[ev]=true;
    }

    void ServerNewConnCallback()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    string data;
                    // wait till server is up
                    sleep(1);

                    {
                        socket_client_connection sc("./socket");

                        sc.write("ABC");

                        // wait half a sec
                        sc.fill_buffer(500000);
                        sc.get_packet(data);

                        // close the connection
                    }
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

            default:
            // parent
            {
                socket_server ss("./socket");

                ss.add_callback(new_connection,bind(&test_callback::callback_func, boost::ref(*this), new_connection, _1));

                // max 3 sec
                for (int i=0; i < 3; i++)
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;
                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);
                        con->write("XYZ");
                    }
                }
                CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[new_connection]));
                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_closed]));
                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_deleted]));
            }
        }
    }

    void ServerConnClosedCallback()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    string data;
                    // wait till server is up
                    sleep(1);

                    {
                        socket_client_connection sc("./socket");

                        sc.write("ABC");

                        // wait half a sec
                        sc.fill_buffer(500000);
                        sc.get_packet(data);

                        // close the connection
                    }
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

            default:
            // parent
            {
                socket_server ss("./socket");

                ss.add_callback(connection_closed,bind(&test_callback::callback_func, boost::ref(*this), connection_closed, _1));

                // max 3 sec
                for (int i=0; i < 3; i++)
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;
                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);
                        con->write("XYZ");
                    }
                }
                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
                CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_closed]));
                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_deleted]));
            }
        }
    }

    void ServerConnDeletedCallback()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    string data;
                    // wait till server is up
                    sleep(1);

                    {
                        socket_client_connection sc("./socket");

                        sc.write("ABC");

                        // wait half a sec
                        sc.fill_buffer(500000);
                        sc.get_packet(data);

                        // close the connection
                    }
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

            default:
            // parent
            {
                socket_server ss("./socket");

                ss.add_callback(connection_deleted,bind(&test_callback::callback_func, boost::ref(*this), connection_deleted, _1));

                // max 3 sec
                for (int i=0; i < 3; i++)
                {
                    ss.fill_buffer(1000000);

                    string data;
                    unsigned int cid;
                    if(ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);
                        con->write("XYZ");
                    }
                    ss.cleanup();
                }
                ss.cleanup();

                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_closed]));
                CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_deleted]));
            }
        }
    }

    void ServerCallbackOrder()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    string data;
                    // wait till server is up
                    sleep(1);

                    {
                        socket_client_connection sc("./socket");

                        sc.write("1");

                        // wait half a sec
                        sc.fill_buffer(500000);
                        sc.get_packet(data);

                        sc.write("2");

                        // close the connection
                    }
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

            default:
            // parent
            {
                socket_server ss("./socket");

                ss.add_callback(connection_closed,bind(&test_callback::callback_func, boost::ref(*this), connection_closed, _1));
                ss.add_callback(connection_deleted,bind(&test_callback::callback_func, boost::ref(*this), connection_deleted, _1));

                bool got_1=false;

                for (int i=0; i < 5; i++)
                {
                    ss.fill_buffer(500000);

                    string data;
                    unsigned int cid;
                    if(!got_1 && ss.get_packet(data,cid))
                    {
                        server_connection* con=ss.get_connection(cid);
                        con->write("XYZ");
                        got_1=true;
                        // don't call get_packet anymore
                    }
                    ss.cleanup();
                }
                ss.cleanup();

                CPPUNIT_ASSERT_EQUAL_MESSAGE("closed done",true,static_cast<bool>(callback_done[connection_closed]));
                CPPUNIT_ASSERT_EQUAL_MESSAGE("not deleted yet",false,static_cast<bool>(callback_done[connection_deleted]));

                for (int i=0; i < 4; i++)
                {
                    ss.fill_buffer(500000);

                    string data;
                    unsigned int cid;
                    ss.get_packet(data,cid);
                    ss.cleanup();
                }
                ss.cleanup();

                CPPUNIT_ASSERT_EQUAL_MESSAGE("closed done (2)",true,static_cast<bool>(callback_done[connection_closed]));
                CPPUNIT_ASSERT_EQUAL_MESSAGE("deleted done",true,static_cast<bool>(callback_done[connection_deleted]));
            }
        }
    }

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

                    // max 3 sec
                    for (int i=0; i < 3; i++)
                    {
                        ss.fill_buffer(1000000);

                        string data;
                        unsigned int cid;
                        if(ss.get_packet(data,cid))
                            break;
                    }
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

            default:
            // parent
            {
                string data;
                // wait till server is up
                sleep(1);

                socket_client_connection sc("./socket");

                sc.add_callback(connection_closed,bind(&test_callback::callback_func, boost::ref(*this), connection_closed, 0));

                sc.write("ABC");

                // wait half a sec
                sc.fill_buffer(500000);
                sc.get_packet(data);

                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
                CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_closed]));
                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_deleted]));
            }
        }
    }

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

                    // max 3 sec
                    for (int i=0; i < 3; i++)
                    {
                        ss.fill_buffer(1000000);

                        string data;
                        unsigned int cid;
                        if(ss.get_packet(data,cid))
                            break;
                    }
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

            default:
            // parent
            {
                string data;
                // wait till server is up
                sleep(1);

                {
                    socket_client_connection sc("./socket");

                    sc.add_callback(connection_deleted,bind(&test_callback::callback_func, boost::ref(*this), connection_deleted, 0));

                    sc.write("ABC");

                    // wait half a sec
                    sc.fill_buffer(500000);
                    sc.get_packet(data);
                }

                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
                CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_closed]));
                CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_deleted]));
            }
        }
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION(test_callback);
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
	28	#include <iostream>
	29	#include <string>
	30	#include <sstream>
	31	#include <stdexcept>
	32	#include <vector>
	33
	34	#include <boost/bind.hpp>
	35
	36	#include <cppunit/extensions/TestFactoryRegistry.h>
	37	#include <cppunit/ui/text/TestRunner.h>
	38	#include <cppunit/extensions/HelperMacros.h>
	39
	40	#include <socket_client.hxx>
	41	#include <socket_server.hxx>
	42
	43	using namespace std;
	44	using namespace libt2n;
	45	using namespace CppUnit;
	46
	47	class test_callback : public TestFixture
	48	{
	49	CPPUNIT_TEST_SUITE(test_callback);
	50
	51	CPPUNIT_TEST(ServerNewConnCallback);
	52	CPPUNIT_TEST(ServerConnClosedCallback);
	53	CPPUNIT_TEST(ServerConnDeletedCallback);
	54	CPPUNIT_TEST(ServerCallbackOrder);
	55	CPPUNIT_TEST(ClientConnClosedCallback);
	56	CPPUNIT_TEST(ClientConnDeletedCallback);
	57
	58	CPPUNIT_TEST_SUITE_END();
	59
	60	std::vector<bool> callback_done;
	61
	62	pid_t child_pid;
	63
	64	public:
	65
	66	void setUp()
	67	{
	68	callback_done.resize(__events_end);
	69	}
	70
	71	void tearDown()
	72	{
	73	callback_done.clear();
	74
	75	// make sure the server-child is dead before the next test runs
	76	kill(child_pid,SIGKILL);
	77	sleep(1);
	78	}
	79
	80	void callback_func(callback_event_type ev, int conn_id)
	81	{
	82	// we don't care for the conn_id, we just mark the callback as done
	83	if (callback_done[ev])
	84	throw runtime_error("callback already done for this event");
	85
	86	callback_done[ev]=true;
	87	}
	88
	89	void ServerNewConnCallback()
	90	{
	91	switch(child_pid=fork())
	92	{
	93	case -1:
	94	{
	95	CPPUNIT_FAIL("fork error");
	96	break;
	97	}
	98	case 0:
	99	// child
	100	{
	101	try
	102	{
	103	string data;
	104	// wait till server is up
	105	sleep(1);
	106
	107	{
	108	socket_client_connection sc("./socket");
	109
	110	sc.write("ABC");
	111
	112	// wait half a sec
	113	sc.fill_buffer(500000);
	114	sc.get_packet(data);
	115
	116	// close the connection
	117	}
	118	} catch(...)
	119	{
	120	std::cerr << "exception in child. ignoring\n";
	121	}
	122
	123	// don't call atexit and stuff
	124	_exit(0);
	125	}
	126
	127	default:
	128	// parent
	129	{
	130	socket_server ss("./socket");
	131
	132	ss.add_callback(new_connection,bind(&test_callback::callback_func, boost::ref(*this), new_connection, _1));
	133
	134	// max 3 sec
	135	for (int i=0; i < 3; i++)
	136	{
	137	ss.fill_buffer(1000000);
	138
	139	string data;
	140	unsigned int cid;
	141	if(ss.get_packet(data,cid))
	142	{
	143	server_connection* con=ss.get_connection(cid);
	144	con->write("XYZ");
	145	}
	146	}
	147	CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[new_connection]));
	148	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_closed]));
	149	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_deleted]));
	150	}
	151	}
	152	}
	153
	154	void ServerConnClosedCallback()
	155	{
	156	switch(child_pid=fork())
	157	{
	158	case -1:
	159	{
	160	CPPUNIT_FAIL("fork error");
	161	break;
	162	}
	163	case 0:
	164	// child
	165	{
	166	try
	167	{
	168	string data;
	169	// wait till server is up
	170	sleep(1);
	171
	172	{
	173	socket_client_connection sc("./socket");
	174
	175	sc.write("ABC");
	176
	177	// wait half a sec
	178	sc.fill_buffer(500000);
	179	sc.get_packet(data);
	180
	181	// close the connection
	182	}
	183	} catch(...)
	184	{
	185	std::cerr << "exception in child. ignoring\n";
	186	}
	187
	188	// don't call atexit and stuff
	189	_exit(0);
	190	}
	191
	192	default:
	193	// parent
	194	{
	195	socket_server ss("./socket");
	196
	197	ss.add_callback(connection_closed,bind(&test_callback::callback_func, boost::ref(*this), connection_closed, _1));
	198
	199	// max 3 sec
	200	for (int i=0; i < 3; i++)
	201	{
	202	ss.fill_buffer(1000000);
	203
	204	string data;
	205	unsigned int cid;
	206	if(ss.get_packet(data,cid))
	207	{
	208	server_connection* con=ss.get_connection(cid);
	209	con->write("XYZ");
	210	}
	211	}
	212	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
	213	CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_closed]));
	214	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_deleted]));
	215	}
	216	}
	217	}
	218
	219	void ServerConnDeletedCallback()
	220	{
	221	switch(child_pid=fork())
	222	{
	223	case -1:
	224	{
	225	CPPUNIT_FAIL("fork error");
	226	break;
	227	}
	228	case 0:
	229	// child
	230	{
	231	try
	232	{
	233	string data;
	234	// wait till server is up
	235	sleep(1);
	236
	237	{
	238	socket_client_connection sc("./socket");
	239
	240	sc.write("ABC");
	241
	242	// wait half a sec
	243	sc.fill_buffer(500000);
	244	sc.get_packet(data);
	245
	246	// close the connection
	247	}
	248	} catch(...)
	249	{
	250	std::cerr << "exception in child. ignoring\n";
	251	}
	252
	253	// don't call atexit and stuff
	254	_exit(0);
	255	}
	256
	257	default:
	258	// parent
	259	{
	260	socket_server ss("./socket");
	261
	262	ss.add_callback(connection_deleted,bind(&test_callback::callback_func, boost::ref(*this), connection_deleted, _1));
	263
	264	// max 3 sec
	265	for (int i=0; i < 3; i++)
	266	{
	267	ss.fill_buffer(1000000);
	268
	269	string data;
	270	unsigned int cid;
	271	if(ss.get_packet(data,cid))
	272	{
	273	server_connection* con=ss.get_connection(cid);
	274	con->write("XYZ");
	275	}
	276	ss.cleanup();
	277	}
	278	ss.cleanup();
	279
	280	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
	281	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_closed]));
	282	CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_deleted]));
	283	}
	284	}
	285	}
	286
	287	void ServerCallbackOrder()
	288	{
	289	switch(child_pid=fork())
	290	{
	291	case -1:
	292	{
	293	CPPUNIT_FAIL("fork error");
	294	break;
	295	}
	296	case 0:
	297	// child
	298	{
	299	try
	300	{
	301	string data;
	302	// wait till server is up
	303	sleep(1);
	304
	305	{
	306	socket_client_connection sc("./socket");
	307
	308	sc.write("1");
	309
	310	// wait half a sec
	311	sc.fill_buffer(500000);
	312	sc.get_packet(data);
	313
	314	sc.write("2");
	315
	316	// close the connection
	317	}
	318	} catch(...)
	319	{
	320	std::cerr << "exception in child. ignoring\n";
	321	}
	322
	323	// don't call atexit and stuff
	324	_exit(0);
	325	}
	326
	327	default:
	328	// parent
	329	{
	330	socket_server ss("./socket");
	331
	332	ss.add_callback(connection_closed,bind(&test_callback::callback_func, boost::ref(*this), connection_closed, _1));
	333	ss.add_callback(connection_deleted,bind(&test_callback::callback_func, boost::ref(*this), connection_deleted, _1));
	334
	335	bool got_1=false;
	336
	337	for (int i=0; i < 5; i++)
	338	{
	339	ss.fill_buffer(500000);
	340
	341	string data;
	342	unsigned int cid;
	343	if(!got_1 && ss.get_packet(data,cid))
	344	{
	345	server_connection* con=ss.get_connection(cid);
	346	con->write("XYZ");
	347	got_1=true;
	348	// don't call get_packet anymore
	349	}
	350	ss.cleanup();
	351	}
	352	ss.cleanup();
	353
	354	CPPUNIT_ASSERT_EQUAL_MESSAGE("closed done",true,static_cast<bool>(callback_done[connection_closed]));
	355	CPPUNIT_ASSERT_EQUAL_MESSAGE("not deleted yet",false,static_cast<bool>(callback_done[connection_deleted]));
	356
	357	for (int i=0; i < 4; i++)
	358	{
	359	ss.fill_buffer(500000);
	360
	361	string data;
	362	unsigned int cid;
	363	ss.get_packet(data,cid);
	364	ss.cleanup();
	365	}
	366	ss.cleanup();
	367
	368	CPPUNIT_ASSERT_EQUAL_MESSAGE("closed done (2)",true,static_cast<bool>(callback_done[connection_closed]));
	369	CPPUNIT_ASSERT_EQUAL_MESSAGE("deleted done",true,static_cast<bool>(callback_done[connection_deleted]));
	370	}
	371	}
	372	}
	373
	374	void ClientConnClosedCallback()
	375	{
	376	switch(child_pid=fork())
	377	{
	378	case -1:
	379	{
	380	CPPUNIT_FAIL("fork error");
	381	break;
	382	}
	383	case 0:
	384	// child
	385	{
	386	try
	387	{
	388	socket_server ss("./socket");
	389
	390	// max 3 sec
	391	for (int i=0; i < 3; i++)
	392	{
	393	ss.fill_buffer(1000000);
	394
	395	string data;
	396	unsigned int cid;
	397	if(ss.get_packet(data,cid))
	398	break;
	399	}
	400	} catch(...)
	401	{
	402	std::cerr << "exception in child. ignoring\n";
	403	}
	404
	405	// don't call atexit and stuff
	406	_exit(0);
	407	}
	408
	409	default:
	410	// parent
	411	{
	412	string data;
	413	// wait till server is up
	414	sleep(1);
	415
	416	socket_client_connection sc("./socket");
	417
	418	sc.add_callback(connection_closed,bind(&test_callback::callback_func, boost::ref(*this), connection_closed, 0));
	419
	420	sc.write("ABC");
	421
	422	// wait half a sec
	423	sc.fill_buffer(500000);
	424	sc.get_packet(data);
	425
	426	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
	427	CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_closed]));
	428	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_deleted]));
	429	}
	430	}
	431	}
	432
	433	void ClientConnDeletedCallback()
	434	{
	435	switch(child_pid=fork())
	436	{
	437	case -1:
	438	{
	439	CPPUNIT_FAIL("fork error");
	440	break;
	441	}
	442	case 0:
	443	// child
	444	{
	445	try
	446	{
	447	socket_server ss("./socket");
	448
	449	// max 3 sec
	450	for (int i=0; i < 3; i++)
	451	{
	452	ss.fill_buffer(1000000);
	453
	454	string data;
	455	unsigned int cid;
	456	if(ss.get_packet(data,cid))
	457	break;
	458	}
	459	} catch(...)
	460	{
	461	std::cerr << "exception in child. ignoring\n";
	462	}
	463
	464	// don't call atexit and stuff
	465	_exit(0);
	466	}
	467
	468	default:
	469	// parent
	470	{
	471	string data;
	472	// wait till server is up
	473	sleep(1);
	474
	475	{
	476	socket_client_connection sc("./socket");
	477
	478	sc.add_callback(connection_deleted,bind(&test_callback::callback_func, boost::ref(*this), connection_deleted, 0));
	479
	480	sc.write("ABC");
	481
	482	// wait half a sec
	483	sc.fill_buffer(500000);
	484	sc.get_packet(data);
	485	}
	486
	487	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[new_connection]));
	488	CPPUNIT_ASSERT_EQUAL(false,static_cast<bool>(callback_done[connection_closed]));
	489	CPPUNIT_ASSERT_EQUAL(true,static_cast<bool>(callback_done[connection_deleted]));
	490	}
	491	}
	492	}
	493	};
	494
	495	CPPUNIT_TEST_SUITE_REGISTRATION(test_callback);