[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
            {
                // wait till server is up
                sleep(1);
                socket_client_connection sc("./socket");
                sc.write("hello");
                // 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
            {
                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");
                    }
                }
                // 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
            {
                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;
                // 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
            {
                // wait till server is up
                sleep(1);
                socket_client_connection sc(6666);
                sc.write("hello");
                // 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
            {
                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");
                    }
                }
                // 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
            {
                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'));
                    }
                }
                // 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	{
	72	// wait till server is up
	73	sleep(1);
	74	socket_client_connection sc("./socket");
	75	sc.write("hello");
	76	// don't call atexit and stuff
	77	_exit(0);
	78	}
	79
	80	default:
	81	// parent
	82	{
	83	socket_server ss("./socket");
	84
d40453e8 RP	85	time_t t0 = time(NULL);
d40453e8 RP	86
07e98688	87	// max 10 sec
d40453e8	88	while (time(NULL) < t0 + 10 )
07e98688 GE	89	{
	90	ss.fill_buffer(1000000);
	91
	92	if(ss.get_packet(data))
	93	break;
	94	}
	95	}
	96	}
	97	CPPUNIT_ASSERT_EQUAL(string("hello"),data);
	98	}
	99
	100	void UnixCommToServerAndBack()
	101	{
b5922184	102	switch(child_pid=fork())
07e98688 GE	103	{
	104	case -1:
	105	{
	106	CPPUNIT_FAIL("fork error");
	107	break;
	108	}
	109	case 0:
	110	// child
	111	{
	112	socket_server ss("./socket");
	113	ss.set_logging(&cerr,debug);
	114
d40453e8 RP	115	time_t t0 = time(NULL);
d40453e8 RP	116
07e98688	117	// max 10 sec
d40453e8	118	while (time(NULL) < t0 + 10 )
07e98688 GE	119	{
	120	ss.fill_buffer(1000000);
	121
	122	string data;
	123	unsigned int cid;
	124
	125	if(ss.get_packet(data,cid))
	126	{
	127	server_connection* con=ss.get_connection(cid);
	128
	129	if (data=="QUIT")
	130	break;
	131
	132	if (data=="ABC")
	133	con->write("DEF");
	134	else
	135	con->write("xyz");
	136	}
	137	}
	138	// don't call atexit and stuff
	139	_exit(0);
	140	}
	141
	142	default:
	143	// parent
	144	{
	145	string data;
	146
	147	// wait till server is up
	148	sleep(1);
	149	socket_client_connection sc("./socket");
	150
	151	sc.write("ABC");
	152
	153	sc.fill_buffer(1000000);
	154	sc.get_packet(data);
	155
	156	CPPUNIT_ASSERT_EQUAL(string("DEF"),data);
	157
	158	sc.write("HAHA");
	159
	160	sc.fill_buffer(1000000);
	161	sc.get_packet(data);
	162
	163	CPPUNIT_ASSERT_EQUAL(string("xyz"),data);
	164
	165	sc.write("QUIT");
	166	}
	167	}
	168	}
	169
58b327c6 GE	170	void UnixCommToServerAndBackBig()
58b327c6 GE	171	{
b5922184	172	switch(child_pid=fork())
58b327c6 GE	173	{
	174	case -1:
	175	{
	176	CPPUNIT_FAIL("fork error");
	177	break;
	178	}
	179	case 0:
	180	// child
	181	{
	182	socket_server ss("./socket");
	183	ss.set_logging(&cerr,debug);
	184
d40453e8 RP	185	time_t t0 = time(NULL);
d40453e8 RP	186
58b327c6	187	// max 10 sec
d40453e8	188	while (time(NULL) < t0 + 10 )
58b327c6 GE	189	{
	190	ss.fill_buffer(1000000);
	191
	192	string data;
	193	unsigned int cid;
	194
	195	if(ss.get_packet(data,cid))
	196	{
	197	server_connection* con=ss.get_connection(cid);
	198
	199	if (data=="QUIT")
	200	break;
	201
	202	con->write(string().insert(0,100*1024,'y'));
	203	}
	204	}
d40453e8	205	std::cerr << "child: OVER" << std::endl;
58b327c6 GE	206	// don't call atexit and stuff
	207	_exit(0);
	208	}
	209
	210	default:
	211	// parent
	212	{
	213	string data;
	214
	215	// wait till server is up
	216	sleep(1);
	217	socket_client_connection sc("./socket");
	218
	219	sc.write(string().insert(0,100*1024,'x'));
	220
	221	while (!sc.get_packet(data))
	222	sc.fill_buffer(1000000);
	223
	224	CPPUNIT_ASSERT_EQUAL(string().insert(0,100*1024,'y'),data);
	225
	226	sc.write("QUIT");
	227	}
	228	}
	229	}
	230
