Merge test folder of test branch
[iotivity.git] / test / src / tc / ca / arduinounit / src / stc / CAClientTest.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 #define SPEED 115200
24 #define RANDOM_STRING_LENGTH 1500
25 #define TOTAL_MESSAGE 0
26 #define RECEIVE_ERROR_COUNT 0
27 #define EXPECTED_ERROR_MESSAGE_COUNT 0
28 #define TESTLOG_START "APIs Called So far: ";
29
30 CAHelper caHelper;
31 CAResult_t result;
32 String testLog;
33
34 void setup()
35 {
36     Serial.begin(SPEED);
37     Serial.println("================================");
38     Serial.println("TestSuite: CAClientTest");
39     Serial.println("================================");
40
41     CAHelper::addFilter();
42
43     caHelper.Connect();
44     Serial.println("------------------------------------BEGIN------------------------------------");
45 }
46
47 void loop()
48 {
49     Test::run();
50 }
51
52 /**
53  * @since 2015-03-30
54  * @see  CAResult_t CAInitialize()
55  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
56  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
57  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
58  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
59  * @see  void CADestroyToken(CAToken_t token)
60  * @see  CAResult_t CAHandleRequestResponse()
61  * @see  void CATerminate()
62  * @objective Check the functionality of CASelectNetwork to receive response message when available network is selected
63  * @target  CAResult_t CASelectNetwork(const CATransportAdapter_t interestedNetwork)
64  * @test_data Response Messages
65  * @pre_condition  1. [Server] Initialize CA by CAInitialize
66  *                 2. [Server] Register the handlers by CARegisterHandler
67  *                 3. [Server] Select network
68  *                 4. [Server] Start Server
69  *                 5. [Client] Initialize CA by CAInitialize
70  *                 6. [Client] Register the handlers by CARegisterHandler
71  *                 7. [Client] Select network
72  *                 8. [Client] Start Client
73  *                 9. [Client] Send Request to find server
74  *                10. [Client] Create Endpoint for server to send request to server
75  *                11. [Client] Generate a token and set this token in request message
76  * @procedure  1. [Client] A client sends a request to server
77  *             2. [Server] Server receives the request and return a response message to client
78  *             3. [Client] Client receive the server's response
79  * @post_condition  1. [Client] Destroy token
80  *                  2. [Client] Destroy endpoint
81  *                  3. [Client] Terminate CA
82  * @expected  The requested amount of response messages should be received
83  */
84 test(SelectNetworkForIncomingMessages_P)
85 {
86     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
87     testLog = TESTLOG_START;
88
89     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
90     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
91
92     result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
93     assertEqual(result, CA_STATUS_OK, testLog);
94     testLog += ", CASendRequest";
95
96     result = caHelper.receiveMessage(REC_CLI_NOR);
97     testLog += ", CAHandleRequestResponse";
98     
99     if (caHelper.isReceiveError(result, REC_CLI_NOR))
100     {
101         caHelper.printReceiveError(testLog, REC_CLI_NOR);
102         fail();
103     }
104     
105     CATerminate();
106 }
107
108 /**
109  * @since 2014-04-02
110  * @see  CAResult_t CAInitialize()
111  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
112  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
113  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
114  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
115  * @see  void CADestroyToken(CAToken_t token)
116  * @see  CAResult_t CAHandleRequestResponse()
117  * @see  void CATerminate()
118  * @objective Check the functionality of CASelectNetwork to receive response message when unavailable network is selected
119  * @target   CAResult_t CASelectNetwork(const CATransportAdapter_t interestedNetwork)
120  * @test_data Response Messages
121  * @pre_condition  1. [Server] Initialize CA by CAInitialize
122  *                 2. [Server] Register the handlers by CARegisterHandler
123  *                 3. [Server] Select network
124  *                 4. [Server] Start Server
125  *                 5. [Client] Initialize CA by CAInitialize
126  *                 6. [Client] Register the handlers by CARegisterHandler
127  *                 7. [Client] Select network
128  *                 8. [Client] Start Client
129  *                 9. [Client] Send Request to find server
130  *                10. [Client] Create Endpoint for server to send request to server
131  *                11. [Client] Generate a token and set this token in request message
132  * @procedure  1. [Client] A client sends a request to server
133  *             2. [Server] Server receives the request and return a response message to client
134  *             3. [Client] Client receive the server's response
135  * @post_condition  1. [Client] Destroy token
136  *                  2. [Client] Destroy endpoint
137  *                  3. [Client] Terminate CA
138   * @expected  The received amount should be zero
139  */
140 test(SelectUnAvailableNetworkForIncomingMessages_N)
141 {
142     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
143     testLog = TESTLOG_START;
144
145     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
146     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
147
148     result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
149     assertEqual(result, CA_STATUS_OK, testLog);
150     testLog += ", CASendRequest";
151
152     result = CAUnSelectNetwork(caHelper.m_availableNetwork);
153     assertEqual(result, CA_STATUS_OK, testLog);
154     testLog += ", CAUnSelectNetwork";
155
156     result = CASelectNetwork(caHelper.m_unAvailableNetwork);
157     assertEqual(result, CA_NOT_SUPPORTED, testLog);
158     testLog += ", CASelectNetwork";
159
160     result = caHelper.receiveMessage(TOTAL_MESSAGE, REC_CLI_NOR);
161     testLog += ", CAHandleRequestResponse";
162     
163     if (caHelper.isReceiveError(result, REC_CLI_NOR, RECEIVE_ERROR_COUNT))
164     {
165         caHelper.printReceiveError(testLog, EXPECTED_ERROR_MESSAGE_COUNT, REC_CLI_NOR);
166         fail();
167     }
168     
169     CATerminate();
170 }
171
172 /**
173  * @since 2015-04-02
174  * @see  CAResult_t CAInitialize()
175  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
176  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
177  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
178  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
179  * @see  void CADestroyToken(CAToken_t token)
180  * @see  CAResult_t CAHandleRequestResponse()
181  * @see  void CATerminate()
182  * @objective Check the functionality of CASelectNetwork to send message when available network is selected
183  * @target   CAResult_t CASelectNetwork(const CATransportAdapter_t interestedNetwork)
184  * @test_data Request Messages
185  * @pre_condition  1. [Server] Initialize CA by CAInitialize
186  *                 2. [Server] Register the handlers by CARegisterHandler
187  *                 3. [Server] Select network
188  *                 4. [Server] Start Server
189  *                 5. [Client] Initialize CA by CAInitialize
190  *                 6. [Client] Register the handlers by CARegisterHandler
191  *                 7. [Client] Select network
192  *                 8. [Client] Start Client
193  *                 9. [Client] Send Request to find server
194  *                10. [Client] Create Endpoint for server to send request to server
195  *                11. [Client] Generate a token and set this token in request message
196  * @procedure  1. [Client] A client sends a request to server
197  *             2. [Server] Server receives the request and return a response message to client
198  *             3. [Client] Client receive the server's response
199  * @post_condition  1. [Client] Destroy token
200  *                  2. [Client] Destroy endpoint
201  *                  3. [Client] Terminate CA
202  * @expected  The number of acknowledgments should be equal to the amount of sent messages
203  */
204 test(SelectNetworkForOutgoingMessages_P)
205 {
206     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
207     testLog = "APIs Called So far: ";
208
209     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
210     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
211
212     result = caHelper.sendRequest(CA_PUT, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
213     assertEqual(result, CA_STATUS_OK, testLog);
214     testLog += ", CASendRequest";
215
216     result = caHelper.receiveMessage(REC_CLI_ACK);
217     testLog += ", CAHandleRequestResponse";
218     
219     if (caHelper.isReceiveError(result, REC_CLI_ACK))
220     {
221         caHelper.printReceiveError(testLog, REC_CLI_ACK);
222         fail();
223     }
224     
225     CATerminate();
226 }
227
228 /**
229  * @since 2015-04-02
230  * @see  CAResult_t CAInitialize()
231  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
232  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
233  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
234  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
235  * @see  void CADestroyToken(CAToken_t token)
236  * @see  CAResult_t CAHandleRequestResponse()
237  * @see  void CATerminate()
238  * @objective Check the functionality of CASelectNetwork to send request message when unavailable network is selected
239  * @target   CAResult_t CASelectNetwork(const CATransportAdapter_t interestedNetwork)
240  * @test_data Request Messages
241  * @pre_condition  1. [Server] Initialize CA by CAInitialize
242  *                 2. [Server] Register the handlers by CARegisterHandler
243  *                 3. [Server] Select network
244  *                 4. [Server] Start Server
245  *                 5. [Client] Initialize CA by CAInitialize
246  *                 6. [Client] Register the handlers by CARegisterHandler
247  *                 7. [Client] Select network
248  *                 8. [Client] Start Client
249  *                 9. [Client] Send Request to find server
250  *                10. [Client] Create Endpoint for server to send request to server
251  *                11. [Client] Generate a token and set this token in request message
252  * @procedure  1. [Client] A client sends a request to server
253  *             2. [Server] Server receives the request and return a response message to client
254  *             3. [Client] Client receive the server's response
255  * @post_condition  1. [Client] Destroy token
256  *                  2. [Client] Destroy endpoint
257  *                  3. [Client] Terminate CA
258  * @expected The number of acknowledgments should be equal to zero
259  */
260
261 test(SelectUnAvailableNetworkForOutgoingMessages_N)
262 {
263     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
264     testLog = TESTLOG_START;
265
266     assertEqual(caHelper.initClientNetwork(false), true, "Initialization");
267     testLog += "CAInitialize, CARegisterHandler";
268
269     result = CASelectNetwork(caHelper.m_unAvailableNetwork);
270     assertEqual(result, CA_NOT_SUPPORTED, testLog);
271     testLog += ", CASelectNetwork";
272
273     result = caHelper.sendRequest(CA_PUT, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
274     assertEqual(result, CA_STATUS_OK, testLog);
275     testLog += ", CASendRequest";
276
277     result = CASelectNetwork(caHelper.m_availableNetwork);
278     assertEqual(result, CA_STATUS_OK, testLog);
279     testLog += ", CASelectNetwork";
280
281     result = caHelper.receiveMessage(TOTAL_MESSAGE, REC_CLI_ACK);
282     testLog += ", CAHandleRequestResponse";
283     
284     if (caHelper.isReceiveError(result, REC_CLI_ACK, RECEIVE_ERROR_COUNT))
285     {
286         caHelper.printReceiveError(testLog, EXPECTED_ERROR_MESSAGE_COUNT, REC_CLI_ACK);
287         fail();
288     }
289     
290     CATerminate();
291 }
292 /**
293  * @since 2015-04-02
294  * @see  CAResult_t CAInitialize()
295  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
296  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
297  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
298  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
299  * @see  void CADestroyToken(CAToken_t token)
300  * @see  CAResult_t CAHandleRequestResponse()
301  * @see  void CATerminate()
302  * @objective Test the effect of selecting available network multiple times on incoming unicast messages
303  * @target    CAResult_t CASelectNetwork(const CATransportAdapter_t interestedNetwork)
304  * @test_data Response Messages
305  * @pre_condition  1. [Server] Initialize CA by CAInitialize
306  *                 2. [Server] Register the handlers by CARegisterHandler
307  * @procedure  1. [Server] Select network
308  *             2. [Server] Start Server
309  *             3. [Client] Initialize CA by CAInitialize
310  *             4. [Client] Register the handlers by CARegisterHandler
311  *             5. [Client] Select network
312  *             6. [Client] Start Client
313  *             7. [Client] Send Request to find server
314  *             8. [Client] Create Endpoint for server to send request to server
315  *             9. [Client] Generate a token and set this token in request message
316  *            10. [Client] A client sends a request to server
317  *            11. [Server] Server receives the request and return a response message to client
318  *            12. [Client] Client receive the server's response
319  *            13. [Client] Destroy token
320  *            14. [Client] Destroy endpoint
321  *            15. Repeat procedure 1 to 14 multiple times
322  * @post_condition  [Client] Terminate CA
323  * @expected  The requested amount of response messages should be received each time
324  */
325
326 test(SelectNetworkMultipleTimesForIncomingMessages_P)
327 {
328     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
329     testLog = TESTLOG_START;
330
331     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
332     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
333
334     for (int i = 0; i < TRY_COUNT; i++)
335     {
336         result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
337         assertEqual(result, CA_STATUS_OK, testLog);
338         testLog += ", CASendRequest";
339
340         result = caHelper.receiveMessage(REC_CLI_NOR);
341         testLog += ", CAHandleRequestResponse";
342         
343         if (caHelper.isReceiveError(result, REC_CLI_NOR))
344         {
345             caHelper.printReceiveError(testLog, REC_CLI_NOR);
346             fail();
347         }
348         
349         caHelper.s_receiveCount[REC_CLI_NOR] = 0;
350     }
351     CATerminate();
352 }
353
354 /**
355  * @since 2015-04-02
356  * @see  CAResult_t CAInitialize()
357  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
358  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
359  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
360  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
361  * @see  void CADestroyToken(CAToken_t token)
362  * @see  CAResult_t CAHandleRequestResponse()
363  * @see  void CATerminate()
364  * @objective Test unicast message receiving functionality by receiving response messages
365  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
366  * @test_data Response Messages
367  * @pre_condition  1. [Server] Initialize CA by CAInitialize
368  *                 2. [Server] Register the handlers by CARegisterHandler
369  *                 3. [Server] Select network
370  *                 4. [Server] Start Server
371  *                 5. [Client] Initialize CA by CAInitialize
372  *                 6. [Client] Register the handlers by CARegisterHandler
373  *                 7. [Client] Select network
374  *                 8. [Client] Start Client
375  *                 9. [Client] Send Request to find server
376  *                10. [Client] Create Endpoint for server to send request to server
377  *                11. [Client] Generate a token and set this token in request message
378  * @procedure  1. [Client] A client sends a request to server
379  *             2. [Server] Server receives the request and return a response message to client
380  *             3. [Client] Client receive the server's response
381  * @post_condition  1. [Client] Destroy token
382  *                  2. [Client] Destroy endpoint
383  *                  3. [Client] Terminate CA
384  * @expected  The requested amount of response messages should be received
385  */
386 test(ReceiveResponse_P)
387 {
388     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
389     testLog = TESTLOG_START;
390
391     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
392     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
393
394     result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
395     assertEqual(result, CA_STATUS_OK, testLog);
396     testLog += ", CASendRequest";
397
398     result = caHelper.receiveMessage(REC_CLI_NOR);
399     testLog += ", CAHandleRequestResponse";
400     
401     if (caHelper.isReceiveError(result, REC_CLI_NOR))
402     {
403         caHelper.printReceiveError(testLog, REC_CLI_NOR);
404         fail();
405     }
406     
407     CATerminate();
408 }
409
410 /**
411  * @since 2015-04-02
412  * @see  CAResult_t CAInitialize()
413  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
414  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
415  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
416  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
417  * @see  void CADestroyToken(CAToken_t token)
418  * @see  CAResult_t CAHandleRequestResponse()
419  * @see  void CATerminate()
420  * @objective Test unicast message sending functionality by sending out request messages
421  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
422  * @test_data Request Messages
423  * @pre_condition  1. [Server] Initialize CA by CAInitialize
424  *                 2. [Server] Register the handlers by CARegisterHandler
425  *                 3. [Server] Select network
426  *                 4. [Server] Start Server
427  *                 5. [Client] Initialize CA by CAInitialize
428  *                 6. [Client] Register the handlers by CARegisterHandler
429  *                 7. [Client] Select network
430  *                 8. [Client] Start Client
431  *                 9. [Client] Send Request to find server
432  *                10. [Client] Create Endpoint for server to send request to server
433  *                11. [Client] Generate a token and set this token in request message
434  * @procedure  1. [Client] A client sends a request to server
435  *             2. [Server] Server receives the request and return a response message to client
436  *             3. [Client] Client receive the server's response
437  * @post_condition  1. [Client] Destroy token
438  *                  2. [Client] Destroy endpoint
439  *                  3. [Client] Terminate CA
440  * @expected  The number of acknowledgments should be equal to the amount of sent messages
441  */
442 test(SendRequest_P)
443 {
444     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
445     testLog = TESTLOG_START;
446
447     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
448     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
449
450     result = caHelper.sendRequest(CA_PUT, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
451     assertEqual(result, CA_STATUS_OK, testLog);
452     testLog += ", CASendRequest";
453
454     result = caHelper.receiveMessage(REC_CLI_ACK);
455     testLog += ", CAHandleRequestResponse";
456     
457     if (caHelper.isReceiveError(result, REC_CLI_ACK))
458     {
459         caHelper.printReceiveError(testLog, REC_CLI_ACK);
460         fail();
461     }
462     
463     CATerminate();
464 }
465
466 /**
467  * @since 2015-04-02
468  * @see  CAResult_t CAInitialize()
469  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
470  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
471  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
472  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
473  * @see  void CADestroyToken(CAToken_t token)
474  * @see  CAResult_t CAHandleRequestResponse()
475  * @see  void CATerminate()
476  * @objective Test unicast message sending functionality using request messages with empty payloads
477  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
478  * @test_data Empty Payload
479  * @pre_condition  1. [Server] Initialize CA by CAInitialize
480  *                 2. [Server] Register the handlers by CARegisterHandler
481  *                 3. [Server] Select network
482  *                 4. [Server] Start Server
483  *                 5. [Client] Initialize CA by CAInitialize
484  *                 6. [Client] Register the handlers by CARegisterHandler
485  *                 7. [Client] Select network
486  *                 8. [Client] Start Client
487  *                 9. [Client] Send Request to find server
488  *                10. [Client] Create Endpoint for server to send request to server
489  *                11. [Client] Generate a token and set this token in request message
490  * @procedure  1. [Client] A client sends a request to server
491  *             2. [Server] Server receives the empty payload request and return a response message to client
492  *             3. [Client] Client receive the server's response
493  * @post_condition  1. [Client] Destroy token
494  *                  2. [Client] Destroy endpoint
495  *                  3. [Client] Terminate CA
496  * @expected  The number of acknowledgments should be equal to the amount of sent messages and received a response empty payload
497  */
498
499 test(SendRequestWithEmptyPayload_P)
500 {
501     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_URI, MESSAGE_UNICAST);
502     testLog = TESTLOG_START;
503
504     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
505     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
506
507     result = caHelper.sendRequestWithCustomPayload("", CA_PUT, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
508     assertEqual(result, CA_STATUS_OK, testLog);
509     testLog += ", CASendRequest";
510
511     result = caHelper.receiveMessage(REC_CLI_ACK);
512     testLog += ", CAHandleRequestResponse";
513     
514     if (caHelper.isReceiveError(result, REC_CLI_ACK))
515     {
516         caHelper.printReceiveError(testLog, REC_CLI_ACK);
517         fail();
518     }
519     
520     CATerminate();
521 }
522
523 /**
524  * @since 2015-04-02
525  * @see  CAResult_t CAInitialize()
526  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
527  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
528  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
529  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
530  * @see  void CADestroyToken(CAToken_t token)
531  * @see  CAResult_t CAHandleRequestResponse()
532  * @see  void CATerminate()
533  * @objective Test unicast message sending functionality using request messages with null payloads
534  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
535  * @test_data Null Payload
536  * @pre_condition  1. [Server] Initialize CA by CAInitialize
537  *                 2. [Server] Register the handlers by CARegisterHandler
538  *                 3. [Server] Select network
539  *                 4. [Server] Start Server
540  *                 5. [Client] Initialize CA by CAInitialize
541  *                 6. [Client] Register the handlers by CARegisterHandler
542  *                 7. [Client] Select network
543  *                 8. [Client] Start Client
544  *                 9. [Client] Send Request to find server
545  *                10. [Client] Create Endpoint for server to send request to server
546  *                11. [Client] Generate a token and set this token in request message
547  * @procedure  1. [Client] A client sends a request to server
548  *             2. [Server] Server receives the null payload request and return a response message to client
549  *             3. [Client] Client receive the server's response
550  * @post_condition  1. [Client] Destroy token
551  *                  2. [Client] Destroy endpoint
552  *                  3. [Client] Terminate CA
553  * @expected  The number of acknowledgments should be equal to the amount of sent messages and received a response null payload
554  */
555 test(SendRequestWithNullPayload_P)
556 {
557     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_URI, MESSAGE_UNICAST);
558     testLog = TESTLOG_START;
559
560     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
561     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
562
563     result = caHelper.sendRequestWithCustomPayload(NULL, CA_PUT, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
564     assertEqual(result, CA_STATUS_OK, testLog);
565     testLog += ", CASendRequest";
566
567     result = caHelper.receiveMessage(REC_CLI_ACK);
568     
569     if (caHelper.isReceiveError(result, REC_CLI_ACK))
570     {
571         caHelper.printReceiveError(testLog, REC_CLI_ACK);
572         fail();
573     }
574     
575     CATerminate();
576 }
577
578 /**
579  * @since 2015-04-02
580  * @see  CAResult_t CAInitialize()
581  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
582  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
583  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
584  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
585  * @see  void CADestroyToken(CAToken_t token)
586  * @see  CAResult_t CAHandleRequestResponse()
587  * @see  void CATerminate()
588  * @objective Test unicast message retransmission functionality using message type CA_MSG_CONFIRM
589  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
590  * @test_data Confirm type message
591  * @pre_condition  1. [Server] Initialize CA by CAInitialize
592  *                 2. [Server] Register the handlers by CARegisterHandler
593  *                 3. [Server] Select network
594  *                 4. [Server] Start Server
595  *                 5. [Client] Initialize CA by CAInitialize
596  *                 6. [Client] Register the handlers by CARegisterHandler
597  *                 7. [Client] Select network
598  *                 8. [Client] Start Client
599  *                 9. [Client] Send Request to find server
600  *                10. [Client] Create Endpoint for server to send request to server
601  *                11. [Client] Generate a token and set this token in request message
602  * @procedure  1. [Client] A client sends a Get request to server
603  *             2. [Server] Server receives the Get request and return a response message to client
604  *             3. [Client] Client receive the server's response
605  * @post_condition  1. [Client] Destroy token
606  *                  2. [Client] Destroy endpoint
607  *                  3. [Client] Terminate CA
608  * @expected  The request message should be acknowledged
609  */
610 test(SendRequestWithMessageTypeConfirm_P)
611 {
612     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
613     testLog = TESTLOG_START;
614
615     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
616     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
617
618     result = caHelper.sendRequest(CA_PUT, CA_MSG_CONFIRM, 1);
619     assertEqual(result, CA_STATUS_OK, testLog);
620     testLog += ", CASendRequest";
621
622     result = caHelper.receiveMessage(TOTAL_MESSAGE+1, MAX_ATTEMPT, REC_CLI_ACK);
623     testLog += ", CAHandleRequestResponse";
624     
625     if (caHelper.isReceiveError(result, REC_CLI_ACK, RECEIVE_ERROR_COUNT+1))
626     {
627         caHelper.printReceiveError(testLog, EXPECTED_ERROR_MESSAGE_COUNT+1, REC_CLI_ACK);
628         fail();
629     }
630     
631     CATerminate();
632 }
633
634 /**
635  * @since 2015-04-02
636  * @see  CAResult_t CAInitialize()
637  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
638  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
639  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
640  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
641  * @see  void CADestroyToken(CAToken_t token)
642  * @see  CAResult_t CAHandleRequestResponse()
643  * @see  void CATerminate()
644  * @objective Test unicast message functionality using message type CA_MSG_RESET
645  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
646  * @test_data Request message of type CA_MSG_RESET
647  * @pre_condition  1. [Server] Initialize CA by CAInitialize
648  *                 2. [Server] Register the handlers by CARegisterHandler
649  *                 3. [Server] Select network
650  *                 4. [Server] Start Server
651  *                 5. [Client] Initialize CA by CAInitialize
652  *                 6. [Client] Register the handlers by CARegisterHandler
653  *                 7. [Client] Select network
654  *                 8. [Client] Start Client
655  *                 9. [Client] Send Request to find server
656  *                10. [Client] Create Endpoint for server to send request to server
657  *                11. [Client] Generate a token and set this token in request message
658  * @procedure  1. [Client] A client sends a request to server
659  *             2. [Server] Server receives the request and return a response message to client
660  *             3. [Client] Client receive the server's response
661  * @post_condition  1. [Client] Destroy token
662  *                  2. [Client] Destroy endpoint
663  *                  3. [Client] Terminate CA
664  * @expected  The number of acknowledgments should be equal to the amount of sent messages
665  */
666
667 test(SendRequestWithMessageTypeReset_P)
668 {
669     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_EMPTY, MESSAGE_UNICAST);
670     testLog = TESTLOG_START;
671
672     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
673     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
674
675     result = caHelper.sendRequest(CA_PUT, CA_MSG_RESET, TOTAL_MESSAGE);
676     assertEqual(result, CA_STATUS_OK, testLog);
677     testLog += ", CASendRequest";
678
679     result = caHelper.receiveMessage(REC_CLI_ACK);
680     testLog += ", CAHandleRequestResponse";
681     
682     if (caHelper.isReceiveError(result, REC_CLI_ACK))
683     {
684         caHelper.printReceiveError(testLog, REC_CLI_ACK);
685         fail();
686     }
687     
688     CATerminate();
689 }
690
691 /**
692  * @since 2014-04-02
693  * @see  CAResult_t CAInitialize()
694  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
695  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
696  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
697  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
698  * @see  void CADestroyToken(CAToken_t token)
699  * @see  CAResult_t CAHandleRequestResponse()
700  * @see  void CATerminate()
701  * @objective Test unicast message sending functionality using wrong endpoint
702  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
703  * @test_data Wrong endpoint URI
704 * @pre_condition  1. [Server] Initialize CA by CAInitialize
705  *                 2. [Server] Register the handlers by CARegisterHandler
706  *                 3. [Server] Select network
707  *                 4. [Server] Start Server
708  *                 5. [Client] Initialize CA by CAInitialize
709  *                 6. [Client] Register the handlers by CARegisterHandler
710  *                 7. [Client] Select network
711  *                 8. [Client] Start Client
712  *                 9. [Client] Send Request to find server
713  *                10. [Client] Create Endpoint for server to send request to server
714  *                11. [Client] Generate a token and set this token in request message
715  * @procedure  1. [Client] A client sends a request to server
716  *             2. [Server] Server receives the Get request and return a response message to client
717  *             3. [Client] Client receive the server's response
718  * @post_condition  1. [Client] Destroy token
719  *                  2. [Client] Destroy endpoint
720  *                  3. [Client] Terminate CA
721  * @expected  The received amount should be zero
722  */
723 test(SendRequestWithWrongEndpoint_N)
724 {
725     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
726     testLog = TESTLOG_START;
727
728     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
729     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
730     
731     result = caHelper.sendRequest((char *) WRONG_IP, (char *) SIM_REQ_ACK,
732             CAHelper::s_tcInfo.identifier, CA_PUT, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
733     assertEqual(result, CA_STATUS_OK, testLog);
734     testLog += ", CASendRequest";
735
736     result = caHelper.receiveMessage(TOTAL_MESSAGE, REC_CLI_ACK);
737     testLog += ", CAHandleRequestResponse";
738     
739     if (caHelper.isReceiveError(result, REC_CLI_ACK, RECEIVE_ERROR_COUNT))
740     {
741         caHelper.printReceiveError(testLog, EXPECTED_ERROR_MESSAGE_COUNT, REC_CLI_ACK);
742         fail();
743     }
744     
745     CATerminate();
746 }
747
748 /**
749  * @since 2015-04-02
750  * @see  CAResult_t CAInitialize()
751  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
752  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
753  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
754  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
755  * @see  void CADestroyToken(CAToken_t token)
756  * @see  CAResult_t CAHandleRequestResponse()
757  * @see  void CATerminate()
758  * @objective Test unicast message sending functionality by sending out GET request messages
759  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
760  * @test_data Request messages with method GET
761  * @pre_condition  1. [Server] Initialize CA by CAInitialize
762  *                 2. [Server] Register the handlers by CARegisterHandler
763  *                 3. [Server] Select network
764  *                 4. [Server] Start Server
765  *                 5. [Client] Initialize CA by CAInitialize
766  *                 6. [Client] Register the handlers by CARegisterHandler
767  *                 7. [Client] Select network
768  *                 8. [Client] Start Client
769  *                 9. [Client] Send Request to find server
770  *                10. [Client] Create Endpoint for server to send request to server
771  *                11. [Client] Generate a token and set this token in request message
772  * @procedure  1. [Client] A client sends a Get request to server
773  *             2. [Server] Server receives Get the request and return a response message to client
774  *             3. [Client] Client receive the server's response
775  * @post_condition  1. [Client] Destroy token
776  *                  2. [Client] Destroy endpoint
777  *                  3. [Client] Terminate CA
778  * @expected  The number of acknowledgments should be equal to the amount of sent messages
779  */
780
781 test(SendGetRequest_P)
782 {
783     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
784     testLog = TESTLOG_START;
785
786     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
787     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
788
789     result = caHelper.sendRequest(CA_GET, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
790     assertEqual(result, CA_STATUS_OK, testLog);
791     testLog += ", CASendRequest";
792
793     result = caHelper.receiveMessage(REC_CLI_ACK);
794     testLog += ", CAHandleRequestResponse";
795     
796     if (caHelper.isReceiveError(result, REC_CLI_ACK))
797     {
798         caHelper.printReceiveError(testLog, REC_CLI_ACK);
799         fail();
800     }
801     
802     CATerminate();
803 }
804
805 /**
806  * @since 2015-04-02
807  * @see  CAResult_t CAInitialize()
808  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
809  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
810  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
811  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
812  * @see  void CADestroyToken(CAToken_t token)
813  * @see  CAResult_t CAHandleRequestResponse()
814  * @see  void CATerminate()
815  * @objective Test unicast message sending functionality by sending out PUT request messages
816  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
817  * @test_data Request messages with method PUT
818  * @pre_condition  1. [Server] Initialize CA by CAInitialize
819  *                 2. [Server] Register the handlers by CARegisterHandler
820  *                 3. [Server] Select network
821  *                 4. [Server] Start Server
822  *                 5. [Client] Initialize CA by CAInitialize
823  *                 6. [Client] Register the handlers by CARegisterHandler
824  *                 7. [Client] Select network
825  *                 8. [Client] Start Client
826  *                 9. [Client] Send Request to find server
827  *                10. [Client] Create Endpoint for server to send request to server
828  *                11. [Client] Generate a token and set this token in request message
829  * @procedure  1. [Client] A client sends a Put request to server
830  *             2. [Server] Server receives the Put request and return a response message to client
831  *             3. [Client] Client receive the server's response
832  * @post_condition  1. [Client] Destroy token
833  *                  2. [Client] Destroy endpoint
834  *                  3. [Client] Terminate CA
835  * @expected  The number of acknowledgments should be equal to the amount of sent messages
836  */
837 test(SendPutRequest_P)
838 {
839     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
840     testLog = TESTLOG_START;
841
842     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
843     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
844
845     result = caHelper.sendRequest(CA_PUT, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
846     assertEqual(result, CA_STATUS_OK, testLog);
847     testLog += ", CASendRequest";
848
849     result = caHelper.receiveMessage(REC_CLI_ACK);
850     testLog += ", CAHandleRequestResponse";
851     
852     if (caHelper.isReceiveError(result, REC_CLI_ACK))
853     {
854         caHelper.printReceiveError(testLog, REC_CLI_ACK);
855         fail();
856     }
857     
858     CATerminate();
859 }
860
861 /**
862  * @since 2015-04-02
863  * @see  CAResult_t CAInitialize()
864  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
865  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
866  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
867  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
868  * @see  void CADestroyToken(CAToken_t token)
869  * @see  CAResult_t CAHandleRequestResponse()
870  * @see  void CATerminate()
871  * @objective Test unicast message sending functionality by sending out POST request messages
872  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
873  * @test_data Request messages with method POST
874  * @pre_condition  1. [Server] Initialize CA by CAInitialize
875  *                 2. [Server] Register the handlers by CARegisterHandler
876  *                 3. [Server] Select network
877  *                 4. [Server] Start Server
878  *                 5. [Client] Initialize CA by CAInitialize
879  *                 6. [Client] Register the handlers by CARegisterHandler
880  *                 7. [Client] Select network
881  *                 8. [Client] Start Client
882  *                 9. [Client] Send Request to find server
883  *                10. [Client] Create Endpoint for server to send request to server
884  *                11. [Client] Generate a token and set this token in request message
885  * @procedure  1. [Client] A client sends a Post request to server
886  *             2. [Server] Server receives the Post request and return a response message to client
887  *             3. [Client] Client receive the server's response
888  * @post_condition  1. [Client] Destroy token
889  *                  2. [Client] Destroy endpoint
890  *                  3. [Client] Terminate CA
891  * @expected  The number of acknowledgments should be equal to the amount of sent messages
892  */
893 test(SendPostRequest_P)
894 {
895     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
896     testLog = TESTLOG_START;
897
898     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
899     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
900
901     result = caHelper.sendRequest(CA_POST, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
902     assertEqual(result, CA_STATUS_OK, testLog);
903     testLog += ", CASendRequest";
904
905     result = caHelper.receiveMessage(REC_CLI_ACK);
906     testLog += ", CAHandleRequestResponse";
907     
908     if (caHelper.isReceiveError(result, REC_CLI_ACK))
909     {
910         caHelper.printReceiveError(testLog, REC_CLI_ACK);
911         fail();
912     }
913     
914     CATerminate();
915 }
916
917 /**
918  * @since 2015-04-02
919  * @see  CAResult_t CAInitialize()
920  * @see  void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
921  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
922  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
923  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
924  * @see  void CADestroyToken(CAToken_t token)
925  * @see  CAResult_t CAHandleRequestResponse()
926  * @see  void CATerminate()
927  * @objective Test unicast message sending functionality by sending out DELETE request messages
928  * @target CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
929  * @test_data Request messages with method DELETE
930  * @pre_condition  1. [Server] Initialize CA by CAInitialize
931  *                 2. [Server] Register the handlers by CARegisterHandler
932  *                 3. [Server] Select network
933  *                 4. [Server] Start Server
934  *                 5. [Client] Initialize CA by CAInitialize
935  *                 6. [Client] Register the handlers by CARegisterHandler
936  *                 7. [Client] Select network
937  *                 8. [Client] Start Client
938  *                 9. [Client] Send Request to find server
939  *                10. [Client] Create Endpoint for server to send request to server
940  *                11. [Client] Generate a token and set this token in request message
941  * @procedure  1. [Client] A client sends a Delete request to server
942  *             2. [Server] Server receives the Delete request and return a response message to client
943  *             3. [Client] Client receive the server's response
944  * @post_condition  1. [Client] Destroy token
945  *                  2. [Client] Destroy endpoint
946  *                  3. [Client] Terminate CA
947  * @expected  The number of acknowledgments should be equal to the amount of sent messages
948  */
949 test(SendDeleteRequest_P)
950 {
951     caHelper.setupTestCase(MESSAGE_OUTGOING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
952     testLog = TESTLOG_START;
953
954     assertEqual(caHelper.initClientNetwork(), true, "Initialization");
955     testLog += "CAInitialize, CASelectNetwork, CARegisterHandler, CAStartDiscoveryServer";
956
957     result = caHelper.sendRequest(CA_DELETE, CA_MSG_NONCONFIRM, TOTAL_MESSAGE);
958     assertEqual(result, CA_STATUS_OK, testLog);
959     testLog += ", CASendRequest";
960
961     result = caHelper.receiveMessage(REC_CLI_ACK);
962     testLog += ", CAHandleRequestResponse";
963     
964     if (caHelper.isReceiveError(result, REC_CLI_ACK))
965     {
966         caHelper.printReceiveError(testLog, REC_CLI_ACK);
967         fail();
968     }
969     
970     CATerminate();
971 }
972
973 /**
974  * @since 2015-04-02
975  * @see  CAResult_t CAInitialize()
976  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
977  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
978  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
979  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
980  * @see  void CADestroyToken(CAToken_t token)
981  * @see  CAResult_t CAHandleRequestResponse()
982  * @see  void CATerminate()
983  * @objective Test 'CARegisterHandler' by registering null response handler
984  * @target CAResult_t CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
985  * @test_data null response handler
986  * @pre_condition  1. [Server] Initialize CA by CAInitialize
987  *                 2. [Server] Register the handlers by CARegisterHandler
988  *                 3. [Server] Select network
989  *                 4. [Server] Start Server
990  *                 5. [Client] Initialize CA by CAInitialize
991  *                 6. [Client] Register the response handlers with a null handler
992  *                 7. [Client] Select network
993  *                 8. [Client] Start Client
994  *                 9. [Client] Send Request to find server
995  *                10. [Client] Create Endpoint for server to send request to server
996  *                11. [Client] Generate a token and set this token in request message
997  * @procedure  1. [Client] A client sends a request to server
998  *             2. [Server] Server receives the request and return a response message to client
999  *             3. [Client] Client receive the server's response
1000  * @post_condition  1. [Client] Destroy token
1001  *                  2. [Client] Destroy endpoint
1002  *                  3. [Client]Terminate CA
1003  * @expected No response messages should be received
1004  */
1005 test(ReceiveWithNullResponseHandler_N)
1006 {
1007     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
1008     testLog = TESTLOG_START;
1009
1010     assertEqual(caHelper.initNetwork(), true, "Initialization");
1011     testLog += "CAInitialize, CASelectNetwork";
1012
1013     CARegisterHandler(CAHelper::handleClientRequest, NULL, CAHelper::handleError);
1014     testLog += ", CARegisterHandler";
1015
1016     result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
1017     assertEqual(result, CA_STATUS_OK, testLog);
1018     testLog += ", CASendRequest";
1019
1020     result = caHelper.receiveMessage(TOTAL_MESSAGE, REC_CLI_NOR);
1021     testLog += ", CAHandleRequestResponse";
1022     
1023     if (caHelper.isReceiveError(result, REC_CLI_NOR, RECEIVE_ERROR_COUNT))
1024     {
1025         caHelper.printReceiveError(testLog, EXPECTED_ERROR_MESSAGE_COUNT, REC_CLI_NOR);
1026         fail();
1027     }
1028     
1029     CATerminate();
1030 }
1031
1032 /**
1033  * @since 2015-04-02
1034  * @see  CAResult_t CAInitialize()
1035  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
1036  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
1037  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
1038  * @see  void CADestroyToken(CAToken_t token)
1039  * @see  void CATerminate()
1040  * @objective Test the impact or consequence of not calling CARegisterHandler Test in receiving response
1041  * @target CAResult_t CAHandleRequestResponse()
1042  * @test_data none
1043  * @pre_condition  1. [Server] Initialize CA by CAInitialize
1044  *                 2. [Server] Register the handlers by CARegisterHandler
1045  *                 3. [Server] Select network
1046  *                 4. [Server] Start Server
1047  *                 5. [Client] Initialize CA by CAInitialize
1048  *                 6. [Client] Select network
1049  *                 7. [Client] Start Client
1050  *                 8. [Client] Send Request to find server
1051  *                 9. [Client] Create Endpoint for server to send request to server
1052  *                10. [Client] Generate a token and set this token in request message
1053  * @procedure  1. [Client] A client sends a request to server
1054  *             2. [Server] Server receives the request and return a response message to client
1055  *             3. [Client] Client receive the server's response
1056  * @post_condition  1. [Client] Destroy token
1057  *                  2. [Client] Destroy endpoint
1058  *                  3. [Client]Terminate CA
1059  * @expected No response messages should be received
1060  */
1061 test(ReceiveResponseWithoutCallingCARegisterHandler_N)
1062 {
1063     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
1064     testLog = TESTLOG_START;
1065
1066     assertEqual(caHelper.initNetwork(), true, "Initialization");
1067     testLog += "CAInitialize, CASelectNetwork";
1068
1069     result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
1070     assertEqual(result, CA_STATUS_OK, testLog);
1071     testLog += ", CASendRequest";
1072
1073     result = caHelper.receiveMessage(TOTAL_MESSAGE, REC_CLI_NOR);
1074     testLog += ", CAHandleRequestResponse";
1075     
1076     if (caHelper.isReceiveError(result, REC_CLI_NOR, RECEIVE_ERROR_COUNT))
1077     {
1078         caHelper.printReceiveError(testLog, 0);
1079         fail();
1080     }
1081     
1082     CATerminate();
1083 }
1084
1085 /**
1086  * @since 2015-04-02
1087  * @see  CAResult_t CAInitialize()
1088  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
1089  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
1090  * @see  CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
1091  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
1092  * @see  void CADestroyToken(CAToken_t token)
1093  * @see  CAResult_t CAHandleRequestResponse()
1094  * @see  void CATerminate()
1095  * @objective Test 'CARegisterHandler' when registration is done twice by using two different response handler
1096  * @target CAResult_t CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
1097  * @test_data two different response handler
1098  * @pre_condition  1. [Server] Initialize CA by CAInitialize
1099  *                 2. [Server] Register the handlers by CARegisterHandler
1100  *                 3. [Server] Select network
1101  *                 4. [Server] Start Server
1102  *                 5. [Client] Initialize CA by CAInitialize
1103  *                 6. [Client] Register the response handlers
1104  *                 7. [Client] Select network
1105  *                 8. [Client] Start Client
1106  *                 9. [Client] Send Request to find server
1107  *                10. [Client] Create Endpoint for server to send request to server
1108  *                11. [Client] Generate a token and set this token in request message
1109  * @procedure  1. [Client] Call CARegisterHandler twice with two different Response Handler
1110  *             2. [Client] A client sends a request to server
1111  *             3. [Server] Server receives the request and return a response message to client
1112  *             4. [Client] Client receive the server's response
1113  * @post_condition  1. [Client] Destroy token
1114  *                  2. [Client] Destroy endpoint
1115  *                  3. [Client]Terminate CA
1116  * @expected Second handler will receive requested amount of response messages and first handler will receive no response message
1117  */
1118 test(ReceiveWithSecondResponseHandler_P)
1119 {
1120     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
1121     testLog = TESTLOG_START;
1122
1123     assertEqual(caHelper.initNetwork(), true, "Initialization");
1124     testLog += "CAInitialize, CASelectNetwork";
1125
1126     CARegisterHandler(CAHelper::handleClientRequest, CAHelper::handleClientResponse, CAHelper::handleError);
1127     testLog += ", CARegisterHandler";
1128
1129     CARegisterHandler(CAHelper::handleClientRequest, CAHelper::handleClientResponseSecond, CAHelper::handleError);
1130     testLog += ", CARegisterHandler";
1131
1132     result = CAStartDiscoveryServer();
1133     assertEqual(result, CA_STATUS_OK, testLog);
1134     testLog += ", CAStartDiscoveryServer";
1135
1136     result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
1137     assertEqual(result, CA_STATUS_OK, testLog);
1138     testLog += ", CASendRequest";
1139
1140     result = caHelper.receiveMessage(REC_SECOND_CLI_NOR);
1141     testLog += ", CAHandleRequestResponse";
1142     
1143     if (result != CA_STATUS_OK || CAHelper::getReceiveCount(REC_CLI_NOR) != 0
1144             || CAHelper::getReceiveCount(REC_SECOND_CLI_NOR) != TOTAL_MESSAGE)
1145     {
1146         caHelper.printReceiveError(testLog, REC_SECOND_CLI_NOR);
1147         fail();
1148     }
1149     
1150     CATerminate();
1151 }
1152
1153 /**
1154  * @since 2015-04-02
1155  * @see  CAResult_t CAInitialize()
1156  * @see  CAResult_t CACreateRemoteEndpoint(const CAURI_t uri, const CAConnectivityType_t connectivityType, CARemoteEndpoint_t **object)
1157  * @see  CAResult_t CAGenerateToken(CAToken_t *token)
1158  * @see  CAResult_t CASendRequest(const CARemoteEndpoint_t *object, CARequestInfo_t *requestInfo)
1159  * @see  void CADestroyRemoteEndpoint(CARemoteEndpoint_t *object)
1160  * @see  void CADestroyToken(CAToken_t token)
1161  * @see  CAResult_t CAHandleRequestResponse()
1162  * @see  void CATerminate()
1163  * @objective Test 'CARegisterHandler' when registration is done twice by using first a valid response handler then a null response handler
1164  * @target CAResult_t CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler)
1165  * @test_data valid response handler & null response handler
1166  * @pre_condition  1. [Server] Initialize CA by CAInitialize
1167  *                 2. [Server] Register the handlers by CARegisterHandler
1168  *                 3. [Server] Select network
1169  *                 4. [Server] Start Server
1170  *                 5. [Client] Initialize CA by CAInitialize
1171  *                 6. [Client] Register the response handlers
1172  *                 7. [Client] Select network
1173  *                 8. [Client] Start Client
1174  *                 9. [Client] Send Request to find server
1175  *                10. [Client] Create Endpoint for server to send request to server
1176  *                11. [Client] Generate a token and set this token in request message
1177  * @procedure  1. [Client] Call CARegisterHandler twice by using first a valid response handler then a null response handler
1178  *             2. [Client] A client sends a request to server
1179  *             3. [Server] Server receives the request and return a response message to client
1180  *             4. [Client] Client receive the server's response
1181  * @post_condition  1. [Client] Destroy token
1182  *                  2. [Client] Destroy endpoint
1183  *                  3. [Client]Terminate CA
1184  * @expected No response messages should be received
1185  */
1186 test(ReceiveWithValidAndNullResponseHandler_N)
1187 {
1188     caHelper.setupTestCase(MESSAGE_INCOMING, MESSAGE_PAYLOAD, MESSAGE_UNICAST);
1189     testLog = TESTLOG_START;
1190
1191     assertEqual(caHelper.initNetwork(), true, "Initialization");
1192     testLog += "CAInitialize, CASelectNetwork";
1193
1194     CARegisterHandler(CAHelper::handleClientRequest, CAHelper::handleClientResponse, CAHelper::handleError);
1195     testLog += ", CARegisterHandler";
1196
1197     CARegisterHandler(CAHelper::handleClientRequest, NULL, CAHelper::handleError);
1198     testLog += ", CARegisterHandler";
1199
1200     result = caHelper.sendConfigurationRequest(SEND_MESSAGE, MESSAGE_RESPONSE, CA_PUT);
1201     assertEqual(result, CA_STATUS_OK, testLog);
1202     testLog += ", CASendRequest";
1203
1204     result = caHelper.receiveMessage(TOTAL_MESSAGE, REC_CLI_NOR);
1205     testLog += ", CAHandleRequestResponse";
1206     
1207     if (caHelper.isReceiveError(result, REC_CLI_NOR, RECEIVE_ERROR_COUNT))
1208     {
1209         caHelper.printReceiveError(testLog, EXPECTED_ERROR_MESSAGE_COUNT, REC_CLI_NOR);
1210         fail();
1211     }
1212     
1213     CATerminate();
1214 }