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     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
  80                 time_t t0 = time(NULL);
  81
  82                 // max 10 sec
  83                 while (time(NULL) < t0 + 10 )
  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
 112                 time_t t0 = time(NULL);
 113
 114                 // max 10 sec
 115                 while (time(NULL) < t0 + 10 )
 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
 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
 184                 time_t t0 = time(NULL);
 185
 186                 // max 10 sec
 187                 while (time(NULL) < t0 + 10 )
 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                 }
 204                 std::cerr << "child: OVER" << std::endl;
 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
 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);
 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         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
 290                 time_t t0 = time(NULL);
 291
 292                 // max 10 sec
 293                 while (time(NULL) < t0 + 10 )
 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);
 324                 socket_client_connection sc(6666);
 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
 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
 362                 time_t t0 = time(NULL);
 363
 364                 // max 10 sec
 365                 while (time(NULL) < t0 + 10 )
 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
 412 };
 413
 414 CPPUNIT_TEST_SUITE_REGISTRATION(test_comm);