cc68aabb GE	231	void IPCommToServer()
cc68aabb GE	232	{
cc68aabb GE	233	string data;
cc68aabb GE	234
b5922184	235	switch(child_pid=fork())
cc68aabb GE	236	{
	237	case -1:
	238	{
	239	CPPUNIT_FAIL("fork error");
	240	break;
	241	}
	242	case 0:
	243	// child
	244	{
	245	// wait till server is up
	246	sleep(1);
b604df5f	247	socket_client_connection sc(6666);
cc68aabb GE	248	sc.write("hello");
	249	// don't call atexit and stuff
	250	_exit(0);
	251	}
	252
	253	default:
	254	// parent
	255	{
	256	socket_server ss(6666);
	257
d40453e8 RP	258	time_t t0 = time(NULL);
d40453e8 RP	259
cc68aabb	260	// max 10 sec
d40453e8	261	while (time(NULL) < t0 + 10 )
cc68aabb GE	262	{
	263	ss.fill_buffer(1000000);
	264
	265	if(ss.get_packet(data))
	266	break;
	267	}
	268	}
	269	}
	270	CPPUNIT_ASSERT_EQUAL(string("hello"),data);
	271	}
	272
7087e187 GE	273	void IPCommToServerAndBack()
7087e187 GE	274	{
b5922184	275	switch(child_pid=fork())
7087e187 GE	276	{
	277	case -1:
	278	{
	279	CPPUNIT_FAIL("fork error");
	280	break;
	281	}
	282	case 0:
	283	// child
	284	{
	285	socket_server ss(6666);
	286	ss.set_logging(&cerr,debug);
	287
d40453e8 RP	288	time_t t0 = time(NULL);
d40453e8 RP	289
7087e187	290	// max 10 sec
d40453e8	291	while (time(NULL) < t0 + 10 )
7087e187 GE	292	{
	293	ss.fill_buffer(1000000);
	294
	295	string data;
	296	unsigned int cid;
	297
	298	if(ss.get_packet(data,cid))
	299	{
	300	server_connection* con=ss.get_connection(cid);
	301
	302	if (data=="QUIT")
	303	break;
	304
	305	if (data=="ABC")
	306	con->write("DEF");
	307	else
	308	con->write("xyz");
	309	}
	310	}
	311	// don't call atexit and stuff
	312	_exit(0);
	313	}
	314
	315	default:
	316	// parent
	317	{
	318	string data;
	319
	320	// wait till server is up
	321	sleep(1);
b604df5f	322	socket_client_connection sc(6666);
7087e187 GE	323	sc.write("ABC");
	324
	325	sc.fill_buffer(1000000);
	326	sc.get_packet(data);
	327
	328	CPPUNIT_ASSERT_EQUAL(string("DEF"),data);
	329
	330	sc.write("HAHA");
	331
	332	sc.fill_buffer(1000000);
	333	sc.get_packet(data);
	334
	335	CPPUNIT_ASSERT_EQUAL(string("xyz"),data);
	336
	337	sc.write("QUIT");
	338	}
	339	}
	340	}
	341
517d1214 RP	342
	343	void IPCommToServerAndBackBig()
	344	{
b5922184	345	switch(child_pid=fork())
517d1214 RP	346	{
	347	case -1:
	348	{
	349	CPPUNIT_FAIL("fork error");
	350	break;
	351	}
	352	case 0:
	353	// child
	354	{
	355	socket_server ss(6666);
	356	ss.set_logging(&cerr,debug);
	357
d40453e8 RP	358	time_t t0 = time(NULL);
d40453e8 RP	359
517d1214	360	// max 10 sec
d40453e8	361	while (time(NULL) < t0 + 10 )
517d1214 RP	362	{
	363	ss.fill_buffer(1000000);
	364
	365	string data;
	366	unsigned int cid;
	367
	368	if(ss.get_packet(data,cid))
	369	{
	370	server_connection* con=ss.get_connection(cid);
	371
	372	socket_handler* alias= dynamic_cast< socket_handler* >(con);
	373
	374	if (data=="QUIT")
	375	break;
	376
	377	alias->set_write_block_size( 4093 );
	378	con->write(string().insert(0,2048*1024,'y'));
	379	}
	380	}
	381	// don't call atexit and stuff
	382	_exit(0);
	383	}
	384
	385	default:
	386	// parent
	387	{
	388	string data;
	389
	390	// wait till server is up
	391	sleep(1);
	392	socket_client_connection sc(6666);
	393
	394	sc.write(string().insert(0,100*1024,'x'));
	395
	396	while (!sc.get_packet(data))
	397	sc.fill_buffer(1000000);
	398
	399	CPPUNIT_ASSERT_EQUAL(string().insert(0,2048*1024,'y'),data);
	400
	401	sc.write("QUIT");
	402	}
	403	}
	404	} // eo IPCommToServerAndBackBig()
07e98688 GE	405	};
	406
	407	CPPUNIT_TEST_SUITE_REGISTRATION(test_comm);