resource/csdk/connectivity/unittests/linux/sample1_unittest.cc

   1 #include "gtest/gtest.h"
   2 #include "cainterface.h"
   3 #include "cacommon.h"
   4 #include <string.h>
   5
   6 using namespace std;
   7
   8 void request_handler(CARemoteEndpoint_t* object, CARequestInfo_t* requestInfo);
   9 void response_handler(CARemoteEndpoint_t* object, CAResponseInfo_t* responseInfo);
  10
  11 void request_handler(CARemoteEndpoint_t* object, CARequestInfo_t* requestInfo)
  12 {
  13     cout << "request_handler, uri : " << (object != NULL) ? object->resourceUri : "";
  14     cout << ", data : " << (requestInfo != NULL) ? requestInfo->info.payload : "";
  15     cout << endl;
  16 }
  17
  18 void response_handler(CARemoteEndpoint_t* object, CAResponseInfo_t* responseInfo)
  19 {
  20     cout << "response_handler, uri : " << (object != NULL) ? object->resourceUri : "";
  21     cout << ", data : " << (responseInfo != NULL) ? responseInfo->info.payload : "";
  22     cout << endl;
  23 }
  24
  25 char* uri;
  26 CARemoteEndpoint_t* tempRep = NULL;
  27 CARequestInfo_t requestInfo;
  28 CAInfo_t responseData;
  29 CAResponseInfo_t responseInfo;
  30 CAToken_t tempToken;
  31
  32 int main(int argc, char **argv)
  33 {
  34     testing::InitGoogleTest(&argc, argv);
  35     return RUN_ALL_TESTS();
  36 }
  37
  38 // CAInitialize TC
  39 // check return value
  40 TEST(InitializeTest, TC_01_Positive_01)
  41 {
  42     EXPECT_EQ(CA_STATUS_OK, CAInitialize());
  43 }
  44
  45 //CATerminate TC
  46 TEST(TerminateTest, TC_02_Positive_01)
  47 {
  48     CATerminate();
  49
  50     char* check = (char *) "terminate success";
  51     EXPECT_STREQ(check, "terminate success");
  52
  53     CAInitialize();
  54 }
  55 // CAStartListeningServer TC
  56 // check return value
  57 TEST(StartListeningServerTest, TC_03_Positive_01)
  58 {
  59     CASelectNetwork(CA_WIFI);
  60     EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
  61 }
  62
  63 // CAStartDiscoveryServer TC
  64 // check return value
  65 TEST(StartDiscoveryServerTest, TC_04_Positive_01)
  66 {
  67     EXPECT_EQ(CA_STATUS_OK, CAStartDiscoveryServer());
  68 }
  69
  70 // CARegisterHandlerTest TC
  71 // check return value
  72 TEST(RegisterHandlerTest, TC_05_Positive_01)
  73 {
  74     CARegisterHandler(request_handler, response_handler);
  75 }
  76
  77 // CACreateRemoteEndpoint TC
  78 // check return value
  79 TEST(CreateRemoteEndpointTest, TC_06_Positive_01)
  80 {
  81     uri = (char *) "123.123.123.123:1234/b/light";
  82
  83     EXPECT_EQ(CA_STATUS_OK, CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep));
  84
  85     CADestroyRemoteEndpoint(tempRep);
  86 }
  87
  88 // check remoteEndpoint and values of remoteEndpoint
  89 TEST(CreateRemoteEndpointTest, TC_07_Positive_02)
  90 {
  91     uri = (char *) "123.123.123.123:1234/b/light";
  92     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
  93
  94     EXPECT_TRUE(tempRep != NULL);
  95
  96     if (tempRep != NULL)
  97     {
  98         EXPECT_STRNE(NULL, tempRep->resourceUri);
  99     }
 100
 101     CADestroyRemoteEndpoint(tempRep);
 102 }
 103
 104 // check return value if uri is NULL
 105 TEST(CreateRemoteEndpointTest, TC_08_Nagative_01)
 106 {
 107     uri = NULL;
 108
 109     EXPECT_EQ(CA_STATUS_FAILED, CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep));
 110
 111     CADestroyRemoteEndpoint(tempRep);
 112 }
 113
 114 // check values of remoteEndpoint if uri is NULL
 115 TEST(CreateRemoteEndpointTest, TC_09_Nagative_02)
 116 {
 117     uri = NULL;
 118     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 119
 120     if (tempRep != NULL)
 121     {
 122         EXPECT_STREQ(NULL, tempRep->resourceUri);
 123     }
 124
 125     CADestroyRemoteEndpoint(tempRep);
 126 }
 127
 128 // CADestroyRemoteEndpoint TC
 129 // check destroyed remoteEndpoint
 130 TEST(DestroyRemoteEndpointTest, TC_10_Positive_01)
 131 {
 132     uri = (char *) "123.123.123.123:1234/b/light";
 133     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 134
 135     CADestroyRemoteEndpoint(tempRep);
 136
 137     char * check = (char *) "destroy success";
 138     EXPECT_STREQ(check, "destroy success");
 139 }
 140
 141 // CAGerateToken TC
 142 // check return value
 143 TEST(GenerateTokenTest, TC_11_Positive_01)
 144 {
 145     EXPECT_EQ(CA_STATUS_OK, CAGenerateToken(&tempToken));
 146
 147     CADestroyToken(tempToken);
 148 }
 149
 150 // CADestroyToken TC
 151 // check destroyed token
 152 TEST(DestroyTokenTest, TC_12_Positive_01)
 153 {
 154     CAGenerateToken(&tempToken);
 155     CADestroyToken(tempToken);
 156
 157     char * check = (char *) "destroy success";
 158     EXPECT_STREQ(check, "destroy success");
 159 }
 160
 161 // CAFindResource TC
 162 // check return value
 163 TEST(FindResourceTest, TC_13_Positive_01)
 164 {
 165     CARegisterHandler(request_handler, response_handler);
 166     uri = (char *) "123.123.123.123:1234/b/light";
 167     EXPECT_EQ(CA_STATUS_OK, CAFindResource(uri));
 168 }
 169
 170 // check return value if uri is NULL
 171 TEST(FindResourceTest, TC_14_Nagative_01)
 172 {
 173     CARegisterHandler(request_handler, response_handler);
 174     uri = NULL;
 175     EXPECT_EQ(CA_STATUS_FAILED, CAFindResource(uri));
 176 }
 177
 178 // CASendRequest TC
 179 // check return value
 180 TEST(SendRequestTest, TC_15_Positive_01)
 181 {
 182     uri = (char *) "123.123.123.123:1234/b/light";
 183     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 184     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 185     CAGenerateToken(&tempToken);
 186     requestInfo.method = CA_GET;
 187     requestInfo.info.token = tempToken;
 188     requestInfo.info.payload = (char *) "request payload";
 189
 190     EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
 191
 192     CADestroyToken(tempToken);
 193     CADestroyRemoteEndpoint(tempRep);
 194 }
 195
 196 // check return value if uri is NULL
 197 TEST(SendRequestTest, TC_16_Nagative_01)
 198 {
 199     uri = NULL;
 200     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 201     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 202     CAGenerateToken(&tempToken);
 203     requestInfo.method = CA_GET;
 204     requestInfo.info.token = tempToken;
 205     requestInfo.info.payload = (char *) "request payload";
 206
 207     EXPECT_EQ(CA_STATUS_FAILED, CASendRequest(tempRep, &requestInfo));
 208
 209     CADestroyToken(tempToken);
 210     CADestroyRemoteEndpoint(tempRep);
 211 }
 212
 213 // CASendResponse TC
 214 // check return value
 215 TEST(SendResponseTest, TC_17_Positive_01)
 216 {
 217     uri = (char *) "123.123.123.123:1234/b/light";
 218     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 219
 220     memset(&responseData, 0, sizeof(CAInfo_t));
 221     CAGenerateToken(&tempToken);
 222     responseData.token = tempToken;
 223     responseData.payload = (char *) "response payload";
 224
 225     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 226     responseInfo.result = CA_VALID;
 227     responseInfo.info = responseData;
 228
 229     EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
 230
 231     CADestroyToken(tempToken);
 232     CADestroyRemoteEndpoint(tempRep);
 233 }
 234
 235 // check return value if uri is NULL
 236 TEST(SendResponseTest, TC_18_Nagative_01)
 237 {
 238     uri = NULL;
 239     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 240
 241     memset(&responseData, 0, sizeof(CAInfo_t));
 242     CAGenerateToken(&tempToken);
 243     responseData.token = tempToken;
 244     responseData.payload = (char *) "response payload";
 245
 246     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 247     responseInfo.result = CA_VALID;
 248     responseInfo.info = responseData;
 249
 250     EXPECT_EQ(CA_STATUS_FAILED, CASendResponse(tempRep, &responseInfo));
 251
 252     CADestroyToken(tempToken);
 253     CADestroyRemoteEndpoint(tempRep);
 254 }
 255
 256 // CASendNotification TC
 257 // check return value
 258 TEST(SendNotificationTest, TC_19_Positive_01)
 259 {
 260     uri = (char *) "123.123.123.123:1234/b/light";
 261     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 262
 263     memset(&responseData, 0, sizeof(CAInfo_t));
 264     responseData.token = (char *) "client token";
 265     responseData.payload = (char *) "Temp Notification Data";
 266
 267     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 268     responseInfo.result = CA_SUCCESS;
 269     responseInfo.info = responseData;
 270
 271     EXPECT_EQ(CA_STATUS_OK, CASendNotification(tempRep, &responseInfo));
 272
 273     CADestroyRemoteEndpoint(tempRep);
 274 }
 275
 276 // check return value if uri is NULL
 277 TEST(SendNotificationTest, TC_20_Nagative_01)
 278 {
 279     uri = NULL;
 280     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 281
 282     memset(&responseData, 0, sizeof(CAInfo_t));
 283     responseData.token = (char *) "client token";
 284     responseData.payload = (char *) "Temp Notification Data";
 285
 286     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 287     responseInfo.result = CA_SUCCESS;
 288     responseInfo.info = responseData;
 289
 290     EXPECT_EQ(CA_STATUS_FAILED, CASendNotification(tempRep, &responseInfo));
 291
 292     CADestroyRemoteEndpoint(tempRep);
 293 }
 294
 295 // CAAdvertiseResource TC
 296 // check return value
 297 TEST(AdvertiseResourceTest, TC_21_Positive_01)
 298 {
 299     uri = (char *) "123.123.123.123:1234/b/light";
 300     int optionNum = 1;
 301     char* optionData;
 302     CAHeaderOption_t* headerOpt;
 303     headerOpt = (CAHeaderOption_t*) malloc(sizeof(CAHeaderOption_t) * optionNum);
 304     memset(headerOpt, 0, sizeof(CAHeaderOption_t) * optionNum);
 305
 306     int i;
 307     for(i = 0 ; i < optionNum ; i++)
 308     {
 309         int optionID = 2;
 310         headerOpt[i].optionID = optionID;
 311         optionData = (char *) "aaa";
 312         memcpy(headerOpt[i].optionData, optionData, strlen(optionData));
 313         headerOpt[i].optionLength = (uint16_t)strlen(optionData);
 314     }
 315     EXPECT_EQ(CA_STATUS_OK, CAAdvertiseResource(uri, headerOpt, (uint8_t)optionNum));
 316 }
 317
 318 // check return value if uri is NULL
 319 TEST(AdvertiseResourceTest, TC_22_Nagative_01)
 320 {
 321     uri = NULL;
 322     int optionNum = 1;
 323     char* optionData;
 324     CAHeaderOption_t* headerOpt;
 325     headerOpt = (CAHeaderOption_t*) malloc(sizeof(CAHeaderOption_t) * optionNum);
 326     memset(headerOpt, 0, sizeof(CAHeaderOption_t) * optionNum);
 327
 328     int i;
 329     for(i = 0 ; i < optionNum ; i++)
 330     {
 331         int optionID = 2;
 332         headerOpt[i].optionID = optionID;
 333         optionData = (char *) "aaa";
 334         memcpy(headerOpt[i].optionData, optionData, strlen(optionData));
 335         headerOpt[i].optionLength = (uint16_t)strlen(optionData);
 336     }
 337     EXPECT_EQ(CA_STATUS_FAILED, CAAdvertiseResource(uri, headerOpt, (uint8_t)optionNum));
 338 }
 339
 340 // CASelectNewwork TC
 341 // check return value
 342 TEST(SelectNetworkTest, TC_23_Positive_01)
 343 {
 344     //Select wifi network
 345     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_WIFI));
 346 }
 347
 348 // check return value if selected network is disable
 349 TEST(SelectNetworkTest, TC_24_Nagative_01)
 350 {
 351     //Select disable network
 352     EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork(20));
 353 }
 354
 355 // CAUnSelectNewwork TC
 356 // check return value
 357 TEST(UnSelectNetworkTest, TC_25_Positive_01)
 358 {
 359     //Unselect wifi network
 360     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_WIFI));
 361 }
 362
 363 // check return value if selected network is disable
 364 TEST(UnSelectNetworkTest, TC_26_Nagative_01)
 365 {
 366     //UnSelect disable network
 367     EXPECT_EQ(CA_NOT_SUPPORTED, CAUnSelectNetwork(20));
 368 }
 369
 370 // CAHandlerRequestResponse TC
 371 // check return value
 372 TEST (HandlerRequestResponseTest, TC_27_Positive_01)
 373 {
 374     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 375 }
 376
 377
 378