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
  13 #include <iostream>
  14 #include <string>
  15 #include <sstream>
  16 #include <stdexcept>
  17
  18 #include <cppunit/extensions/TestFactoryRegistry.h>
  19 #include <cppunit/ui/text/TestRunner.h>
  20 #include <cppunit/extensions/HelperMacros.h>
  21
  22 #include <socket_client.hxx>
  23 #include <socket_server.hxx>
  24
  25 using namespace std;
  26 using namespace libt2n;
  27 using namespace CppUnit;
  28
  29 class test_comm : public TestFixture
  30 {
  31     CPPUNIT_TEST_SUITE(test_comm);
  32
  33     CPPUNIT_TEST(UnixCommToServer);
  34     CPPUNIT_TEST(UnixCommToServerAndBack);
  35     CPPUNIT_TEST(UnixCommToServerAndBackBig);
  36     CPPUNIT_TEST(IPCommToServer);
  37     CPPUNIT_TEST(IPCommToServerAndBack);
  38
  39     CPPUNIT_TEST_SUITE_END();
  40
  41     public:
  42
  43     void setUp()
  44     { }
  45
  46     void tearDown()
  47     { }
  48
  49     void UnixCommToServer()
  50     {
  51         pid_t pid;
  52         string data;
  53
  54         switch(pid=fork())
  55         {
  56             case -1:
  57             {
  58                 CPPUNIT_FAIL("fork error");
  59                 break;
  60             }
  61             case 0:
  62             // child
  63             {
  64                 // wait till server is up
  65                 sleep(1);
  66                 socket_client_connection sc("./socket");
  67                 sc.write("hello");
  68                 // don't call atexit and stuff
  69                 _exit(0);
  70             }
  71
  72             default:
  73             // parent
  74             {
  75                 socket_server ss("./socket");
  76
  77                 // max 10 sec
  78                 for (int i=0; i < 10; i++)
  79                 {
  80                     ss.fill_buffer(1000000);
  81
  82                     if(ss.get_packet(data))
  83                         break;
  84                 }
  85             }
  86         }
  87         CPPUNIT_ASSERT_EQUAL(string("hello"),data);
  88     }
  89
  90     void UnixCommToServerAndBack()
  91     {
  92         pid_t pid;
  93
  94         switch(pid=fork())
  95         {
  96             case -1:
  97             {
  98                 CPPUNIT_FAIL("fork error");
  99                 break;
 100             }
 101             case 0:
 102             // child
 103             {
 104                 socket_server ss("./socket");
 105                 ss.set_logging(&cerr,debug);
 106
 107                 // max 10 sec
 108                 for (int i=0; i < 10; i++)
 109                 {
 110                     ss.fill_buffer(1000000);
 111
 112                     string data;
 113                     unsigned int cid;
 114
 115                     if(ss.get_packet(data,cid))
 116                     {
 117                         server_connection* con=ss.get_connection(cid);
 118
 119                         if (data=="QUIT")
 120                             break;
 121
 122                         if (data=="ABC")
 123                             con->write("DEF");
 124                         else
 125                             con->write("xyz");
 126                     }
 127                 }
 128                 // don't call atexit and stuff
 129                 _exit(0);
 130             }
 131
 132             default:
 133             // parent
 134             {
 135                 string data;
 136
 137                 // wait till server is up
 138                 sleep(1);
 139                 socket_client_connection sc("./socket");
 140
 141                 sc.write("ABC");
 142
 143                 sc.fill_buffer(1000000);
 144                 sc.get_packet(data);
 145
 146                 CPPUNIT_ASSERT_EQUAL(string("DEF"),data);
 147
 148                 sc.write("HAHA");
 149
 150                 sc.fill_buffer(1000000);
 151                 sc.get_packet(data);
 152
 153                 CPPUNIT_ASSERT_EQUAL(string("xyz"),data);
 154
 155                 sc.write("QUIT");
 156             }
 157         }
 158     }
 159
 160     void UnixCommToServerAndBackBig()
 161     {
 162         pid_t pid;
 163
 164         switch(pid=fork())
 165         {
 166             case -1:
 167             {
 168                 CPPUNIT_FAIL("fork error");
 169                 break;
 170             }
 171             case 0:
 172             // child
 173             {
 174                 socket_server ss("./socket");
 175                 ss.set_logging(&cerr,debug);
 176
 177                 // max 10 sec
 178                 for (int i=0; i < 10; i++)
 179                 {
 180                     ss.fill_buffer(1000000);
 181
 182                     string data;
 183                     unsigned int cid;
 184
 185                     if(ss.get_packet(data,cid))
 186                     {
 187                         server_connection* con=ss.get_connection(cid);
 188
 189                         if (data=="QUIT")
 190                             break;
 191
 192                         con->write(string().insert(0,100*1024,'y'));
 193                     }
 194                 }
 195                 // don't call atexit and stuff
 196                 _exit(0);
 197             }
 198
 199             default:
 200             // parent
 201             {
 202                 string data;
 203
 204                 // wait till server is up
 205                 sleep(1);
 206                 socket_client_connection sc("./socket");
 207
 208                 sc.write(string().insert(0,100*1024,'x'));
 209
 210                 while (!sc.get_packet(data))
 211                     sc.fill_buffer(1000000);
 212
 213                 CPPUNIT_ASSERT_EQUAL(string().insert(0,100*1024,'y'),data);
 214
 215                 sc.write("QUIT");
 216             }
 217         }
 218     }
 219
 220     void IPCommToServer()
 221     {
 222         pid_t pid;
 223         string data;
 224
 225         switch(pid=fork())
 226         {
 227             case -1:
 228             {
 229                 CPPUNIT_FAIL("fork error");
 230                 break;
 231             }
 232             case 0:
 233             // child
 234             {
 235                 // wait till server is up
 236                 sleep(1);
 237                 socket_client_connection sc(6666);
 238                 sc.write("hello");
 239                 // don't call atexit and stuff
 240                 _exit(0);
 241             }
 242
 243             default:
 244             // parent
 245             {
 246                 socket_server ss(6666);
 247
 248                 // max 10 sec
 249                 for (int i=0; i < 10; i++)
 250                 {
 251                     ss.fill_buffer(1000000);
 252
 253                     if(ss.get_packet(data))
 254                         break;
 255                 }
 256             }
 257         }
 258         CPPUNIT_ASSERT_EQUAL(string("hello"),data);
 259     }
 260
 261     void IPCommToServerAndBack()
 262     {
 263         pid_t pid;
 264
 265         switch(pid=fork())
 266         {
 267             case -1:
 268             {
 269                 CPPUNIT_FAIL("fork error");
 270                 break;
 271             }
 272             case 0:
 273             // child
 274             {
 275                 socket_server ss(6666);
 276                 ss.set_logging(&cerr,debug);
 277
 278                 // max 10 sec
 279                 for (int i=0; i < 10; i++)
 280                 {
 281                     ss.fill_buffer(1000000);
 282
 283                     string data;
 284                     unsigned int cid;
 285
 286                     if(ss.get_packet(data,cid))
 287                     {
 288                         server_connection* con=ss.get_connection(cid);
 289
 290                         if (data=="QUIT")
 291                             break;
 292
 293                         if (data=="ABC")
 294                             con->write("DEF");
 295                         else
 296                             con->write("xyz");
 297                     }
 298                 }
 299                 // don't call atexit and stuff
 300                 _exit(0);
 301             }
 302
 303             default:
 304             // parent
 305             {
 306                 string data;
 307
 308                 // wait till server is up
 309                 sleep(1);
 310                 socket_client_connection sc(6666);
 311                 sc.write("ABC");
 312
 313                 sc.fill_buffer(1000000);
 314                 sc.get_packet(data);
 315
 316                 CPPUNIT_ASSERT_EQUAL(string("DEF"),data);
 317
 318                 sc.write("HAHA");
 319
 320                 sc.fill_buffer(1000000);
 321                 sc.get_packet(data);
 322
 323                 CPPUNIT_ASSERT_EQUAL(string("xyz"),data);
 324
 325                 sc.write("QUIT");
 326             }
 327         }
 328     }
 329
 330 };
 331
 332 CPPUNIT_TEST_SUITE_REGISTRATION(test_comm);