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

    public:

    void setUp()
    { }

    void tearDown()
    { }

    void UnixCommToServer()
    {
        pid_t pid;
        string data;

        switch(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()
    {
        pid_t pid;

        switch(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()
    {
        pid_t pid;

        switch(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()
    {
        pid_t pid;
        string data;

        switch(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()
    {
        pid_t pid;

        switch(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()
    {
        pid_t pid;

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