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 "platform_features.h"
22 #include "gtest/gtest.h"
23 #include "cainterface.h"
24 #include "cautilinterface.h"
26 #include "oic_string.h"
28 #define CA_TRANSPORT_ADAPTER_SCOPE 1000
30 class CATests : public testing::Test {
37 virtual void TearDown()
43 void request_handler(CAEndpoint_t* object, CARequestInfo_t* requestInfo);
44 void response_handler(CAEndpoint_t* object, CAResponseInfo_t* responseInfo);
45 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
46 void adapter_handler(CATransportAdapter_t adapter, bool enabled);
47 void connection_handler(CATransportAdapter_t adapter, const char *remote_address, bool connected);
48 CAResult_t checkSelectNetwork();
50 void request_handler(const CAEndpoint_t * /*object*/,
51 const CARequestInfo_t * /*requestInfo*/)
56 void response_handler(const CAEndpoint_t * /*object*/,
57 const CAResponseInfo_t * /*responseInfo*/)
62 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo)
64 if(!object || !errorInfo)
69 //error handling shall be added
73 void adapter_handler(CATransportAdapter_t /*adapter*/,
78 void connection_handler(const CAEndpoint_t * /*endpoint*/,
83 static char* addr = NULL;
84 static CAEndpoint_t* tempRep = NULL;
85 static CARequestInfo_t requestInfo;
86 static CAInfo_t requestData;
87 static CAInfo_t responseData;
88 static CAResponseInfo_t responseInfo;
89 static CAToken_t tempToken = NULL;
90 static uint8_t tokenLength = CA_MAX_TOKEN_LEN;
91 static const char ADDRESS[] = "10.11.12.13";
92 static const uint16_t PORT = 4545;
94 static const char NORMAL_INFO_DATA[] =
95 "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
96 "\"if\":[\"oc.mi.def\"],\"obs\":1}}]}";
100 // Iotivity Device Identity.
101 const unsigned char IDENTITY[] = ("1111111111111111");
103 // PSK between this device and peer device.
104 const unsigned char RS_CLIENT_PSK[] = ("AAAAAAAAAAAAAAAA");
106 // Internal API. Invoked by CA stack to retrieve credentials from this module
107 int32_t CAGetDtlsPskCredentials( CADtlsPskCredType_t type,
108 const unsigned char *desc, size_t desc_len,
109 unsigned char *result, size_t result_length)
111 printf("CAGetDtlsPskCredentials IN\n");
122 case CA_DTLS_PSK_HINT:
123 case CA_DTLS_PSK_IDENTITY:
125 if (result_length < sizeof(IDENTITY))
127 printf("ERROR : Wrong value for result for storing IDENTITY");
131 memcpy(result, IDENTITY, sizeof(IDENTITY));
132 ret = sizeof(IDENTITY);
135 case CA_DTLS_PSK_KEY:
137 if ((desc_len == sizeof(IDENTITY)) &&
138 memcmp(desc, IDENTITY, sizeof(IDENTITY)) == 0)
140 if (result_length < sizeof(RS_CLIENT_PSK))
142 printf("ERROR : Wrong value for result for storing RS_CLIENT_PSK");
146 memcpy(result, RS_CLIENT_PSK, sizeof(RS_CLIENT_PSK));
147 ret = sizeof(RS_CLIENT_PSK);
153 printf("Wrong value passed for PSK_CRED_TYPE.");
158 printf("CAGetDtlsPskCredentials OUT\n");
161 #endif //__WITH_DTLS__
164 TEST(InitializeTest, CAInitializeTest)
166 EXPECT_EQ(CA_STATUS_OK, CAInitialize());
171 TEST_F(CATests, TerminateTest)
175 char* check = (char *) "terminate success";
176 EXPECT_STREQ(check, "terminate success");
181 // CAStartListeningServer TC
182 TEST_F(CATests, StartListeningServerTestWithNonSelect)
184 EXPECT_EQ(CA_STATUS_FAILED, CAStartListeningServer());
187 // CAStartListeningServer TC
188 TEST_F(CATests, StartListeningServerTest)
190 EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
191 EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
194 // CAStopListeningServer TC
195 TEST_F(CATests, CAStopListeningServerTestWithNonSelect)
197 EXPECT_EQ(CA_STATUS_FAILED, CAStopListeningServer());
200 // CAStopListeningServer TC
201 TEST_F(CATests, CAStopListeningServerTest)
203 EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
204 EXPECT_EQ(CA_STATUS_OK, CAStopListeningServer());
207 // CARegisterHandlerTest TC
208 TEST_F(CATests, RegisterHandlerTest)
210 CARegisterHandler(request_handler, response_handler, error_handler);
211 char* check = (char *) "registerHandler success";
212 EXPECT_STREQ(check, "registerHandler success");
215 // CACreateRemoteEndpoint TC
216 TEST_F(CATests, CreateRemoteEndpointTestGood)
218 addr = (char *) ADDRESS;
220 EXPECT_EQ(CA_STATUS_OK, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr,
223 CADestroyEndpoint(tempRep);
227 // check remoteEndpoint and values of remoteEndpoint
228 TEST_F(CATests, CreateRemoteEndpointTestValues)
230 addr = (char *) ADDRESS;
232 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
234 EXPECT_TRUE(tempRep != NULL);
236 CADestroyEndpoint(tempRep);
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");
265 TEST_F(CATests, SendRequestTestWithInvalidAddress)
267 CARegisterHandler(request_handler, response_handler, error_handler);
269 EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
270 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "10.11.13.13.14", PORT, &tempRep);
272 memset(&requestData, 0, sizeof(CAInfo_t));
273 CAGenerateToken(&tempToken, tokenLength);
274 requestData.token = tempToken;
275 requestData.tokenLength = tokenLength;
276 requestData.type = CA_MSG_CONFIRM;
278 memset(&requestInfo, 0, sizeof(CARequestInfo_t));
279 requestInfo.method = CA_GET;
280 requestInfo.info = requestData;
282 EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
284 CADestroyToken(tempToken);
285 CADestroyEndpoint(tempRep);
286 free(requestData.payload);
291 TEST(SendRequestTest, DISABLED_TC_16_Positive_01)
293 addr = (char *) ADDRESS;
294 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
296 memset(&requestData, 0, sizeof(CAInfo_t));
297 CAGenerateToken(&tempToken, tokenLength);
298 requestData.token = tempToken;
299 requestData.tokenLength = tokenLength;
301 int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
302 requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
303 if(!requestData.payload)
305 CADestroyToken(tempToken);
306 FAIL() << "requestData.payload allocation failed";
308 snprintf((char*)requestData.payload, length, NORMAL_INFO_DATA, "a/light");
309 requestData.payloadSize = length + 1;
310 requestData.type = CA_MSG_NONCONFIRM;
312 memset(&requestInfo, 0, sizeof(CARequestInfo_t));
313 requestInfo.method = CA_GET;
314 requestInfo.info = requestData;
316 EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
318 CADestroyToken(tempToken);
319 CADestroyEndpoint(tempRep);
320 free(requestData.payload);
324 // check return value when a NULL is passed instead of a valid CARequestInfo_t address
325 TEST_F(CATests, SendRequestTestWithNullAddr)
327 addr = (char *) ADDRESS;
328 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
330 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, NULL));
332 CADestroyEndpoint(tempRep);
336 TEST_F(CATests, SendResponseTestWithInvalidCode)
338 EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
340 addr = (char *) ADDRESS;
341 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
343 memset(&responseData, 0, sizeof(CAInfo_t));
344 responseData.type = CA_MSG_RESET;
345 responseData.messageId = 1;
346 responseData.payload = (CAPayload_t)malloc(sizeof("response payload"));
348 EXPECT_TRUE(responseData.payload != NULL);
350 if (responseData.payload)
352 CAGenerateToken(&tempToken, tokenLength);
353 requestData.token = tempToken;
354 requestData.tokenLength = tokenLength;
356 memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
357 responseInfo.result = CA_CONTENT;
358 responseInfo.info = responseData;
360 EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
362 CADestroyToken(tempToken);
363 CADestroyEndpoint(tempRep);
364 free(responseData.payload);
370 TEST(SendResponseTest, DISABLED_TC_19_Positive_01)
372 addr = (char *) ADDRESS;
373 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
375 memset(&responseData, 0, sizeof(CAInfo_t));
376 responseData.type = CA_MSG_NONCONFIRM;
377 responseData.messageId = 1;
378 responseData.payload = (CAPayload_t)malloc(sizeof("response payload"));
380 EXPECT_TRUE(responseData.payload != NULL);
381 if(!responseData.payload)
383 CADestroyEndpoint(tempRep);
387 memcpy(responseData.payload, "response payload", sizeof("response payload"));
388 responseData.payloadSize = sizeof("response payload");
390 CAGenerateToken(&tempToken, tokenLength);
391 requestData.token = tempToken;
392 requestData.tokenLength = tokenLength;
394 memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
395 responseInfo.result = CA_CONTENT;
396 responseInfo.info = responseData;
398 EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
400 CADestroyToken(tempToken);
401 CADestroyEndpoint(tempRep);
402 free(responseData.payload);
406 // check return value when address is NULL as multicast
407 TEST(SendResponseTest, DISABLED_TC_20_Negative_01)
410 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, 0, &tempRep);
412 memset(&responseData, 0, sizeof(CAInfo_t));
413 responseData.type = CA_MSG_NONCONFIRM;
414 responseData.messageId = 1;
415 responseData.payload = (CAPayload_t)malloc(sizeof("response payload"));
416 EXPECT_TRUE(responseData.payload != NULL);
418 if(!responseData.payload)
420 CADestroyEndpoint(tempRep);
424 memcpy(responseData.payload, "response payload", sizeof("response payload"));
425 responseData.payloadSize = sizeof("response payload");
427 CAGenerateToken(&tempToken, tokenLength);
428 requestData.token = tempToken;
429 requestData.tokenLength = tokenLength;
431 memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
432 responseInfo.result = CA_CONTENT;
433 responseInfo.info = responseData;
435 EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
437 CADestroyToken(tempToken);
438 CADestroyEndpoint(tempRep);
439 free (responseData.payload);
443 // check return value NULL is passed instead of a valid CAResponseInfo_t address
444 TEST_F(CATests, SendResponseTest)
446 addr = (char *) ADDRESS;
447 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
449 EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, NULL));
451 CADestroyEndpoint(tempRep);
455 // CASelectNewwork TC
456 TEST_F(CATests, SelectNetworkTestGood)
458 EXPECT_EQ(CA_STATUS_OK, checkSelectNetwork());
461 CAResult_t checkSelectNetwork()
463 CAResult_t res = CASelectNetwork(CA_ADAPTER_IP);
465 if (CA_STATUS_OK == res)
467 EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
470 if (CA_NOT_SUPPORTED == res)
472 EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(CA_ADAPTER_IP));
479 // check return value when selected network is disable
480 TEST_F(CATests, SelectNetworkTestBad)
482 //Select disable network
483 EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork((CATransportAdapter_t)
484 CA_TRANSPORT_ADAPTER_SCOPE));
487 // check return value when selected network is disable
488 TEST_F(CATests, UnSelectNetworkTest)
490 //UnSelect disable network
491 EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork((CATransportAdapter_t)
492 CA_TRANSPORT_ADAPTER_SCOPE));
495 // CAHandlerRequestResponse TC
496 TEST_F(CATests, HandlerRequestResponseTest)
498 EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
501 // CAGetNetworkInformation TC
502 TEST_F (CATests, GetNetworkInformationTest)
504 uint32_t tempSize = 0;
505 CAEndpoint_t *tempInfo = NULL;
507 EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
508 EXPECT_EQ(CA_STATUS_OK, CAGetNetworkInformation(&tempInfo, &tempSize));
513 TEST_F(CATests, RegisterDTLSCredentialsHandlerTest)
516 EXPECT_EQ(CA_STATUS_OK, CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials));
520 // CARegisterNetworkMonitorHandler TC
521 TEST_F(CATests, RegisterNetworkMonitorHandler)
523 EXPECT_EQ(CA_STATUS_OK, CARegisterNetworkMonitorHandler(adapter_handler,
524 connection_handler));
527 // CASetAutoConnectionDeviceInfo TC
528 TEST_F(CATests, SetAutoConnectionDeviceInfo)
530 addr = (char *) ADDRESS;
532 #if defined(__ANDROID__) && defined(LE_ADAPTER)
533 EXPECT_EQ(CA_STATUS_OK, CASetAutoConnectionDeviceInfo(addr));
535 EXPECT_EQ(CA_NOT_SUPPORTED, CASetAutoConnectionDeviceInfo(addr));
539 // CAUnsetAutoConnectionDeviceInfo TC
540 TEST_F(CATests, UnsetAutoConnectionDeviceInfo)
542 addr = (char *) ADDRESS;
544 #if defined(__ANDROID__) && defined(LE_ADAPTER)
545 EXPECT_EQ(CA_STATUS_OK, CAUnsetAutoConnectionDeviceInfo(addr));
547 EXPECT_EQ(CA_NOT_SUPPORTED, CAUnsetAutoConnectionDeviceInfo(addr));
551 TEST(CASetPortNumberTest, CASetPortNumberToAssign)
553 EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_IP, CA_IPV4, 5683));
554 EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_IP, CA_IPV6, 5683));
555 EXPECT_EQ(CA_STATUS_OK,
556 CASetPortNumberToAssign(CA_ADAPTER_IP,
557 static_cast<CATransportFlags_t>(CA_IPV4|CA_SECURE), 5683));
558 EXPECT_EQ(CA_STATUS_OK,
559 CASetPortNumberToAssign(CA_ADAPTER_IP,
560 static_cast<CATransportFlags_t>(CA_IPV6|CA_SECURE), 5683));
563 EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_TCP, CA_IPV4, 5683));
564 EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_TCP, CA_IPV6, 5683));
568 TEST(CAGetPortNumberTest, CAGetPortNumberToAssign)
570 ASSERT_EQ(static_cast<uint16_t>(0),
571 CAGetAssignedPortNumber(CA_ADAPTER_IP, CA_IPV4));
572 ASSERT_EQ(static_cast<uint16_t>(0),
573 CAGetAssignedPortNumber(CA_ADAPTER_IP, CA_IPV6));
574 ASSERT_EQ(static_cast<uint16_t>(0),
575 CAGetAssignedPortNumber(CA_ADAPTER_IP,
576 static_cast<CATransportFlags_t>(CA_IPV4|CA_SECURE)));
577 ASSERT_EQ(static_cast<uint16_t>(0),
578 CAGetAssignedPortNumber(CA_ADAPTER_IP,
579 static_cast<CATransportFlags_t>(CA_IPV6|CA_SECURE)));
581 ASSERT_EQ(static_cast<uint16_t>(0), CAGetAssignedPortNumber(CA_ADAPTER_TCP, CA_IPV4));
582 ASSERT_EQ(static_cast<uint16_t>(0), CAGetAssignedPortNumber(CA_ADAPTER_TCP, CA_IPV6));