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                 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
  83                 // don't call atexit and stuff
  84                 _exit(0);
  85             }
  86
  87             default:
  88             // parent
  89             {
  90                 socket_server ss("./socket");
  91
  92                 time_t t0 = time(NULL);
  93
  94                 // max 10 sec
  95                 while (time(NULL) < t0 + 10 )
  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     {
 109         switch(child_pid=fork())
 110         {
 111             case -1:
 112             {
 113                 CPPUNIT_FAIL("fork error");
 114                 break;
 115             }
 116             case 0:
 117             // child
 118             {
 119                 try
 120                 {
 121                     socket_server ss("./socket");
 122                     ss.set_logging(&cerr,debug);
 123
 124                     time_t t0 = time(NULL);
 125
 126                     // max 10 sec
 127                     while (time(NULL) < t0 + 10 )
 128                     {
 129                         ss.fill_buffer(1000000);
 130
 131                         string data;
 132                         unsigned int cid;
 133
 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                         }
 146                     }
 147                 } catch(...)
 148                 {
 149                     std::cerr << "exception in child. ignoring\n";
 150                 }
 151
 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
 184     void UnixCommToServerAndBackBig()
 185     {
 186         switch(child_pid=fork())
 187         {
 188             case -1:
 189             {
 190                 CPPUNIT_FAIL("fork error");
 191                 break;
 192             }
 193             case 0:
 194             // child
 195             {
 196                 try
 197                 {
 198                     socket_server ss("./socket");
 199                     ss.set_logging(&cerr,debug);
 200
 201                     time_t t0 = time(NULL);
 202
 203                     // max 10 sec
 204                     while (time(NULL) < t0 + 10 )
 205                     {
 206                         ss.fill_buffer(1000000);
 207
 208                         string data;
 209                         unsigned int cid;
 210
 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                         }
 220                     }
 221                     std::cerr << "child: OVER" << std::endl;
 222                 } catch(...)
 223                 {
 224                     std::cerr << "exception in child. ignoring\n";
 225                 }
 226
 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
 252     void IPCommToServer()
 253     {
 254         string data;
 255
 256         switch(child_pid=fork())
 257         {
 258             case -1:
 259             {
 260                 CPPUNIT_FAIL("fork error");
 261                 break;
 262             }
 263             case 0:
 264             // child
 265             {
 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
 277                 // don't call atexit and stuff
 278                 _exit(0);
 279             }
 280
 281             default:
 282             // parent
 283             {
 284                 socket_server ss(6666);
 285
 286                 time_t t0 = time(NULL);
 287
 288                 // max 10 sec
 289                 while (time(NULL) < t0 + 10 )
 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
 301     void IPCommToServerAndBack()
 302     {
 303         switch(child_pid=fork())
 304         {
 305             case -1:
 306             {
 307                 CPPUNIT_FAIL("fork error");
 308                 break;
 309             }
 310             case 0:
 311             // child
 312             {
 313                 try
 314                 {
 315                     socket_server ss(6666);
 316                     ss.set_logging(&cerr,debug);
 317
 318                     time_t t0 = time(NULL);
 319
 320                     // max 10 sec
 321                     while (time(NULL) < t0 + 10 )
 322                     {
 323                         ss.fill_buffer(1000000);
 324
 325                         string data;
 326                         unsigned int cid;
 327
 328                         if(ss.get_packet(data,cid))
 329                         {
 330                             server_connection* con=ss.get_connection(cid);
 331
 332                             if (data=="QUIT")
 333                                 break;
 334
 335                             if (data=="ABC")
 336                                 con->write("DEF");
 337                             else
 338                                 con->write("xyz");
 339                         }
 340                     }
 341                 } catch(...)
 342                 {
 343                     std::cerr << "exception in child. ignoring\n";
 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);
 356                 socket_client_connection sc(6666);
 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
 376
 377     void IPCommToServerAndBackBig()
 378     {
 379         switch(child_pid=fork())
 380         {
 381             case -1:
 382             {
 383                 CPPUNIT_FAIL("fork error");
 384                 break;
 385             }
 386             case 0:
 387             // child
 388             {
 389                 try
 390                 {
 391                     socket_server ss(6666);
 392                     ss.set_logging(&cerr,debug);
 393
 394                     time_t t0 = time(NULL);
 395
 396                     // max 10 sec
 397                     while (time(NULL) < t0 + 10 )
 398                     {
 399                         ss.fill_buffer(1000000);
 400
 401                         string data;
 402                         unsigned int cid;
 403
 404                         if(ss.get_packet(data,cid))
 405                         {
 406                             server_connection* con=ss.get_connection(cid);
 407
 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                         }
 416                     }
 417                 } catch(...)
 418                 {
 419                     std::cerr << "exception in child. ignoring\n";
 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()
 445 };
 446
 447 CPPUNIT_TEST_SUITE_REGISTRATION(test_comm);