[libt2n] / test / comm.cpp

/***************************************************************************
 *   Copyright (C) 2004 by Intra2net AG                                    *
 *   info@intra2net.com                                                    *
 *                                                                         *
 ***************************************************************************/

#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>

#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_comm : public TestFixture
{
    CPPUNIT_TEST_SUITE(test_comm);

    CPPUNIT_TEST(UnixCommToServer);
    CPPUNIT_TEST(UnixCommToServerAndBack);
    CPPUNIT_TEST(UnixCommToServerAndBackBig);
    CPPUNIT_TEST(IPCommToServer);
    CPPUNIT_TEST(IPCommToServerAndBack);
    CPPUNIT_TEST(IPCommToServerAndBackBig);

    CPPUNIT_TEST_SUITE_END();

    pid_t child_pid;

    public:

    void setUp()
    { }

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

    void UnixCommToServer()
    {
        string data;

        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    // wait till server is up
                    sleep(1);
                    socket_client_connection sc("./socket");
                    sc.write("hello");
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

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

                time_t t0 = time(NULL);

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

                    if(ss.get_packet(data))
                        break;
                }
            }
        }
        CPPUNIT_ASSERT_EQUAL(string("hello"),data);
    }

    void UnixCommToServerAndBack()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    socket_server ss("./socket");
                    ss.set_logging(&cerr,debug);

                    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=="ABC")
                                con->write("DEF");
                            else
                                con->write("xyz");
                        }
                    }
                } 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.write("ABC");

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

                CPPUNIT_ASSERT_EQUAL(string("DEF"),data);

                sc.write("HAHA");

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

                CPPUNIT_ASSERT_EQUAL(string("xyz"),data);

                sc.write("QUIT");
            }
        }
    }

    void UnixCommToServerAndBackBig()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    socket_server ss("./socket");
                    ss.set_logging(&cerr,debug);

                    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;

                            con->write(string().insert(0,100*1024,'y'));
                        }
                    }
                    std::cerr << "child: OVER" << std::endl;
                } 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.write(string().insert(0,100*1024,'x'));

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

                CPPUNIT_ASSERT_EQUAL(string().insert(0,100*1024,'y'),data);

                sc.write("QUIT");
            }
        }
    }

    void IPCommToServer()
    {
        string data;

        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    // wait till server is up
                    sleep(1);
                    socket_client_connection sc(6666);
                    sc.write("hello");
                } catch(...)
                {
                    std::cerr << "exception in child. ignoring\n";
                }

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

            default:
            // parent
            {
                socket_server ss(6666);

                time_t t0 = time(NULL);

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

                    if(ss.get_packet(data))
                        break;
                }
            }
        }
        CPPUNIT_ASSERT_EQUAL(string("hello"),data);
    }

    void IPCommToServerAndBack()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    socket_server ss(6666);
                    ss.set_logging(&cerr,debug);

                    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=="ABC")
                                con->write("DEF");
                            else
                                con->write("xyz");
                        }
                    }
                } 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(6666);
                sc.write("ABC");

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

                CPPUNIT_ASSERT_EQUAL(string("DEF"),data);

                sc.write("HAHA");

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

                CPPUNIT_ASSERT_EQUAL(string("xyz"),data);

                sc.write("QUIT");
            }
        }
    }


    void IPCommToServerAndBackBig()
    {
        switch(child_pid=fork())
        {
            case -1:
            {
                CPPUNIT_FAIL("fork error");
                break;
            }
            case 0:
            // child
            {
                try
                {
                    socket_server ss(6666);
                    ss.set_logging(&cerr,debug);

                    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);

                            socket_handler* alias= dynamic_cast< socket_handler* >(con);

                            if (data=="QUIT")
                                break;

                            alias->set_write_block_size( 4093 );
                            con->write(string().insert(0,2048*1024,'y'));
                        }
                    }
                } 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(6666);

                sc.write(string().insert(0,100*1024,'x'));

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

                CPPUNIT_ASSERT_EQUAL(string().insert(0,2048*1024,'y'),data);

                sc.write("QUIT");
            }
        }
    } // eo IPCommToServerAndBackBig()
};

CPPUNIT_TEST_SUITE_REGISTRATION(test_comm);
Commit	Line	Data
07e98688 GE	1	/***************************************************************************
	2	* Copyright (C) 2004 by Intra2net AG *
	3	* info@intra2net.com *
	4	* *
	5	***************************************************************************/
	6
	7	#include <sys/types.h>
	8	#include <unistd.h>
	9	#include <errno.h>
	10	#include <signal.h>
	11	#include <stdio.h>
