Merge test folder of test branch
[iotivity.git] / test / src / tc / ca / gtest / src / btc / CATest.cpp
1 /******************************************************************
2 *
3 * Copyright 2016 Samsung Electronics All Rights Reserved.
4 *
5 *
6 *
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
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
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.
18 *
19 ******************************************************************/
20
21 #include "CAHelper.h"
22
23 class CATest_btc: public ::testing::Test
24 {
25 protected:
26     CAHelper m_caHelper;
27
28     virtual void SetUp()
29     {
30         CommonTestUtil::runCommonTCSetUpPart();
31     }
32
33     virtual void TearDown()
34     {
35         CommonTestUtil::runCommonTCTearDownPart();
36     }
37 };
38
39 /**
40  * @since 2014-11-28
41  * @see void CATerminate()
42  * @objective Test 'CAInitialize' positively to initialize CA module
43  * @target CAResult_t CAInitialize()
44  * @test_data none
45  * @pre_condition none
46  * @procedure call CAInitialize() API
47  * @post_condition Terminate CA using CATerminate() API
48  * @expected Initialization will succeed and return CA_STATUS_OK
49  */
50 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
51 TEST_F(CATest_btc , CAInitialize_P)
52 {
53     if (!m_caHelper.initialize())
54     {
55         SET_FAILURE(m_caHelper.getFailureMessage());
56         return;
57     }
58
59     CATerminate();
60 }
61 #endif
62
63 /**
64  * @since 2014-12-01
65  * @see CAResult_t CAInitialize()
66  * @see void CATerminate()
67  * @objective Test 'CARegisterHandler' positively to register request & response handlers
68  * @target void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler,
69  CAErrorCallback ErrorHandler)
70  * @test_data  1. A request handler
71  *             2. A response handler
72  *             2. A error handler
73  * @pre_condition Initialize CA using CAInitialize()
74  * @procedure call Call CARegisterHandler() API with request,response and error handlers as arguments
75  * @post_condition Terminate CA using CATerminate() API
76  * @expected CARegisterHandler() will register the handlers
77  */
78 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
79 TEST_F(CATest_btc , CARegisterHandler_P)
80 {
81     if (!m_caHelper.initialize())
82     {
83         SET_FAILURE(m_caHelper.getFailureMessage());
84         return;
85     }
86
87     CARegisterHandler(CAHelper::requestHandler, CAHelper::responseHandler, CAHelper::errorHandler);
88
89     CATerminate();
90 }
91 #endif
92
93 /**
94  * @since 2014-11-28
95  * @see void CADestroyToken(CAToken_t token)
96  * @objective Test 'CAGenerateToken' positively to generate a token
97  * @target CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
98  * @test_data a pointer of the type CAToken_t and token length
99  * @pre_condition none
100  * @procedure call the CAGenerateToken() API with passing a reference to the token and uint8_t length to tokenLength as argument
101  * @post_condition Destroy token using CADestroyToken.
102  * @expected 1. It will generate a token and return CA_STATUS_OK
103  *           2. Token variable is not NULL
104  */
105 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
106 TEST_F(CATest_btc , CAGenerateToken_P)
107 {
108     if (!m_caHelper.generateToken())
109     {
110         SET_FAILURE(m_caHelper.getFailureMessage());
111         CATerminate();
112         return;
113     }
114
115     m_caHelper.destroyToken();
116 }
117 #endif
118
119 /**
120  * @since 2016-02-18
121  * @see void CADestroyToken(CAToken_t token)
122  * @objective Test 'CAGenerateToken' positively with lower boundary value in Token Length parameter [LBV]
123  * @target CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
124  * @test_data Lower boundary value (1) as token length argument
125  * @pre_condition none
126  * @procedure Call CAGenerateToken with lower boundary value (1) as token length argument
127  * @post_condition Destroy token using CADestroyToken.
128  * @expected 1. It will generate a token and return CA_STATUS_OK
129  *           2. Token variable is not NULL
130  */
131 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
132 TEST_F(CATest_btc , CAGenerateToken_LBV_P)
133 {
134     CAToken_t token = NULL;
135     CAResult_t m_result = CAGenerateToken(&token, TOKEN_MIN_LENGTH );
136     if (token == NULL)
137     {
138         m_caHelper.m_failureMessage = "Failed to generate token.";
139         SET_FAILURE(m_caHelper.getFailureMessage());
140     }
141
142     if (m_result != CA_STATUS_OK)
143     {
144         SET_FAILURE(m_caHelper.getFailureMessage("CAGenerateToken", m_result, CA_STATUS_OK ));
145         return;
146     }
147
148     CADestroyToken(token);
149 }
150 #endif
151
152 /**
153  * @since 2015-02-17
154  * @see none
155  * @objective Test 'CAGenerateToken' negatively with out of lower bundary value in Token Length parameter [LOBV]
156  * @target CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
157  * @test_data out of lower bundary value as token length argument
158  * @pre_condition none
159  * @procedure Call CAGenerateToken with out of lower boundary value in token length parameter
160  * @post_condition none
161  * @expected It will return CA_STATUS_INVALID_PARAM
162  */
163 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
164 TEST_F(CATest_btc , CAGenerateToken_LOBV_N)
165 {
166     CAToken_t token = NULL;
167     CAResult_t result = CAGenerateToken(&token, TOKEN_LOBV_LENGTH);
168
169     if (result != CA_STATUS_INVALID_PARAM)
170     {
171         SET_FAILURE(m_caHelper.getFailureMessage());
172         IOTIVITYTEST_LOG(ERROR, "CAGenerateToken, Returned:  %s, Expected: %s", m_caHelper.getResultName(result), m_caHelper.getResultName(CA_STATUS_INVALID_PARAM));
173     }
174 }
175 #endif
176
177 /**
178  * @since 2015-02-17
179  * @see none
180  * @objective Test 'CAGenerateToken' negatively with out of upper boundary value in Token Length parameter [UOBV]
181  * @target CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
182  * @test_data out of upper boundary value as token length argument
183  * @pre_condition none
184  * @procedure Call CAGenerateToken with out of upper boundary value in token length parameter
185  * @post_condition none
186  * @expected It will return CA_STATUS_INVALID_PARAM
187  */
188 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
189 TEST_F(CATest_btc , CAGenerateToken_UOBV_N)
190 {
191     CAToken_t m_token = NULL;
192     CAResult_t m_result = CAGenerateToken(&m_token, TOKEN_UOBV_LENGTH);
193
194     if (m_result != CA_STATUS_INVALID_PARAM)
195     {
196         SET_FAILURE(m_caHelper.getFailureMessage());
197         IOTIVITYTEST_LOG(ERROR, "CAGenerateToken, Returned:  %s, Expected: %s", m_caHelper.getResultName(m_result), m_caHelper.getResultName(CA_STATUS_INVALID_PARAM));
198     }
199 }
200 #endif
201
202 /**
203  * @since 2016-02-18
204  * @see none
205  * @objective Test 'CAGenerateToken' negatively with passing invalid refrerence in token parameter [UFRV]
206  * @target CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
207  * @test_data Invalid reference as token argument
208  * @pre_condition none
209  * @procedure Call CAGenerateToken with unformatted reference value in token type parameter
210  * @post_condition none
211  * @expected It will not generate token & will return CA_STATUS_INVALID_PARAM
212  */
213 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
214 TEST_F(CATest_btc , CAGenerateToken_UFRV_N)
215 {
216     CAToken_t *m_token = NULL;
217     CAResult_t m_result = CAGenerateToken(m_token, TOKEN_MAX_LENGTH);
218
219     if (m_result != CA_STATUS_INVALID_PARAM)
220     {
221         SET_FAILURE(m_caHelper.getFailureMessage("CAGenerateToken", m_result, CA_STATUS_INVALID_PARAM));
222     }
223 }
224 #endif
225
226 /**
227  * @since 2014-12-02
228  * @see none
229  * @objective Test 'CAGenerateToken' negatively with passing NULL value as token argument
230  * @target CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
231  * @test_data NULL as token argument
232  * @pre_condition none
233  * @procedure Call CAGenerateToken with NULL value as token argument
234  * @post_condition none
235  * @expected It will return CA_STATUS_INVALID_PARAM
236  */
237 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
238 TEST_F(CATest_btc , CAGenerateToken_N)
239 {
240     if (!m_caHelper.generateToken(CA_STATUS_INVALID_PARAM))
241     {
242         SET_FAILURE(m_caHelper.getFailureMessage());
243     }
244 }
245 #endif
246
247 /**
248  * @since 2016-02-22
249  * @see CAResult_t CAInitialize()
250  * @see void CATerminate()
251  * @objective Test 'CASelectNetwork' positively with lower boundary value of selected network [LBV]
252  * @target CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
253  * @test_data lower boundary value as network argument
254  * @pre_condition Initialize CA using CAInitialize
255  * @procedure  1. Call CASelectNetwork using lower boundary value as network argument
256  *             2. Check it's return value
257  * @post_condition Terminate CA using CATerminate function
258  * @expected It will return CA_NOT_SUPPORTED
259  */
260 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
261 TEST_F(CATest_btc, CASelectNetwork_LBV_P)
262 {
263     if (!m_caHelper.initialize())
264     {
265         SET_FAILURE(m_caHelper.getFailureMessage());
266         return;
267     }
268
269     if (!m_caHelper.selectNetwork(CA_DEFAULT_ADAPTER, CA_NOT_SUPPORTED))
270     {
271         SET_FAILURE(m_caHelper.getFailureMessage());
272     }
273
274     CATerminate();
275 }
276 #endif
277
278 /**
279  * @since 2016-02-22
280  * @see CAResult_t CAInitialize()
281  * @see void CATerminate()
282  * @objective Test 'CASelectNetwork' positively with upper boundary value of selected network [UBV]
283  * @target CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
284  * @test_data upper boundary value as network argument
285  * @pre_condition Initialize CA using CAInitialize
286  * @procedure  1. Call CASelectNetwork using upper boundary value as network argument
287  *             2. Check it's return value
288  * @post_condition Terminate CA using CATerminate function
289  * @expected It will return CA_STATUS_OK
290  */
291 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
292 TEST_F(CATest_btc, CASelectNetwork_UBV_P)
293 {
294     if (!m_caHelper.initialize())
295     {
296         SET_FAILURE(m_caHelper.getFailureMessage());
297         return;
298     }
299
300     if (!m_caHelper.selectNetwork(CA_ALL_ADAPTERS, CA_STATUS_OK))
301     {
302         SET_FAILURE(m_caHelper.getFailureMessage());
303     }
304
305     CATerminate();
306 }
307 #endif
308
309 /**
310  * @since 2016-02-23
311  * @see CAResult_t CAInitialize()
312  * @see void CATerminate()
313  * @objective Test 'CASelectNetwork' negatively with out of lower boundary value of selected network [LOBV]
314  * @target CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
315  * @test_data out of lower boundary value as Network argument
316  * @pre_condition Initialize CA using CAInitialize
317  * @procedure  1. Call CASelectNetwork using out of lower boundary value as network argument
318  *             2. Check it's return value
319  * @post_condition Terminate CA using CATerminate function
320  * @expected It will return CA_NOT_SUPPORTED
321  */
322 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
323 TEST_F(CATest_btc, CASelectNetwork_LOBV_N)
324 {
325     if (!m_caHelper.initialize())
326     {
327         SET_FAILURE(m_caHelper.getFailureMessage());
328         return;
329     }
330
331     IOTIVITYTEST_LOG(DEBUG, "[CASelectNetwork] IN ");
332
333     m_caHelper.m_result = CASelectNetwork(CA_INVALID_ADAPTER);
334
335     if (m_caHelper.m_result != CA_NOT_SUPPORTED)
336     {
337         SET_FAILURE(m_caHelper.getFailureMessage("CASelectNetwork", m_caHelper.m_result, CA_NOT_SUPPORTED));
338     }
339
340     IOTIVITYTEST_LOG(DEBUG, "[CASelectNetwork] OUT ");
341
342     CATerminate();
343 }
344 #endif
345
346 /**
347  * @since 2016-02-23
348  * @see CAResult_t CAInitialize()
349  * @see void CATerminate()
350  * @objective Test 'CASelectNetwork' negatively with out of upper boundary value of selected network [UOBV]
351  * @target CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
352  * @test_data upper boundary value as network argument
353  * @pre_condition Initialize CA using CAInitialize
354  * @procedure  1. Call CASelectNetwork using out of upper boundary value as network argument
355  *             2. Check it's return value
356  * @post_condition Terminate CA using CATerminate function
357  * @expected It will return CA_NOT_SUPPORTED
358  */
359 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
360 TEST_F(CATest_btc, CASelectNetwork_UOBV_N)
361 {
362     if (!m_caHelper.initialize())
363     {
364         SET_FAILURE(m_caHelper.getFailureMessage());
365         return;
366     }
367
368     if (!m_caHelper.selectNetwork(CA_INVALID_UOBV_ADAPTER, CA_NOT_SUPPORTED))
369     {
370         SET_FAILURE(m_caHelper.getFailureMessage());
371     }
372
373     CATerminate();
374 }
375 #endif
376
377 /**
378  * @since 2014-12-04
379  * @see CAResult_t CAInitialize()
380  * @see void CATerminate()
381  * @objective Test 'CASelectNetwork' negatively to select invalid network
382  * @target CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
383  * @test_data invalid value for which network interface is not defined
384  * @pre_condition Initialize CA using CAInitialize
385  * @procedure  1. Call CASelectNetwork using invalid network value
386  *             2. Check it's return value
387  * @post_condition Terminate CA using CATerminate function
388  * @expected It will fail to select a network and will return CA_NOT_SUPPORTED
389  */
390 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
391 TEST_F(CATest_btc, CASelectNetwork_N)
392 {
393     if (!m_caHelper.initialize())
394     {
395         SET_FAILURE(m_caHelper.getFailureMessage());
396         return;
397     }
398
399     if (!m_caHelper.selectNetwork(NETWORK_OUT_OF_BOUNDARY_VALUE, CA_NOT_SUPPORTED))
400     {
401         SET_FAILURE(m_caHelper.getFailureMessage());
402     }
403
404     CATerminate();
405 }
406 #endif
407
408 /**
409  * @since 2016-02-23
410  * @see CAResult_t CAInitialize()
411  * @see CAResult_t CASelectNetwork(const uint32_t interestedNetwork)
412  * @see void CATerminate()
413  * @objective Test 'CAUnSelectNetwork' positively with upper boundary value of selected network [UBV]
414  * @target CAResult_t CAUnSelectNetwork(CATransportAdapter_t nonInterestedNetwork)
415  * @test_data upper boundary value as Network argument
416  * @pre_condition Initialize CA using CAInitialize
417  * @procedure  1. Call CASelectNetwork using upper boundary value as network argument
418  *             2. Check it's return value
419  *             3. Call CAUnselectNetwork using upper boundary value value as network argument
420  *             4. Check it's return value
421  * @post_condition Terminate CA using CATerminate function
422  * @expected It will unselect the network and will return CA_STATUS_OK
423  */
424 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
425 TEST_F(CATest_btc, CAUnSelectNetwork_UBV_P)
426 {
427     if (!m_caHelper.initialize())
428     {
429         SET_FAILURE(m_caHelper.getFailureMessage());
430         return;
431     }
432
433     if (!m_caHelper.selectNetwork(CA_ALL_ADAPTERS, CA_STATUS_OK))
434     {
435         SET_FAILURE(m_caHelper.getFailureMessage());
436         CATerminate();
437         return;
438     }
439
440     if (!m_caHelper.unselectNetwork(CA_ALL_ADAPTERS, CA_STATUS_OK))
441     {
442         SET_FAILURE(m_caHelper.getFailureMessage());
443     }
444
445     CATerminate();
446 }
447 #endif
448
449 /**
450  * @since 2014-11-28
451  * @see CAResult_t CAInitialize()
452  * @see void CATerminate()
453  * @objective Test 'CAUnSelectNetwork' negatively to un-select invalid network
454  * @target CAResult_t CAUnSelectNetwork(CATransportAdapter_t nonInterestedNetwork)
455  * @test_data invalid value for which adapter is not defined
456  * @pre_condition Initialize CA using CAInitialize
457  * @procedure  1. Call CAUnSelectNetwork with invalid adapter
458  *             2. Check it's return value
459  * @post_condition Terminate CA using CATerminate
460  * @expected It will fail to un-select the network and will return CA_STATUS_FAILED
461  */
462 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
463 TEST_F(CATest_btc, CAUnSelectNetwork_N)
464 {
465     if (!m_caHelper.initialize())
466     {
467         SET_FAILURE(m_caHelper.getFailureMessage());
468         return;
469     }
470
471     if (!m_caHelper.unselectNetwork(NETWORK_OUT_OF_BOUNDARY_VALUE, CA_STATUS_FAILED))
472     {
473         SET_FAILURE(m_caHelper.getFailureMessage());
474     }
475
476     CATerminate();
477 }
478 #endif
479
480 /**
481  * @since 2014-12-02
482  * @see CAResult_t CAInitialize()
483  * @see void CATerminate()
484  * @objective Test CAHandleRequestResponse() API positively
485  * @target CAResult_t CAHandleRequestResponse()
486  * @test_data none
487  * @pre_condition Initialize CA using CAInitialize()
488  * @procedure  1. Call CAHandleRequestResponse() API
489  *             2. Check it's return value
490  * @post_condition Terminate CA using CATerminate()
491  * @expected CAHandleRequestResponse() will return CA_STATUS_OK
492  */
493 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
494 TEST_F(CATest_btc , CAHandleRequestResponse_P)
495 {
496     if (!m_caHelper.initialize())
497     {
498         SET_FAILURE(m_caHelper.getFailureMessage());
499         return;
500     }
501
502     CAResult_t result = CAHandleRequestResponse();
503     if (result != CA_STATUS_OK)
504     {
505         SET_FAILURE(m_caHelper.getFailureMessage("CAHandleRequestResponse", result, CA_STATUS_OK));
506     }
507
508     CATerminate();
509 }
510 #endif
511
512 /**
513  * @since 2016-02-23
514  * @see CAResult_t CAInitialize()
515  * @see void CATerminate()
516  * @objective Test 'CAStartListeningServer' without selecting a network [ECRC]
517  * @target CAResult_t CAStartListeningServer()
518  * @test_data none
519  * @pre_condition  1. Initialize CA using CAInitialize
520  *                 2. Do not select network
521  * @procedure  1. Call CAStartListeningServer API
522  *             2. Check it's return value
523  * @post_condition Terminate CA using CATerminate
524  * @expected It will return CA_STATUS_FAILED
525  */
526 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
527 TEST_F(CATest_btc, CAStartListeningServerWithoutSelectingNetwork_ECRC_N)
528 {
529     if (!m_caHelper.initialize())
530     {
531         SET_FAILURE(m_caHelper.getFailureMessage());
532         return;
533     }
534
535     if (!m_caHelper.startListeningServer(CA_STATUS_FAILED))
536     {
537         SET_FAILURE(m_caHelper.getFailureMessage());
538     }
539
540     CATerminate();
541 }
542 #endif
543
544 /**
545  * @since 2015-02-16
546  * @see CAResult_t CAInitialize()
547  * @see void CATerminate()
548  * @objective Test 'CAStopListeningServer' negatively without SelectingNetwork [ECRC]
549  * @target CAResult_t CAStopListeningServer()
550  * @test_data none
551  * @pre_condition Initialize CA using CAInitialize
552  * @procedure 1. Call the CAStopListeningServer API
553  *            2. Check it's return value
554  * @post_condition Terminate CA using CATerminate
555  * @expected It will return CA_STATUS_FAILED
556  */
557 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
558 TEST_F(CATest_btc, CAStopListeningServerWithoutSelectingNetwork_ECRC_N)
559 {
560     if (!m_caHelper.initialize())
561     {
562         SET_FAILURE(m_caHelper.getFailureMessage());
563         return;
564     }
565
566     if (!m_caHelper.stopListeningServer(CA_STATUS_FAILED))
567     {
568         SET_FAILURE(m_caHelper.getFailureMessage());
569     }
570
571     CATerminate();
572 }
573 #endif
574
575 /**
576  * @since 2016-02-24
577  * @see CAResult_t CAInitialize()
578  * @see void CATerminate()
579  * @objective Test 'CAStartDiscoveryServer' without selecting a network [ECRC]
580  * @target CAResult_t CAStartDiscoveryServer()
581  * @test_data none
582  * @pre_condition  1. Initialize CA using CAInitialize
583  *                 2. Do not select network
584  * @procedure  1. Call the CAStartDiscoveryServer API
585  *             2. Check it's return value
586  * @post_condition Terminate CA using CATerminate
587  * @expected It will return CA_STATUS_FAILED
588  */
589 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
590 TEST_F(CATest_btc, CAStartDiscoveryServerWithoutSelectingNetwork_ECRC_N)
591 {
592     if (!m_caHelper.initialize())
593     {
594         SET_FAILURE(m_caHelper.getFailureMessage());
595         return;
596     }
597
598     if (!m_caHelper.startDiscoveryServer(CA_STATUS_FAILED))
599     {
600         SET_FAILURE(m_caHelper.getFailureMessage());
601     }
602
603     CATerminate();
604 }
605 #endif
606
607 /**
608  * @since 2016-02-24
609  * @see none
610  * @objective Test 'CACreateEndpoint' to check against negative value in Adapter [adapter-ECRC]
611  * @target CAResult_t CACreateEndpoint(CATransportFlags_t flags, CATransportAdapter_t adapter, const char *addr,
612  *         uint16_t port, CAEndpoint_t **object)
613  * @test_data  Invalid adapter
614  * @pre_condition none
615  * @procedure  1. call the CACreateEndpoint API and pass the invalid value as adapter arguments
616  *             2. Check it's return value
617  * @post_condition none
618  * @expected It will fail to create end point and return CA_STATUS_OK
619  */
620 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
621 TEST_F(CATest_btc, CACreateEndpoint_Adapter_ECRC_N)
622 {
623     CAEndpoint_t* m_endpoint = NULL;
624
625     CAResult_t m_result = CACreateEndpoint(CA_DEFAULT_FLAGS, CA_INVALID_ADAPTER, ENDPOINT_IP, ENDPOINT_PORT, &m_endpoint);
626     if (m_result != CA_STATUS_OK)
627     {
628         SET_FAILURE(m_caHelper.getFailureMessage("CACreateEndpoint", m_result, CA_STATUS_OK));
629     }
630 }
631 #endif
632
633 /**
634  * @since 2016-02-25
635  * @see none
636  * @objective Test 'CADestroyEndpoint' negatively to check with NULL value [NV]
637  * @target void CADestroyEndpoint(CAEndpoint_t *object)
638  * @test_data  NULL value in endpoint
639  * @pre_condition none
640  * @procedure  1. call the CADestroyEndpoint API and pass the NULL value
641  *             2. Check it's return value
642  * @post_condition none
643  * @expected It will invoke the API without any error/exception
644  */
645 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
646 TEST_F(CATest_btc, CADestroyEndpoint_NV_N)
647 {
648     CADestroyEndpoint(NULL);
649 }
650 #endif
651
652 #ifdef __WITH_DTLS__
653
654 /**
655  * @since 2015-02-02
656  * @see CAResult_t CAInitialize()
657  * @see void CATerminate()
658  * @objective Test CAregisterPskCredentialsHandler return value when a valid handler is registered
659  * @target   CAResult_t CAregisterPskCredentialsHandler(CAGetDTLSPskCredentialsHandler GetDTLSCredentials)
660  * @test_data OCDtlsPskCredsBlob object
661  * @pre_condition Initialize CA using CAInitialize
662  * @procedure call 1. Call CAregisterPskCredentialsHandler
663  *                 2. Check it's return value
664  * @post_condition Terminate CA using CATerminate
665  * @expected CAregisterPskCredentialsHandler return value will be CA_STATUS_OK
666  */
667 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
668 TEST_F(CATest_btc, RegisterDtls_P)
669 {
670     if (!m_caHelper.initialize())
671     {
672         SET_FAILURE(m_caHelper.getFailureMessage());
673         return;
674     }
675
676     if(!m_caHelper.setDtls())
677     {
678         SET_FAILURE(m_caHelper.getFailureMessage());
679     }
680
681     CATerminate();
682
683 }
684 #endif
685
686 /**
687  * @since 2015-02-04
688  * @see CAResult_t CAInitialize()
689  * @see void CATerminate()
690  * @objective Test CAregisterPskCredentialsHandler return value when a invalid handler is registered
691  * @target   CAResult_t CAregisterPskCredentialsHandler(CAGetDTLSPskCredentialsHandler GetDTLSCredentials)
692  * @test_data NULL as GetDTLSCredentials
693  * @pre_condition Initialize CA using CAInitialize
694  * @procedure call 1. Call CAregisterPskCredentialsHandler with NULL handler
695  *                 2. Check it's return value
696  * @post_condition Terminate CA using CATerminate
697  * @expected CAregisterPskCredentialsHandler return value won't be CA_STATUS_OK
698  */
699 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__ANDROID__) || defined(__WINDOWS__)
700 TEST_F(CATest_btc, RegisterDtlsCredentialsWithNullHandler_N)
701 {
702     if (!m_caHelper.initialize())
703     {
704         SET_FAILURE(m_caHelper.getFailureMessage());
705         return;
706     }
707
708     CAResult_t result = CAregisterPskCredentialsHandler(NULL);
709     if (result != CA_STATUS_OK)
710     {
711         SET_FAILURE("CAregisterPskCredentialsHandler not returned CA_STATUS_OK with NULL handler");
712     }
713
714     CATerminate();
715
716 }
717 #endif
718
719 #endif