developer.intra2net.com Git - libt2n/blob - test/comm.cpp

   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>
  12 #include <time.h>
  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
  30
  31 class test_comm : public TestFixture
  32 {
  33     CPPUNIT_TEST_SUITE(test_comm);
  34
  35     CPPUNIT_TEST(UnixCommToServer);
  36     CPPUNIT_TEST(UnixCommToServerAndBack);
  37     CPPUNIT_TEST(UnixCommToServerAndBackBig);
  38     CPPUNIT_TEST(IPCommToServer);
  39     CPPUNIT_TEST(IPCommToServerAndBack);
  40     CPPUNIT_TEST(IPCommToServerAndBackBig);
  41
  42     CPPUNIT_TEST_SUITE_END();
  43
  44     pid_t child_pid;
  45
  46     public:
  47
  48     void setUp()
  49     { }
  50
  51     void tearDown()
  52     {
  53         // make sure the server-child is dead before the next test runs
  54         kill(child_pid,SIGKILL);
  55         sleep(1);
  56     }
  57
  58     void UnixCommToServer()
  59     {
  60         string data;
  61
  62         switch(child_pid=fork())
  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
  85                 time_t t0 = time(NULL);
  86
  87                 // max 10 sec
  88                 while (time(NULL) < t0 + 10 )
  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     {
 102         switch(child_pid=fork())
 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
 115                 time_t t0 = time(NULL);
 116
 117                 // max 10 sec
 118                 while (time(NULL) < t0 + 10 )
 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
 170     void UnixCommToServerAndBackBig()
 171     {
 172         switch(child_pid=fork())
 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
 185                 time_t t0 = time(NULL);
 186
 187                 // max 10 sec
 188                 while (time(NULL) < t0 + 10 )
 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                 }
 205                 std::cerr << "child: OVER" << std::endl;
 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
 231     void IPCommToServer()
 232     {
 233         string data;
 234
 235         switch(child_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);
 247                 socket_client_connection sc(6666);
 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
 258                 time_t t0 = time(NULL);
 259
 260                 // max 10 sec
 261                 while (time(NULL) < t0 + 10 )
 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
 273     void IPCommToServerAndBack()
 274     {
 275         switch(child_pid=fork())
 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
 288                 time_t t0 = time(NULL);
 289
 290                 // max 10 sec
 291                 while (time(NULL) < t0 + 10 )
 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);
 322                 socket_client_connection sc(6666);
 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
 342
 343     void IPCommToServerAndBackBig()
 344     {
 345         switch(child_pid=fork())
 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
 358                 time_t t0 = time(NULL);
 359
 360                 // max 10 sec
 361                 while (time(NULL) < t0 + 10 )
 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()
 405 };
 406
 407 CPPUNIT_TEST_SUITE_REGISTRATION(test_comm);