d40453e8	12	#include <time.h>
07e98688 GE	13
	14	#include <iostream>
	15	#include <string>
	16	#include <sstream>
	17	#include <stdexcept>
	18
	19	#include <cppunit/extensions/TestFactoryRegistry.h>
	20	#include <cppunit/ui/text/TestRunner.h>
	21	#include <cppunit/extensions/HelperMacros.h>
	22
	23	#include <socket_client.hxx>
	24	#include <socket_server.hxx>
	25
	26	using namespace std;
	27	using namespace libt2n;
	28	using namespace CppUnit;
	29
517d1214	30
07e98688 GE	31	class test_comm : public TestFixture
	32	{
	33	CPPUNIT_TEST_SUITE(test_comm);
	34
	35	CPPUNIT_TEST(UnixCommToServer);
	36	CPPUNIT_TEST(UnixCommToServerAndBack);
58b327c6	37	CPPUNIT_TEST(UnixCommToServerAndBackBig);
cc68aabb	38	CPPUNIT_TEST(IPCommToServer);
7087e187	39	CPPUNIT_TEST(IPCommToServerAndBack);
517d1214	40	CPPUNIT_TEST(IPCommToServerAndBackBig);
07e98688 GE	41
	42	CPPUNIT_TEST_SUITE_END();
	43
b5922184 GE	44	pid_t child_pid;
b5922184 GE	45
07e98688 GE	46	public:
	47
	48	void setUp()
	49	{ }
	50
	51	void tearDown()
b5922184 GE	52	{
	53	// make sure the server-child is dead before the next test runs
	54	kill(child_pid,SIGKILL);
	55	sleep(1);
	56	}
07e98688 GE	57
	58	void UnixCommToServer()
	59	{
07e98688 GE	60	string data;
07e98688 GE	61
b5922184	62	switch(child_pid=fork())
07e98688 GE	63	{
	64	case -1:
	65	{
	66	CPPUNIT_FAIL("fork error");
	67	break;
	68	}
	69	case 0:
	70	// child
	71	{
441d41fe TJ	72	try
	73	{
	74	// wait till server is up
	75	sleep(1);
	76	socket_client_connection sc("./socket");
	77	sc.write("hello");
	78	} catch(...)
	79	{
	80	std::cerr << "exception in child. ignoring\n";
	81	}
	82
07e98688 GE	83	// don't call atexit and stuff
	84	_exit(0);
	85	}
	86
	87	default:
	88	// parent
	89	{
	90	socket_server ss("./socket");
	91
d40453e8 RP	92	time_t t0 = time(NULL);
d40453e8 RP	93
07e98688	94	// max 10 sec
d40453e8	95	while (time(NULL) < t0 + 10 )
07e98688 GE	96	{
	97	ss.fill_buffer(1000000);
	98
	99	if(ss.get_packet(data))
	100	break;
	101	}
	102	}
	103	}
	104	CPPUNIT_ASSERT_EQUAL(string("hello"),data);
	105	}
	106
	107	void UnixCommToServerAndBack()
	108	{
b5922184	109	switch(child_pid=fork())
07e98688 GE	110	{
	111	case -1:
	112	{
	113	CPPUNIT_FAIL("fork error");
	114	break;
	115	}
	116	case 0:
	117	// child
	118	{
441d41fe	119	try
07e98688	120	{
441d41fe TJ	121	socket_server ss("./socket");
441d41fe TJ	122	ss.set_logging(&cerr,debug);
07e98688	123
441d41fe	124	time_t t0 = time(NULL);
07e98688	125
441d41fe TJ	126	// max 10 sec
441d41fe TJ	127	while (time(NULL) < t0 + 10 )
07e98688	128	{
441d41fe	129	ss.fill_buffer(1000000);
07e98688	130
441d41fe TJ	131	string data;
441d41fe TJ	132	unsigned int cid;
07e98688	133
441d41fe TJ	134	if(ss.get_packet(data,cid))
	135	{
	136	server_connection* con=ss.get_connection(cid);
	137
	138	if (data=="QUIT")
	139	break;
	140
	141	if (data=="ABC")
	142	con->write("DEF");
	143	else
	144	con->write("xyz");
	145	}
07e98688	146	}
441d41fe TJ	147	} catch(...)
	148	{
	149	std::cerr << "exception in child. ignoring\n";
07e98688	150	}
441d41fe	151
07e98688 GE	152	// don't call atexit and stuff
	153	_exit(0);
	154	}
	155
	156	default:
	157	// parent
	158	{
	159	string data;
	160
	161	// wait till server is up
	162	sleep(1);
	163	socket_client_connection sc("./socket");
	164
	165	sc.write("ABC");
	166
	167	sc.fill_buffer(1000000);
	168	sc.get_packet(data);
	169
	170	CPPUNIT_ASSERT_EQUAL(string("DEF"),data);
	171
	172	sc.write("HAHA");
	173
	174	sc.fill_buffer(1000000);
	175	sc.get_packet(data);
	176
	177	CPPUNIT_ASSERT_EQUAL(string("xyz"),data);
	178
	179	sc.write("QUIT");
	180	}
	181	}
	182	}
	183
58b327c6 GE	184	void UnixCommToServerAndBackBig()
58b327c6 GE	185	{
b5922184	186	switch(child_pid=fork())
58b327c6 GE	187	{
	188	case -1:
	189	{
	190	CPPUNIT_FAIL("fork error");
	191	break;
	192	}
	193	case 0:
	194	// child
	195	{
441d41fe	196	try
58b327c6	197	{
441d41fe TJ	198	socket_server ss("./socket");
441d41fe TJ	199	ss.set_logging(&cerr,debug);
58b327c6	200
441d41fe	201	time_t t0 = time(NULL);
58b327c6	202
441d41fe TJ	203	// max 10 sec
441d41fe TJ	204	while (time(NULL) < t0 + 10 )
58b327c6	205	{
441d41fe	206	ss.fill_buffer(1000000);
58b327c6	207
441d41fe TJ	208	string data;
441d41fe TJ	209	unsigned int cid;
58b327c6	210
441d41fe TJ	211	if(ss.get_packet(data,cid))
	212	{
	213	server_connection* con=ss.get_connection(cid);
	214
	215	if (data=="QUIT")
	216	break;
	217
	218	con->write(string().insert(0,100*1024,'y'));
	219	}
58b327c6	220	}
441d41fe TJ	221	std::cerr << "child: OVER" << std::endl;
	222	} catch(...)
	223	{
	224	std::cerr << "exception in child. ignoring\n";
58b327c6	225	}
441d41fe	226
58b327c6 GE	227	// don't call atexit and stuff
	228	_exit(0);
	229	}
	230
	231	default:
	232	// parent
	233	{
	234	string data;
	235
	236	// wait till server is up
	237	sleep(1);
	238	socket_client_connection sc("./socket");
	239
	240	sc.write(string().insert(0,100*1024,'x'));
	241
	242	while (!sc.get_packet(data))
	243	sc.fill_buffer(1000000);
	244
	245	CPPUNIT_ASSERT_EQUAL(string().insert(0,100*1024,'y'),data);
	246
	247	sc.write("QUIT");
	248	}
	249	}
	250	}
	251
cc68aabb GE	252	void IPCommToServer()
cc68aabb GE	253	{
cc68aabb GE	254	string data;
cc68aabb GE	255
b5922184	256	switch(child_pid=fork())
cc68aabb GE	257	{
	258	case -1:
	259	{
	260	CPPUNIT_FAIL("fork error");
	261	break;
	262	}
	263	case 0:
	264	// child
	265	{
441d41fe TJ	266	try
	267	{
	268	// wait till server is up
	269	sleep(1);
	270	socket_client_connection sc(6666);
	271	sc.write("hello");
	272	} catch(...)
	273	{
	274	std::cerr << "exception in child. ignoring\n";
	275	}
	276
cc68aabb GE	277	// don't call atexit and stuff
	278	_exit(0);
	279	}
	280
	281	default:
	282	// parent
	283	{
	284	socket_server ss(6666);
	285
d40453e8 RP	286	time_t t0 = time(NULL);
d40453e8 RP	287
cc68aabb	288	// max 10 sec
d40453e8	289	while (time(NULL) < t0 + 10 )
cc68aabb GE	290	{
	291	ss.fill_buffer(1000000);
	292
	293	if(ss.get_packet(data))
	294	break;
	295	}
	296	}
	297	}
	298	CPPUNIT_ASSERT_EQUAL(string("hello"),data);
	299	}
	300
7087e187 GE	301	void IPCommToServerAndBack()
7087e187 GE	302	{
b5922184	303	switch(child_pid=fork())
7087e187 GE	304	{
	305	case -1:
	306	{
	307	CPPUNIT_FAIL("fork error");
	308	break;
	309	}
	310	case 0:
	311	// child
	312	{
441d41fe	313	try
7087e187	314	{
441d41fe TJ	315	socket_server ss(6666);
441d41fe TJ	316	ss.set_logging(&cerr,debug);
7087e187	317
441d41fe	318	time_t t0 = time(NULL);
7087e187	319
441d41fe TJ	320	// max 10 sec
441d41fe TJ	321	while (time(NULL) < t0 + 10 )
7087e187	322	{
441d41fe TJ	323	ss.fill_buffer(1000000);
	324
	325	string data;
	326	unsigned int cid;
7087e187	327
441d41fe TJ	328	if(ss.get_packet(data,cid))
	329	{
	330	server_connection* con=ss.get_connection(cid);
7087e187	331
441d41fe TJ	332	if (data=="QUIT")
	333	break;
	334
	335	if (data=="ABC")
	336	con->write("DEF");
	337	else
	338	con->write("xyz");
	339	}
7087e187	340	}
441d41fe TJ	341	} catch(...)
	342	{
	343	std::cerr << "exception in child. ignoring\n";
7087e187 GE	344	}
	345	// don't call atexit and stuff
	346	_exit(0);
	347	}
	348
	349	default:
	350	// parent
	351	{
	352	string data;
	353
	354	// wait till server is up
	355	sleep(1);
b604df5f	356	socket_client_connection sc(6666);
7087e187 GE	357	sc.write("ABC");
	358
	359	sc.fill_buffer(1000000);
	360	sc.get_packet(data);
	361
	362	CPPUNIT_ASSERT_EQUAL(string("DEF"),data);
	363
	364	sc.write("HAHA");
	365
	366	sc.fill_buffer(1000000);
	367	sc.get_packet(data);
	368
	369	CPPUNIT_ASSERT_EQUAL(string("xyz"),data);
	370
	371	sc.write("QUIT");
	372	}
	373	}
	374	}
	375
517d1214 RP	376
	377	void IPCommToServerAndBackBig()
	378	{
b5922184	379	switch(child_pid=fork())
517d1214 RP	380	{
	381	case -1:
	382	{
	383	CPPUNIT_FAIL("fork error");
	384	break;
	385	}
	386	case 0:
	387	// child
	388	{
441d41fe	389	try
517d1214	390	{
441d41fe TJ	391	socket_server ss(6666);
441d41fe TJ	392	ss.set_logging(&cerr,debug);
517d1214	393
441d41fe	394	time_t t0 = time(NULL);
517d1214	395
441d41fe TJ	396	// max 10 sec
441d41fe TJ	397	while (time(NULL) < t0 + 10 )
517d1214	398	{
441d41fe	399	ss.fill_buffer(1000000);
517d1214	400
441d41fe TJ	401	string data;
441d41fe TJ	402	unsigned int cid;
517d1214	403
441d41fe TJ	404	if(ss.get_packet(data,cid))
	405	{
	406	server_connection* con=ss.get_connection(cid);
517d1214	407
441d41fe TJ	408	socket_handler* alias= dynamic_cast< socket_handler* >(con);
	409
	410	if (data=="QUIT")
	411	break;
	412
	413	alias->set_write_block_size( 4093 );
	414	con->write(string().insert(0,2048*1024,'y'));
	415	}
517d1214	416	}
441d41fe TJ	417	} catch(...)
	418	{
	419	std::cerr << "exception in child. ignoring\n";
517d1214 RP	420	}
	421	// don't call atexit and stuff
	422	_exit(0);
	423	}
	424
	425	default:
	426	// parent
	427	{
	428	string data;
	429
	430	// wait till server is up
	431	sleep(1);
	432	socket_client_connection sc(6666);
	433
	434	sc.write(string().insert(0,100*1024,'x'));
	435
	436	while (!sc.get_packet(data))
	437	sc.fill_buffer(1000000);
	438
	439	CPPUNIT_ASSERT_EQUAL(string().insert(0,2048*1024,'y'),data);
	440
	441	sc.write("QUIT");
	442	}
	443	}
	444	} // eo IPCommToServerAndBackBig()
07e98688 GE	445	};
	446
	447	CPPUNIT_TEST_SUITE_REGISTRATION(test_comm);