AudioManagerDaemon/test/sockethandler/sockethandlerTest.cpp

   1 /*
   2  * sockethandlerTest.cpp
   3  *
   4  *  Created on: Dec 19, 2011
   5  *      Author: christian
   6  */
   7
   8 #include "sockethandlerTest.h"
   9 #include <stdio.h>
  10 #include <sys/socket.h> /* for socket(), connect(), (), and recv() */
  11 #include <arpa/inet.h>  /* for sockaddr_in and inet_addr() */
  12 #include <sys/ioctl.h>
  13 #include <string.h>
  14 #include <netdb.h>
  15 #include <fcntl.h>
  16 #include <sys/un.h>
  17
  18 #define SOCK_PATH "/tmp/mysock"
  19
  20 using namespace testing;
  21 using namespace am;
  22
  23 sockethandlerTest::sockethandlerTest()
  24 {
  25 }
  26
  27 sockethandlerTest::~sockethandlerTest()
  28 {
  29 }
  30
  31 am::timerCallBack::timerCallBack(SocketHandler *myHandler)
  32  :pTimer1Callback(this, &timerCallBack::timer1Callback),
  33   pTimer2Callback(this, &timerCallBack::timer2Callback),
  34   pTimer3Callback(this, &timerCallBack::timer3Callback),
  35   pTimer4Callback(this, &timerCallBack::timer4Callback),
  36   mSocketHandler(myHandler)
  37
  38 {
  39 }
  40
  41
  42
  43 am::timerCallBack::~timerCallBack()
  44 {
  45 }
  46
  47
  48
  49 void am::timerCallBack::timer1Callback(sh_timerHandle_t handle, void* userData)
  50 {
  51         std::cout<<"callback1 called"<<std::endl;
  52         timespec timeout;
  53         timeout.tv_nsec=0;
  54         timeout.tv_sec=1;
  55         shTimerCallBack *buf=&pTimer1Callback;
  56         sh_timerHandle_t handle_;
  57         mSocketHandler->addTimer(timeout,buf,handle_,NULL);
  58 }
  59
  60
  61
  62 void am::timerCallBack::timer2Callback(sh_timerHandle_t handle, void* userData)
  63 {
  64         std::cout<<"callback2 called"<<std::endl;
  65         timespec timeout;
  66         timeout.tv_nsec=0;
  67         timeout.tv_sec=1;
  68         shTimerCallBack *buf=&pTimer2Callback;
  69         sh_timerHandle_t handle_;
  70         mSocketHandler->addTimer(timeout,buf,handle_,NULL);
  71 }
  72
  73 void am::timerCallBack::timer3Callback(sh_timerHandle_t, void* userData)
  74 {
  75         std::cout<<"callback3 called"<<std::endl;
  76 }
  77
  78 void am::timerCallBack::timer4Callback(sh_timerHandle_t, void* userData)
  79 {
  80         std::cout<<"callback4 called"<<std::endl;
  81         mSocketHandler->stop_listening();
  82 }
  83
  84 void* playWithSocketServer(void* data)
  85 {
  86         SocketHandler myHandler;
  87         SamplePlugin myplugin(&myHandler);
  88         myHandler.start_listenting();
  89 }
  90
  91
  92
  93 TEST(sockethandlerTest,playWithSockets)
  94 {
  95         pthread_t serverThread;
  96         char buffer[3000];
  97         struct sockaddr_in servAddr;
  98         unsigned short servPort = 6060;
  99         struct hostent *host;
 100         int socket_;
 101
 102         //creates a thread that handles the serverpart
 103         pthread_create(&serverThread,NULL,playWithSocketServer,NULL);
 104
 105         sleep(1); //we need that here because the port needs to be opened
 106     if ((socket_ = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 107     {
 108         std::cout<<"socket problem"<<std::endl;
 109
 110     }
 111
 112     if ((host = (struct hostent*) gethostbyname("localhost")) == 0)
 113     {
 114         std::cout<<"ERROR: gethostbyname() failed\n"<<std::endl;
 115
 116     }
 117
 118     memset(&servAddr, 0, sizeof(servAddr));
 119     servAddr.sin_family      = AF_INET;
 120     servAddr.sin_addr.s_addr = inet_addr(inet_ntoa(*( struct in_addr*)( host -> h_addr_list[0])));
 121     servAddr.sin_port        = htons(servPort);
 122
 123     if (connect(socket_, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0)
 124     {
 125         std::cout<<"ERROR: connect() failed\n"<<std::endl;
 126     }
 127
 128         for (int i=0;i<=1000;i++)
 129         {
 130                 std::string string("Got It?");
 131                 send(socket_,string.c_str(),string.size(),0);
 132         }
 133         std::string string("finish!");
 134         send(socket_,string.c_str(),string.size(),0);
 135
 136         pthread_join(serverThread,NULL);
 137 }
 138
 139 TEST(sockethandlerTest,playWithTimers)
 140 {
 141         SocketHandler myHandler;
 142         timerCallBack testCallback(&myHandler);
 143         timespec timeoutTime, timeout2, timeout3, timeout4;
 144         timeoutTime.tv_sec=3;
 145         timeoutTime.tv_nsec=0;
 146         timeout2.tv_nsec=0;
 147         timeout2.tv_sec=1;
 148         timeout3.tv_nsec=000000000;
 149         timeout3.tv_sec=2;
 150         timeout4.tv_nsec=0;
 151         timeout4.tv_sec=13;
 152         shTimerCallBack* buf=&testCallback.pTimer1Callback;
 153         shTimerCallBack* buf2=&testCallback.pTimer2Callback;
 154         shTimerCallBack* buf3=&testCallback.pTimer3Callback;
 155         shTimerCallBack* buf4=&testCallback.pTimer4Callback;
 156         sh_timerHandle_t handle;
 157         myHandler.addTimer(timeoutTime,buf,handle,NULL);
 158         myHandler.addTimer(timeout2,buf2,handle,NULL);
 159         myHandler.addTimer(timeout3,buf3,handle,NULL);
 160         myHandler.addTimer(timeout4,buf4,handle,NULL);
 161         myHandler.start_listenting();
 162
 163 }
 164
 165 void sockethandlerTest::SetUp()
 166 {
 167 }
 168
 169 void sockethandlerTest::TearDown()
 170 {
 171 }
 172
 173 int main(int argc, char **argv)
 174 {
 175         ::testing::InitGoogleTest(&argc, argv);
 176         return RUN_ALL_TESTS();
 177 }
 178
 179 am::SamplePlugin::SamplePlugin(SocketHandler *mySocketHandler)
 180         :connectFiredCB(this,&SamplePlugin::connectSocket),
 181          receiveFiredCB(this,&SamplePlugin::receiveData),
 182          sampleDispatchCB(this,&SamplePlugin::dispatchData),
 183          sampleCheckCB(this,&SamplePlugin::check),
 184          mSocketHandler(mySocketHandler),
 185          mConnecthandle(),
 186          mReceiveHandle(),
 187          msgList()
 188 {
 189         int ret;
 190         int yes = 1;
 191
 192         struct sockaddr_in servAddr;
 193         unsigned int servPort = 6060;
 194         int socketHandle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 195     setsockopt(socketHandle, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
 196     memset(&servAddr, 0, sizeof(servAddr));
 197     servAddr.sin_family      = AF_INET;
 198     servAddr.sin_addr.s_addr = INADDR_ANY;
 199     servAddr.sin_port        = htons(servPort);
 200
 201     if (bind(socketHandle, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0)
 202     {
 203         std::cout<<"bind ok"<<std::endl;
 204     } /* if */
 205
 206     if (listen(socketHandle, 3) < 0)
 207     {
 208         std::cout<<"listen ok"<<std::endl;
 209     } /* if */
 210
 211     int a=1;
 212     ioctl (socketHandle, FIONBIO, (char *) &a);
 213     setsockopt (socketHandle, SOL_SOCKET, SO_KEEPALIVE, (char *) &a, sizeof (a));
 214
 215         short events=0;
 216         events |= POLLIN;
 217         mySocketHandler->addFDPoll(socketHandle,events,NULL,&connectFiredCB,NULL,NULL,NULL,mConnecthandle);
 218         std::cout<<"setup server - listening"<<std::endl;
 219 }
 220
 221
 222
 223 void am::SamplePlugin::connectSocket(const pollfd pollfd1, const sh_pollHandle_t handle, void *userData)
 224 {
 225         //first, accept the connection, create a new filedescriptor
 226         std::cout<<"Got a connection request !"<<std::endl;
 227         struct sockaddr answer;
 228         socklen_t len=sizeof(answer);
 229         int receiveFD = accept(pollfd1.fd, (struct sockaddr*)&answer, &len);
 230
 231         //set the correct event:
 232         short event = 0;
 233         event |=POLLIN;
 234
 235         //aded the filedescriptor to the sockethandler and register the callbacks for receiving the data
 236         mSocketHandler->addFDPoll(receiveFD,event,NULL,&receiveFiredCB,&sampleCheckCB,&sampleDispatchCB,NULL,mReceiveHandle);
 237
 238 }
 239
 240
 241
 242 void am::SamplePlugin::receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
 243 {
 244         //initialize buffer
 245         char buffer[10];
 246         //read until buffer is full or no more data is there
 247         int read=recv(pollfd.fd,buffer,7,NULL);
 248         if (read>1)
 249         {
 250                 //read the message and store it in a queue
 251                 std::string msg=std::string(buffer,read);
 252                 msgList.push(msg);
 253                 std::cout<<"Got a message !"<<std::endl;
 254         }
 255 }
 256
 257
 258
 259 bool am::SamplePlugin::dispatchData(const sh_pollHandle_t handle, void *userData)
 260 {
 261         //read data from the queue
 262         std::cout<<"Data:"<<msgList.front()<<std::endl;
 263
 264         //if the message was our finish message, we quit the poll loop
 265         if (msgList.front().compare("finish!")==0)
 266         {
 267                 mSocketHandler->stop_listening();
 268         }
 269         //remove the message from the queue and return false if there is no more message to read.
 270         msgList.pop();
 271         if (msgList.size()!=0) return true;
 272         return false;
 273 }
 274
 275 bool am::SamplePlugin::check(const sh_pollHandle_t handle, void *userData)
 276 {
 277         //checks if there is data to dispatch
 278         std::cout<<"check!:"<<std::endl;
 279         if (msgList.size()!=0) return true;
 280         return false;
 281 }
 282
 283
 284
 285
 286
 287
 288
 289