1 /* ****************************************************************
3 * Copyright 2014 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 ******************************************************************/
21 #include "gtest/gtest.h"
22 #include "cainterface.h"
26 class CATests : public testing::Test {
28 virtual void SetUp() {
32 virtual void TearDown()
38 void request_handler(CAEndpoint_t* object, CARequestInfo_t* requestInfo);
39 void response_handler(CAEndpoint_t* object, CAResponseInfo_t* responseInfo);
40 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
41 CAResult_t checkGetNetworkInfo();
42 CAResult_t checkSelectNetwork();
44 void request_handler(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo)
49 void response_handler(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
54 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo)
56 if(!object || !errorInfo)
61 //error handling shall be added
65 static char* uri = NULL;
66 static CAEndpoint_t* tempRep = NULL;
67 static CARequestInfo_t requestInfo;
68 static CAInfo_t requestData;
69 static CAInfo_t responseData;
70 static CAResponseInfo_t responseInfo;
71 static CAToken_t tempToken = NULL;
72 static uint8_t tokenLength = CA_MAX_TOKEN_LEN;
73 static const char URI[] = "coap://10.11.12.13:4545/a/light";
74 static const char RESOURCE_URI[] = "/a/light";
76 static const char SECURE_INFO_DATA[] =
77 "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
78 "\"if\":[\"oc.mi.def\"],\"obs\":1,\"sec\":1,\"port\":%d}}]}";
79 static const char NORMAL_INFO_DATA[] =
80 "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
81 "\"if\":[\"oc.mi.def\"],\"obs\":1}}]}";
89 #define IDENTITY ("1111111111111111")
93 #define RS_CLIENT_PSK ("AAAAAAAAAAAAAAAA")
95 static CADtlsPskCredsBlob_t *pskCredsBlob = NULL;
97 void clearDtlsCredentialInfo()
99 printf("clearDtlsCredentialInfo IN\n");
102 // Initialize sensitive data to zeroes before freeing.
103 memset(pskCredsBlob->creds, 0, sizeof(OCDtlsPskCreds) * (pskCredsBlob->num));
104 free(pskCredsBlob->creds);
106 memset(pskCredsBlob, 0, sizeof(CADtlsPskCredsBlob_t));
110 printf("clearDtlsCredentialInfo OUT\n");
113 // Internal API. Invoked by OC stack to retrieve credentials from this module
114 void CAGetDtlsPskCredentials(CADtlsPskCredsBlob_t **credInfo)
116 printf("CAGetDtlsPskCredentials IN\n");
118 if (pskCredsBlob != NULL)
120 *credInfo = pskCredsBlob;
123 printf("CAGetDtlsPskCredentials OUT\n");
126 int32_t SetCredentials()
128 printf("SetCredentials IN\n");
129 pskCredsBlob = (CADtlsPskCredsBlob_t *)malloc(sizeof(CADtlsPskCredsBlob_t));
131 memset(pskCredsBlob, 0x0, sizeof(CADtlsPskCredsBlob_t));
132 memcpy(pskCredsBlob->identity, IDENTITY, DTLS_PSK_ID_LEN);
134 pskCredsBlob->num = 1;
136 pskCredsBlob->creds = (OCDtlsPskCreds *)malloc(sizeof(OCDtlsPskCreds) * (pskCredsBlob->num));
138 memcpy(pskCredsBlob->creds[0].id, IDENTITY, DTLS_PSK_ID_LEN);
139 memcpy(pskCredsBlob->creds[0].psk, RS_CLIENT_PSK, DTLS_PSK_PSK_LEN);
141 printf("SetCredentials OUT\n");
146 int main(int argc, char **argv)
148 testing::InitGoogleTest(&argc, argv);
149 return RUN_ALL_TESTS();
153 // check return value
154 TEST(InitializeTest, TC_01_Positive_01)
156 EXPECT_EQ(CA_STATUS_OK, CAInitialize());
161 TEST_F(CATests, TerminateTest)
165 char* check = (char *) "terminate success";
166 EXPECT_STREQ(check, "terminate success");
170 // CAStartListeningServer TC
171 // check return value
172 TEST(StartListeningServerTest, DISABLED_TC_03_Positive_01)
174 CASelectNetwork(CA_IPV4);
175 EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
178 // CAStartDiscoveryServer TC
179 // check return value
180 TEST(StartDiscoveryServerTest, DISABLED_TC_04_Positive_01)
182 EXPECT_EQ(CA_STATUS_OK, CAStartDiscoveryServer());
185 // CARegisterHandlerTest TC
186 // check return value
187 TEST_F(CATests, RegisterHandlerTest)
189 CARegisterHandler(request_handler, response_handler, error_handler);
190 char* check = (char *) "registerHandler success";
191 EXPECT_STREQ(check, "registerHandler success");
194 // CACreateRemoteEndpoint TC
195 // check return value
196 TEST_F(CATests, CreateRemoteEndpointTestGood)
200 EXPECT_EQ(CA_STATUS_OK, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep));
204 CADestroyEndpoint(tempRep);
209 // check remoteEndpoint and values of remoteEndpoint
210 TEST_F(CATests, CreateRemoteEndpointTestValues)
214 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
216 EXPECT_TRUE(tempRep != NULL);
220 CADestroyEndpoint(tempRep);
225 // check return value when uri is NULL
226 TEST_F(CATests, CreateRemoteEndpointTestBad)
230 EXPECT_EQ(CA_STATUS_FAILED, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep));
234 CADestroyEndpoint(tempRep);
240 // check return value
241 TEST_F(CATests, GenerateTokenTestGood)
243 EXPECT_EQ(CA_STATUS_OK, CAGenerateToken(&tempToken, tokenLength));
245 CADestroyToken(tempToken);
248 // check return value when CAGenerateToken is passed a NULL instead a valid pointer
249 TEST_F(CATests, GenerateTokenTestBad)
251 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CAGenerateToken(NULL, tokenLength));
255 // check destroyed token
256 TEST_F(CATests, DestroyTokenTest)
258 CAGenerateToken(&tempToken, tokenLength);
259 CADestroyToken(tempToken);
261 char * check = (char *) "destroy success";
262 EXPECT_STREQ(check, "destroy success");
266 // check return value
267 TEST(SendRequestTest, DISABLED_TC_16_Positive_01)
270 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
272 memset(&requestData, 0, sizeof(CAInfo_t));
273 CAGenerateToken(&tempToken, tokenLength);
274 requestData.token = tempToken;
275 requestData.tokenLength = tokenLength;
277 int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
278 requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
279 if(!requestData.payload)
281 CADestroyToken(tempToken);
282 FAIL() << "requestData.payload allocation failed";
284 snprintf(requestData.payload, length, NORMAL_INFO_DATA, "a/light");
285 requestData.type = CA_MSG_NONCONFIRM;
287 memset(&requestInfo, 0, sizeof(CARequestInfo_t));
288 requestInfo.method = CA_GET;
289 requestInfo.info = requestData;
291 EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
293 CADestroyToken(tempToken);
295 free(requestData.payload);
297 CADestroyEndpoint(tempRep);
302 // check return value when uri is NULL
303 TEST_F(CATests, SendRequestTestWithNullURI)
306 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
308 memset(&requestData, 0, sizeof(CAInfo_t));
309 CAGenerateToken(&tempToken, tokenLength);
310 requestData.token = tempToken;
311 requestData.tokenLength = tokenLength;
313 int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
314 requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
315 if(!requestData.payload)
317 CADestroyToken(tempToken);
318 FAIL() << "requestData.payload allocation failed";
320 snprintf(requestData.payload, length, NORMAL_INFO_DATA, "a/light");
321 requestData.type = CA_MSG_NONCONFIRM;
323 memset(&requestInfo, 0, sizeof(CARequestInfo_t));
324 requestInfo.method = CA_GET;
325 requestInfo.info = requestData;
327 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, &requestInfo));
329 CADestroyToken(tempToken);
331 free(requestData.payload);
335 CADestroyEndpoint(tempRep);
340 // check return value when a NULL is passed instead of a valid CARequestInfo_t address
341 TEST_F(CATests, SendRequestTestWithNullAddr)
344 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
346 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, NULL));
350 CADestroyEndpoint(tempRep);
356 // check return value
357 TEST(SendResponseTest, DISABLED_TC_19_Positive_01)
360 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
362 memset(&responseData, 0, sizeof(CAInfo_t));
363 responseData.type = CA_MSG_NONCONFIRM;
364 responseData.messageId = 1;
365 responseData.payload = (char *) "response payload";
367 CAGenerateToken(&tempToken, tokenLength);
368 requestData.token = tempToken;
369 requestData.tokenLength = tokenLength;
371 memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
372 responseInfo.result = CA_SUCCESS;
373 responseInfo.info = responseData;
375 EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
377 CADestroyToken(tempToken);
378 CADestroyEndpoint(tempRep);
382 // check return value when uri is NULL
383 TEST(SendResponseTest, DISABLED_TC_20_Negative_01)
386 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
388 memset(&responseData, 0, sizeof(CAInfo_t));
389 responseData.type = CA_MSG_NONCONFIRM;
390 responseData.messageId = 1;
391 responseData.payload = (char *) "response payload";
393 CAGenerateToken(&tempToken, tokenLength);
394 requestData.token = tempToken;
395 requestData.tokenLength = tokenLength;
397 memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
398 responseInfo.result = CA_SUCCESS;
399 responseInfo.info = responseData;
401 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, &responseInfo));
403 CADestroyToken(tempToken);
406 CADestroyEndpoint(tempRep);
411 // check return value NULL is passed instead of a valid CAResponseInfo_t address
412 TEST_F(CATests, SendResponseTest)
415 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
417 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, NULL));
421 CADestroyEndpoint(tempRep);
426 // CASendNotification TC
427 // check return value
428 TEST(SendNotificationTest, DISABLED_TC_22_Positive_01)
431 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
433 memset(&responseData, 0, sizeof(CAInfo_t));
434 responseData.type = CA_MSG_NONCONFIRM;
435 responseData.payload = (char *) "Temp Notification Data";
437 CAGenerateToken(&tempToken, tokenLength);
438 requestData.token = tempToken;
439 requestData.tokenLength = tokenLength;
441 memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
442 responseInfo.result = CA_SUCCESS;
443 responseInfo.info = responseData;
445 EXPECT_EQ(CA_STATUS_OK, CASendNotification(tempRep, &responseInfo));
447 CADestroyToken(tempToken);
450 CADestroyEndpoint(tempRep);
455 // check return value when uri is NULL
456 TEST_F(CATests, SendNotificationTest)
459 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, uri, 0, &tempRep);
461 memset(&responseData, 0, sizeof(CAInfo_t));
462 responseData.type = CA_MSG_NONCONFIRM;
463 responseData.payload = (char *) "Temp Notification Data";
465 CAGenerateToken(&tempToken, tokenLength);
466 requestData.token = tempToken;
467 requestData.tokenLength = tokenLength;
469 memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
470 responseInfo.result = CA_SUCCESS;
471 responseInfo.info = responseData;
473 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendNotification(tempRep, &responseInfo));
475 CADestroyToken(tempToken);
478 CADestroyEndpoint(tempRep);
483 // CASelectNewwork TC
484 // check return value
485 TEST_F(CATests, SelectNetworkTestGood)
487 CAResult_t res = checkSelectNetwork();
488 EXPECT_EQ(CA_STATUS_OK, res);
491 CAResult_t checkSelectNetwork()
493 CAResult_t res = CASelectNetwork(CA_ADAPTER_IP);
495 if (CA_STATUS_OK == res)
497 EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
500 if (CA_NOT_SUPPORTED == res)
502 EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(CA_ADAPTER_IP));
509 // check return value when selected network is disable
510 TEST_F(CATests, SelectNetworkTestBad)
512 //Select disable network
513 EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork(1000));
516 // check return value when selected network is disable
517 TEST_F(CATests, UnSelectNetworkTest)
519 //UnSelect disable network
520 EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(1000));
523 // CAHandlerRequestResponse TC
524 // check return value
525 TEST_F(CATests, HandlerRequestResponseTest)
527 EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
530 // CAGetNetworkInformation TC
531 // check return value
532 TEST_F (CATests, GetNetworkInformationTestGood)
534 EXPECT_EQ(CA_STATUS_OK, checkGetNetworkInfo());
537 TEST_F(CATests, RegisterDTLSCredentialsHandlerTest)
540 if (SetCredentials() == 0)
542 printf("SetCredentials failed\n");
545 EXPECT_EQ(CA_STATUS_OK, CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials));
549 CAResult_t checkGetNetworkInfo()
551 CAEndpoint_t *tempInfo = NULL;
552 uint32_t tempSize = 0;
554 CAResult_t res = CAGetNetworkInformation(&tempInfo, &tempSize);
558 if (CA_STATUS_OK == res || CA_ADAPTER_NOT_ENABLED == res ||
559 CA_NOT_SUPPORTED == res)
565 return CA_STATUS_FAILED;