1 #include <stdio.h>
2 #include "tx_api.h"
3 #include "nx_api.h"
4 #include "fx_api.h"
5 #include "nx_ip.h"
6
7 #ifdef NX_WEB_HTTPS_ENABLE
8 #include "nx_secure_tls.h"
9 #endif
10
11 #include "nx_web_http_client.h"
12 #include "nx_web_http_server.h"
13
14 #define TEST(prefix, name) void prefix ## _ ##name()
15 #define EXPECT_EQ(expected, actual) \
16 if(expected != actual) \
17 { \
18 printf("\nERROR! File: %s Line: %d\n", __FILE__, __LINE__); \
19 printf("Expected: 0x%x, (%d) Got: 0x%x (%d)\n", (int)expected, (int)expected, (int)actual, (int)actual); \
20 error_counter++; \
21 }
22
23 #define EXPECT_TRUE(statement) \
24 if(!statement) \
25 { \
26 printf("\nERROR! File: %s Line: %d\n", __FILE__, __LINE__); \
27 printf("Expected statement to be true!\n"); \
28 error_counter++; \
29 }
30
31
32 //typedef void VOID;
33
34 extern void test_control_return(UINT status);
35
36 UINT nx_web_http_client_create_test(void);
37 UINT nx_web_http_client_delete_test(void);
38 UINT nx_web_http_client_get_start_test(void);
39 UINT nx_web_http_client_put_start_test(void);
40 UINT nx_web_http_client_post_start_test(void);
41 UINT nx_web_http_client_head_start_test(void);
42 UINT nx_web_http_client_delete_start_test(void);
43 #ifdef NX_WEB_HTTPS_ENABLE
44 UINT nx_web_http_client_get_secure_start_test(void);
45 UINT nx_web_http_client_put_secure_start_test(void);
46 UINT nx_web_http_client_post_secure_start_test(void);
47 UINT nx_web_http_client_head_secure_start_test(void);
48 UINT nx_web_http_client_delete_secure_start_test(void);
49 #endif
50 UINT nx_web_http_client_response_body_get_test(void);
51 UINT nx_web_http_client_put_packet_test(void);
52 UINT nx_web_http_client_response_header_callback_set_test(void);
53 UINT nx_web_http_client_request_initialize_test(void);
54 UINT nx_web_http_client_request_send_test(void);
55 UINT nx_web_http_client_request_header_add_test(void);
56 UINT nx_web_http_client_connect_test(void);
57 #ifdef NX_WEB_HTTPS_ENABLE
58 UINT nx_web_http_client_secure_connect_test(void);
59 #endif
60 UINT nx_web_http_server_callback_data_send_test(VOID *stack_memory, UINT stack_size);
61 UINT nx_web_http_server_callback_response_send_test(VOID *stack_memory, UINT stack_size);
62 UINT nx_web_http_server_content_get_test(VOID *stack_memory, UINT stack_size);
63 UINT nx_web_http_server_create_test(VOID *stack_memory, UINT stack_size);
64 UINT nx_web_http_server_delete_test(VOID *stack_memory, UINT stack_size);
65 UINT nx_web_http_server_param_get_test(VOID *stack_memory, UINT stack_size);
66 UINT nx_web_http_server_query_get_test(VOID *stack_memory, UINT stack_size);
67 UINT nx_web_http_server_start_test(VOID *stack_memory, UINT stack_size);
68 #ifdef NX_WEB_HTTPS_ENABLE
69 UINT nx_web_http_server_secure_configure_test(VOID *stack_memory, UINT stack_size);
70 #endif
71 UINT nx_web_http_server_stop_test(VOID *stack_memory, UINT stack_size);
72 UINT nx_web_http_server_content_get_extended_test(VOID *stack_memory, UINT stack_size);
73 UINT nx_web_http_server_content_length_get_test(VOID *stack_memory, UINT stack_size);
74 #ifdef NX_WEB_HTTP_MULTIPART_ENABLE
75 UINT nx_web_http_server_get_entity_header_test(VOID *stack_memory, UINT stack_size);
76 UINT nx_web_http_server_get_entity_content_test(VOID *stack_memory, UINT stack_size);
77 #endif
78 UINT nx_web_http_server_callback_generate_response_header_test(VOID *stack_memory, UINT stack_size);
79 UINT nx_web_http_server_callback_packet_send_test(VOID *stack_memory, UINT stack_size);
80 UINT nx_web_http_server_gmt_callback_set_test(VOID *stack_memory, UINT stack_size);
81 UINT nx_web_http_server_cache_info_callback_set_test(VOID *stack_memory, UINT stack_size);
82 UINT nx_web_http_server_mime_maps_additional_set_test(VOID *stack_memory, UINT stack_size);
83 UINT nx_web_http_server_type_get_test(VOID *stack_memory, UINT stack_size);
84 UINT nx_web_http_server_packet_content_find_test(VOID *stack_memory, UINT stack_size);
85 UINT nx_web_http_server_packet_get_test(VOID *stack_memory, UINT stack_size);
86 UINT nx_web_http_server_invalid_userpassword_notify_set_test(VOID *stack_memory, UINT stack_size);
87
88 #define DEMO_STACK_SIZE 4096
89 #define TEST_WINDOW_SIZE 2000
90 static UCHAR stack_memory[4096];
91
92 static UCHAR ip_data[4096];
93 static UCHAR pool_data[4096];
94
95 #define SERVER_PACKET_SIZE (NX_WEB_HTTP_SERVER_MIN_PACKET_SIZE * 2)
96
97 #define HTTP_SERVER_ADDRESS IP_ADDRESS(1,2,3,4)
98
99 static TX_THREAD test_thread;
100 static NX_PACKET_POOL pool_0;
101 static NX_IP ip_0;
102
103 void test_thread_entry(ULONG thread_input);
104
105 /* Define device drivers. */
106 extern void _fx_ram_driver(FX_MEDIA *media_ptr);
107 extern void _nx_ram_network_driver_1024(NX_IP_DRIVER *driver_req_ptr);
108
109
110
111 #ifdef CTEST
test_application_define(void * first_unused_memory)112 void test_application_define(void* first_unused_memory)
113 #else /* CTEST */
114 void netx_https_api_test(void* first_unused_memory)
115 #endif /* CTEST */
116 {
117 UINT status;
118 UINT error_counter = 0;
119 CHAR *pointer;
120
121 printf("NetX Test: HTTPS API Test............................................");
122
123 /* Initialize the NetX system. */
124 nx_system_initialize();
125
126
127 /* Setup the working pointer. */
128 pointer = (CHAR *) first_unused_memory;
129
130 /* Create the test thread. */
131 status = tx_thread_create(&test_thread, "HTTPS API Test Thread", test_thread_entry, 0,
132 pointer, DEMO_STACK_SIZE,
133 6, 6, TX_NO_TIME_SLICE, TX_AUTO_START);
134 pointer = pointer + DEMO_STACK_SIZE;
135 if (status)
136 error_counter++;
137
138 /* Create the server packet pool. */
139 status = nx_packet_pool_create(&pool_0, "HTTP Server Packet Pool", SERVER_PACKET_SIZE,
140 pointer, SERVER_PACKET_SIZE*8);
141 pointer = pointer + SERVER_PACKET_SIZE * 8;
142 if (status)
143 error_counter++;
144
145 /* Create an IP instance. */
146 status = nx_ip_create(&ip_0, "HTTP Client IP", HTTP_SERVER_ADDRESS,
147 0xFFFFFF00UL, &pool_0, _nx_ram_network_driver_1024,
148 pointer, 4096, 1);
149 pointer = pointer + 4096;
150 if (status)
151 error_counter++;
152
153 /* Enable ARP and supply ARP cache memory for the server IP instance. */
154 status = nx_arp_enable(&ip_0, (void *) pointer, 1024);
155 pointer = pointer + 1024;
156 if (status)
157 error_counter++;
158
159 /* Enable TCP traffic. */
160 status = nx_tcp_enable(&ip_0);
161 if (status)
162 error_counter++;
163
164
165 }
166
test_thread_entry(ULONG thread_input)167 void test_thread_entry(ULONG thread_input)
168 {
169 UINT status;
170 UINT error_counter = 0;
171
172 /* Give IP task and driver a chance to initialize the system. */
173 tx_thread_sleep(NX_IP_PERIODIC_RATE);
174
175
176 status = nx_web_http_client_create_test();
177 if(status != NX_SUCCESS)
178 {
179 error_counter++;
180 }
181
182 status = nx_web_http_client_delete_test();
183 if(status != NX_SUCCESS)
184 {
185 error_counter++;
186 }
187
188 status = nx_web_http_client_get_start_test();
189 if(status != NX_SUCCESS)
190 {
191 error_counter++;
192 }
193
194 status = nx_web_http_client_put_start_test();
195 if(status != NX_SUCCESS)
196 {
197 error_counter++;
198 }
199
200 status = nx_web_http_client_post_start_test();
201 if(status != NX_SUCCESS)
202 {
203 error_counter++;
204 }
205
206 status = nx_web_http_client_head_start_test();
207 if(status != NX_SUCCESS)
208 {
209 error_counter++;
210 }
211
212 status = nx_web_http_client_delete_start_test();
213 if(status != NX_SUCCESS)
214 {
215 error_counter++;
216 }
217
218 #ifdef NX_WEB_HTTPS_ENABLE
219 status = nx_web_http_client_get_secure_start_test();
220 if(status != NX_SUCCESS)
221 {
222 error_counter++;
223 }
224
225 status = nx_web_http_client_put_secure_start_test();
226 if(status != NX_SUCCESS)
227 {
228 error_counter++;
229 }
230
231 status = nx_web_http_client_post_secure_start_test();
232 if(status != NX_SUCCESS)
233 {
234 error_counter++;
235 }
236
237 status = nx_web_http_client_head_secure_start_test();
238 if(status != NX_SUCCESS)
239 {
240 error_counter++;
241 }
242
243 status = nx_web_http_client_delete_secure_start_test();
244 if(status != NX_SUCCESS)
245 {
246 error_counter++;
247 }
248 #endif
249
250 status = nx_web_http_client_response_body_get_test();
251 if(status != NX_SUCCESS)
252 {
253 error_counter++;
254 }
255
256 status = nx_web_http_client_put_packet_test();
257 if(status != NX_SUCCESS)
258 {
259 error_counter++;
260 }
261
262 status = nx_web_http_client_response_header_callback_set_test();
263 if(status != NX_SUCCESS)
264 {
265 error_counter++;
266 }
267
268 status = nx_web_http_client_request_initialize_test();
269 if(status != NX_SUCCESS)
270 {
271 error_counter++;
272 }
273
274 status = nx_web_http_client_request_send_test();
275 if(status != NX_SUCCESS)
276 {
277 error_counter++;
278 }
279
280 status = nx_web_http_client_request_header_add_test();
281 if(status != NX_SUCCESS)
282 {
283 error_counter++;
284 }
285
286 status = nx_web_http_client_connect_test();
287 if(status != NX_SUCCESS)
288 {
289 error_counter++;
290 }
291 #ifdef NX_WEB_HTTPS_ENABLE
292 status = nx_web_http_client_secure_connect_test();
293 if(status != NX_SUCCESS)
294 {
295 error_counter++;
296 }
297 #endif
298
299
300 status = nx_web_http_server_callback_data_send_test(stack_memory, sizeof(stack_memory));
301 if(status != NX_SUCCESS)
302 {
303 error_counter++;
304 }
305
306 status = nx_web_http_server_callback_response_send_test(stack_memory, sizeof(stack_memory));
307 if(status != NX_SUCCESS)
308 {
309 error_counter++;
310 }
311
312 status = nx_web_http_server_content_get_test(stack_memory, sizeof(stack_memory));
313 if(status != NX_SUCCESS)
314 {
315 error_counter++;
316 }
317
318 status = nx_web_http_server_create_test(stack_memory, sizeof(stack_memory));
319 if(status != NX_SUCCESS)
320 {
321 error_counter++;
322 }
323
324 status = nx_web_http_server_delete_test(stack_memory, sizeof(stack_memory));
325 if(status != NX_SUCCESS)
326 {
327 error_counter++;
328 }
329
330 status = nx_web_http_server_param_get_test(stack_memory, sizeof(stack_memory));
331 if(status != NX_SUCCESS)
332 {
333 error_counter++;
334 }
335
336 status = nx_web_http_server_query_get_test(stack_memory, sizeof(stack_memory));
337 if(status != NX_SUCCESS)
338 {
339 error_counter++;
340 }
341
342 status = nx_web_http_server_start_test(stack_memory, sizeof(stack_memory));
343 if(status != NX_SUCCESS)
344 {
345 error_counter++;
346 }
347
348 #ifdef NX_WEB_HTTPS_ENABLE
349 status = nx_web_http_server_secure_configure_test(stack_memory, sizeof(stack_memory));
350 if(status != NX_SUCCESS)
351 {
352 error_counter++;
353 }
354 #endif
355
356 status = nx_web_http_server_stop_test(stack_memory, sizeof(stack_memory));
357 if(status != NX_SUCCESS)
358 {
359 error_counter++;
360 }
361
362 status = nx_web_http_server_content_get_extended_test(stack_memory, sizeof(stack_memory));
363 if(status != NX_SUCCESS)
364 {
365 error_counter++;
366 }
367
368 status = nx_web_http_server_content_length_get_test(stack_memory, sizeof(stack_memory));
369 if(status != NX_SUCCESS)
370 {
371 error_counter++;
372 }
373
374 #ifdef NX_WEB_HTTP_MULTIPART_ENABLE
375 status = nx_web_http_server_get_entity_header_test(stack_memory, sizeof(stack_memory));
376 if(status != NX_SUCCESS)
377 {
378 error_counter++;
379 }
380
381 status = nx_web_http_server_get_entity_content_test(stack_memory, sizeof(stack_memory));
382 if(status != NX_SUCCESS)
383 {
384 error_counter++;
385 }
386 #endif
387
388 status = nx_web_http_server_callback_generate_response_header_test(stack_memory, sizeof(stack_memory));
389 if(status != NX_SUCCESS)
390 {
391 error_counter++;
392 }
393
394 status = nx_web_http_server_callback_packet_send_test(stack_memory, sizeof(stack_memory));
395 if(status != NX_SUCCESS)
396 {
397 error_counter++;
398 }
399
400 status = nx_web_http_server_gmt_callback_set_test(stack_memory, sizeof(stack_memory));
401 if(status != NX_SUCCESS)
402 {
403 error_counter++;
404 }
405
406 status = nx_web_http_server_cache_info_callback_set_test(stack_memory, sizeof(stack_memory));
407 if(status != NX_SUCCESS)
408 {
409 error_counter++;
410 }
411
412 status = nx_web_http_server_mime_maps_additional_set_test(stack_memory, sizeof(stack_memory));
413 if(status != NX_SUCCESS)
414 {
415 error_counter++;
416 }
417
418 status = nx_web_http_server_type_get_test(stack_memory, sizeof(stack_memory));
419 if(status != NX_SUCCESS)
420 {
421 error_counter++;
422 }
423
424 status = nx_web_http_server_packet_content_find_test(stack_memory, sizeof(stack_memory));
425 if(status != NX_SUCCESS)
426 {
427 error_counter++;
428 }
429
430 status = nx_web_http_server_packet_get_test(stack_memory, sizeof(stack_memory));
431 if(status != NX_SUCCESS)
432 {
433 error_counter++;
434 }
435
436 status = nx_web_http_server_invalid_userpassword_notify_set_test(stack_memory, sizeof(stack_memory));
437 if(status != NX_SUCCESS)
438 {
439 error_counter++;
440 }
441
442 nx_ip_delete(&ip_0);
443 nx_packet_pool_delete(&pool_0);
444 tx_thread_delete(&test_thread);
445
446 if(error_counter > 0)
447 {
448 printf("FAILURE!!\n");
449 test_control_return(1);
450 }
451 else
452 {
453 printf("SUCCESS!\n");
454 test_control_return(0);
455 }
456 }
457
458 /************************ Utility functions. **************************/
459 #ifdef NX_WEB_HTTPS_ENABLE
460 /* Define the TLS setup callback function. */
tls_callback(NX_WEB_HTTP_CLIENT * client_ptr,NX_SECURE_TLS_SESSION * tls_session)461 static UINT tls_callback(NX_WEB_HTTP_CLIENT *client_ptr, NX_SECURE_TLS_SESSION *tls_session)
462 {
463
464 return(NX_SUCCESS);
465 }
466 #endif /* NX_WEB_HTTPS_ENABLE */
467
468
server_auth_check(NX_WEB_HTTP_SERVER * server_ptr,UINT request_type,CHAR * resource,CHAR ** name,CHAR ** password,CHAR ** realm)469 UINT server_auth_check(NX_WEB_HTTP_SERVER *server_ptr, UINT request_type, CHAR *resource, CHAR **name, CHAR **password, CHAR **realm)
470 {
471 return(NX_SUCCESS);
472 }
473
server_req_notify(NX_WEB_HTTP_SERVER * server_ptr,UINT request_type,CHAR * resource,NX_PACKET * packet_ptr)474 UINT server_req_notify(NX_WEB_HTTP_SERVER *server_ptr, UINT request_type, CHAR *resource, NX_PACKET *packet_ptr)
475 {
476 return(NX_SUCCESS);
477 }
478
479
480 /************************ Begin test cases. **************************/
481
nx_web_http_client_create_test(void)482 UINT nx_web_http_client_create_test(void)
483 {
484 NX_WEB_HTTP_CLIENT http_client;
485 UINT status;
486 UINT error_counter = 0;
487
488 /* Setup the IP instance so tests will pass. */
489 ip_0.nx_ip_id = NX_IP_ID;
490
491 memset(&http_client, 0, sizeof(NX_WEB_HTTP_CLIENT));
492 status = nx_web_http_client_create(NX_NULL, "Name", &ip_0, &pool_0, TEST_WINDOW_SIZE);
493 EXPECT_EQ(NX_PTR_ERROR, status);
494
495 memset(&http_client, 0, sizeof(NX_WEB_HTTP_CLIENT));
496 status = nx_web_http_client_create(&http_client, "Name", NX_NULL, &pool_0, TEST_WINDOW_SIZE);
497 EXPECT_EQ(NX_PTR_ERROR, status);
498
499 memset(&http_client, 0, sizeof(NX_WEB_HTTP_CLIENT));
500 status = nx_web_http_client_create(&http_client, "Name", &ip_0, NX_NULL, TEST_WINDOW_SIZE);
501 EXPECT_EQ(NX_PTR_ERROR, status);
502
503 /* Name can be NULL. */
504 memset(&http_client, 0, sizeof(NX_WEB_HTTP_CLIENT));
505 status = nx_web_http_client_create(&http_client, NX_NULL, &ip_0, &pool_0, TEST_WINDOW_SIZE);
506 EXPECT_EQ(NX_SUCCESS, status);
507
508 /* Proper usage test for cases below. */
509 status = nx_web_http_client_delete(&http_client);
510 EXPECT_EQ(NX_SUCCESS, status);
511 status = nx_web_http_client_create(&http_client, "Name", &ip_0, &pool_0, TEST_WINDOW_SIZE);
512 EXPECT_EQ(NX_SUCCESS, status);
513
514 EXPECT_EQ(http_client.nx_web_http_client_ip_ptr, &ip_0);
515
516 EXPECT_EQ(http_client.nx_web_http_client_packet_pool_ptr, &pool_0);
517
518 EXPECT_EQ(http_client.nx_web_http_client_state, NX_WEB_HTTP_CLIENT_STATE_READY);
519
520 EXPECT_EQ(http_client.nx_web_http_client_method, NX_WEB_HTTP_METHOD_NONE);
521
522 EXPECT_EQ(http_client.nx_web_http_client_id, NX_WEB_HTTP_CLIENT_ID);
523 status = nx_web_http_client_delete(&http_client);
524 EXPECT_EQ(NX_SUCCESS, status);
525
526 if(error_counter > 0)
527 {
528 return(1);
529 }
530
531 return(NX_SUCCESS);
532 }
533
nx_web_http_client_delete_test(void)534 UINT nx_web_http_client_delete_test(void)
535 {
536 NX_WEB_HTTP_CLIENT http_client;
537 UINT status;
538 UINT error_counter = 0;
539
540 /* Create web server instance for test. */
541 status = nx_web_http_client_create(&http_client, "nx_web_http_client_delete",
542 &ip_0, &pool_0, TEST_WINDOW_SIZE);
543
544 status = nx_web_http_client_delete(NX_NULL);
545 EXPECT_EQ(NX_PTR_ERROR, status);
546
547 status = nx_web_http_client_delete(&http_client);
548 EXPECT_EQ(NX_SUCCESS, status);
549
550 if(error_counter > 0)
551 {
552 return(1);
553 }
554
555 return(NX_SUCCESS);
556 }
557
558
nx_web_http_client_get_start_test(void)559 UINT nx_web_http_client_get_start_test(void)
560 {
561 NX_WEB_HTTP_CLIENT http_client;
562 NXD_ADDRESS ip_addr;
563 CHAR *resource = "test";
564 UINT status;
565 UINT error_counter = 0;
566
567 /*NX_WEB_HTTP_CLIENT *client_ptr, NXD_ADDRESS *ip_address, UINT server_port,
568 CHAR *resource, CHAR *username, CHAR *password,
569 ULONG wait_option)*/
570 http_client.nx_web_http_client_id = NX_WEB_HTTP_CLIENT_ID;
571
572 status = nx_web_http_client_get_start(NX_NULL, &ip_addr, 0, resource, "www.abc.com", NX_NULL, NX_NULL, NX_WAIT_FOREVER);
573 EXPECT_EQ(NX_PTR_ERROR, status);
574
575 /* Create instance for test. */
576 status = nx_web_http_client_create(&http_client, "nx_web_http_client_get_start",
577 &ip_0, &pool_0, TEST_WINDOW_SIZE);
578
579 status = nx_web_http_client_get_start(&http_client, NX_NULL, 0, resource, "www.abc.com", NX_NULL, NX_NULL, NX_WAIT_FOREVER);
580 EXPECT_EQ(NX_PTR_ERROR, status);
581
582 status = nx_web_http_client_get_start(&http_client, &ip_addr, 0, NX_NULL, "www.abc.com", NX_NULL, NX_NULL, NX_WAIT_FOREVER);
583 EXPECT_EQ(NX_PTR_ERROR, status);
584
585 http_client.nx_web_http_client_id = 0;
586 status = nx_web_http_client_get_start(&http_client, &ip_addr, 0, resource, "www.abc.com", NX_NULL, NX_NULL, NX_WAIT_FOREVER);
587 EXPECT_EQ(NX_PTR_ERROR, status);
588
589 nx_web_http_client_delete(&http_client);
590
591 if(error_counter > 0)
592 {
593 return(1);
594 }
595
596 return(NX_SUCCESS);
597 }
598
599
nx_web_http_client_put_start_test(void)600 UINT nx_web_http_client_put_start_test(void)
601 {
602 NX_WEB_HTTP_CLIENT http_client;
603 NXD_ADDRESS ip_addr;
604 CHAR *resource = "test";
605 UINT status;
606 UINT error_counter = 0;
607
608 /* Control block not initialized. */
609 status = nx_web_http_client_put_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
610 EXPECT_EQ(NX_PTR_ERROR, status);
611
612 /* Create web server instance for test. */
613 status = nx_web_http_client_create(&http_client, "nx_web_http_client_put_start",
614 &ip_0, &pool_0, TEST_WINDOW_SIZE);
615
616 status = nx_web_http_client_put_start(NX_NULL, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
617 EXPECT_EQ(NX_PTR_ERROR, status);
618
619 status = nx_web_http_client_put_start(&http_client, NX_NULL, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
620 EXPECT_EQ(NX_PTR_ERROR, status);
621
622 status = nx_web_http_client_put_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
623 EXPECT_EQ(NX_PTR_ERROR, status);
624
625 nx_web_http_client_delete(&http_client);
626
627 if(error_counter > 0)
628 {
629 return(1);
630 }
631
632 return(NX_SUCCESS);
633 }
634
nx_web_http_client_post_start_test(void)635 UINT nx_web_http_client_post_start_test(void)
636 {
637 NX_WEB_HTTP_CLIENT http_client;
638 NXD_ADDRESS ip_addr;
639 CHAR *resource = "test";
640 UINT status;
641 UINT error_counter = 0;
642
643 nx_web_http_client_delete(&http_client);
644
645 /* Control block not initialized. */
646 status = nx_web_http_client_post_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
647 EXPECT_EQ(NX_PTR_ERROR, status);
648
649 /* Create web server instance for test. */
650 status = nx_web_http_client_create(&http_client, "nx_web_http_client_post_start",
651 &ip_0, &pool_0, TEST_WINDOW_SIZE);
652
653 status = nx_web_http_client_post_start(NX_NULL, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
654 EXPECT_EQ(NX_PTR_ERROR, status);
655
656 status = nx_web_http_client_post_start(&http_client, NX_NULL, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
657 EXPECT_EQ(NX_PTR_ERROR, status);
658
659 status = nx_web_http_client_post_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", 100, NX_WAIT_FOREVER);
660 EXPECT_EQ(NX_PTR_ERROR, status);
661
662 nx_web_http_client_delete(&http_client);
663
664 if(error_counter > 0)
665 {
666 return(1);
667 }
668
669 return(NX_SUCCESS);
670 }
671
nx_web_http_client_head_start_test(void)672 UINT nx_web_http_client_head_start_test(void)
673 {
674 NX_WEB_HTTP_CLIENT http_client;
675 NXD_ADDRESS ip_addr;
676 CHAR *resource = "test";
677 UINT status;
678 UINT error_counter = 0;
679
680 nx_web_http_client_delete(&http_client);
681
682 /* Control block not initialized. */
683 status = nx_web_http_client_head_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
684 EXPECT_EQ(NX_PTR_ERROR, status);
685
686 /* Create web server instance for test. */
687 status = nx_web_http_client_create(&http_client, "nx_web_http_client_head_start",
688 &ip_0, &pool_0, TEST_WINDOW_SIZE);
689
690 status = nx_web_http_client_head_start(NX_NULL, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
691 EXPECT_EQ(NX_PTR_ERROR, status);
692
693 status = nx_web_http_client_head_start(&http_client, NX_NULL, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
694 EXPECT_EQ(NX_PTR_ERROR, status);
695
696 status = nx_web_http_client_head_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
697 EXPECT_EQ(NX_PTR_ERROR, status);
698
699 nx_web_http_client_delete(&http_client);
700
701 if(error_counter > 0)
702 {
703 return(1);
704 }
705
706 return(NX_SUCCESS);
707 }
708
nx_web_http_client_delete_start_test(void)709 UINT nx_web_http_client_delete_start_test(void)
710 {
711 NX_WEB_HTTP_CLIENT http_client;
712 NXD_ADDRESS ip_addr;
713 CHAR *resource = "test";
714 UINT status;
715 UINT error_counter = 0;
716
717 nx_web_http_client_delete(&http_client);
718
719 /* Control block not initialized. */
720 status = nx_web_http_client_delete_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
721 EXPECT_EQ(NX_PTR_ERROR, status);
722
723
724 /* Create web server instance for test. */
725 status = nx_web_http_client_create(&http_client, "nx_web_http_client_delete_start",
726 &ip_0, &pool_0, TEST_WINDOW_SIZE);
727
728 status = nx_web_http_client_delete_start(NX_NULL, &ip_addr, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
729 EXPECT_EQ(NX_PTR_ERROR, status);
730
731 status = nx_web_http_client_delete_start(&http_client, NX_NULL, NX_WEB_HTTP_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
732 EXPECT_EQ(NX_PTR_ERROR, status);
733
734 status = nx_web_http_client_delete_start(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", NX_WAIT_FOREVER);
735 EXPECT_EQ(NX_PTR_ERROR, status);
736
737 status = nx_web_http_client_delete(&http_client);
738 EXPECT_EQ(NX_SUCCESS, status);
739
740 if(error_counter > 0)
741 {
742 return(1);
743 }
744
745 return(NX_SUCCESS);
746 }
747
748 #ifdef NX_WEB_HTTPS_ENABLE
nx_web_http_client_get_secure_start_test(void)749 UINT nx_web_http_client_get_secure_start_test(void)
750 {
751 NX_WEB_HTTP_CLIENT http_client;
752 NXD_ADDRESS ip_addr;
753 CHAR *resource = "test";
754 UINT status;
755 UINT error_counter = 0;
756
757 nx_web_http_client_delete(&http_client);
758
759 /* Control block not initialized. */
760 status = nx_web_http_client_get_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
761 EXPECT_EQ(NX_PTR_ERROR, status);
762
763 /* Create web server instance for test. */
764 status = nx_web_http_client_create(&http_client, "nx_web_http_client_get_secure_start",
765 &ip_0, &pool_0, TEST_WINDOW_SIZE);
766
767 status = nx_web_http_client_get_secure_start(NX_NULL, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
768 EXPECT_EQ(NX_PTR_ERROR, status);
769
770 status = nx_web_http_client_get_secure_start(&http_client, NX_NULL, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
771 EXPECT_EQ(NX_PTR_ERROR, status);
772
773 status = nx_web_http_client_get_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
774 EXPECT_EQ(NX_PTR_ERROR, status);
775
776 status = nx_web_http_client_get_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_NULL, NX_WAIT_FOREVER);
777 EXPECT_EQ(NX_PTR_ERROR, status);
778
779 status = nx_web_http_client_delete(&http_client);
780 EXPECT_EQ(NX_SUCCESS, status);
781
782 if(error_counter > 0)
783 {
784 return(1);
785 }
786
787 return(NX_SUCCESS);
788 }
789
nx_web_http_client_put_secure_start_test(void)790 UINT nx_web_http_client_put_secure_start_test(void)
791 {
792 NX_WEB_HTTP_CLIENT http_client;
793 NXD_ADDRESS ip_addr;
794 CHAR *resource = "test";
795 UINT status;
796 UINT error_counter = 0;
797
798 nx_web_http_client_delete(&http_client);
799
800 /* Control block not initialized. */
801 status = nx_web_http_client_put_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
802 EXPECT_EQ(NX_PTR_ERROR, status);
803
804 /* Create web server instance for test. */
805 status = nx_web_http_client_create(&http_client, "nx_web_http_client_put_secure_start",
806 &ip_0, &pool_0, TEST_WINDOW_SIZE);
807
808 status = nx_web_http_client_put_secure_start(NX_NULL, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
809 EXPECT_EQ(NX_PTR_ERROR, status);
810
811 status = nx_web_http_client_put_secure_start(&http_client, NX_NULL, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
812 EXPECT_EQ(NX_PTR_ERROR, status);
813
814 status = nx_web_http_client_put_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
815 EXPECT_EQ(NX_PTR_ERROR, status);
816
817 status = nx_web_http_client_put_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_NULL, NX_WAIT_FOREVER);
818 EXPECT_EQ(NX_PTR_ERROR, status);
819
820 nx_web_http_client_delete(&http_client);
821
822 if(error_counter > 0)
823 {
824 return(1);
825 }
826
827 return(NX_SUCCESS);
828 }
829
nx_web_http_client_post_secure_start_test(void)830 UINT nx_web_http_client_post_secure_start_test(void)
831 {
832 NX_WEB_HTTP_CLIENT http_client;
833 NXD_ADDRESS ip_addr;
834 CHAR *resource = "test";
835 UINT status;
836 UINT error_counter = 0;
837
838 nx_web_http_client_delete(&http_client);
839
840 /* Control block not initialized. */
841 status = nx_web_http_client_post_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
842 EXPECT_EQ(NX_PTR_ERROR, status);
843
844 /* Create web server instance for test. */
845 status = nx_web_http_client_create(&http_client, "nx_web_http_client_post_secure_start",
846 &ip_0, &pool_0, TEST_WINDOW_SIZE);
847
848 status = nx_web_http_client_post_secure_start(NX_NULL, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
849 EXPECT_EQ(NX_PTR_ERROR, status);
850
851 status = nx_web_http_client_post_secure_start(&http_client, NX_NULL, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
852 EXPECT_EQ(NX_PTR_ERROR, status);
853
854 status = nx_web_http_client_post_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", 100, tls_callback, NX_WAIT_FOREVER);
855 EXPECT_EQ(NX_PTR_ERROR, status);
856
857 status = nx_web_http_client_post_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", 100, NX_NULL, NX_WAIT_FOREVER);
858 EXPECT_EQ(NX_PTR_ERROR, status);
859
860 nx_web_http_client_delete(&http_client);
861
862 if(error_counter > 0)
863 {
864 return(1);
865 }
866
867 return(NX_SUCCESS);
868 }
869
nx_web_http_client_head_secure_start_test(void)870 UINT nx_web_http_client_head_secure_start_test(void)
871 {
872 NX_WEB_HTTP_CLIENT http_client;
873 NXD_ADDRESS ip_addr;
874 CHAR *resource = "test";
875 UINT status;
876 UINT error_counter = 0;
877
878 nx_web_http_client_delete(&http_client);
879
880 /* Control block not initialized. */
881 status = nx_web_http_client_head_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
882 EXPECT_EQ(NX_PTR_ERROR, status);
883
884 /* Create web server instance for test. */
885 status = nx_web_http_client_create(&http_client, "nx_web_http_client_head_secure_start",
886 &ip_0, &pool_0, TEST_WINDOW_SIZE);
887
888 status = nx_web_http_client_head_secure_start(NX_NULL, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
889 EXPECT_EQ(NX_PTR_ERROR, status);
890
891 status = nx_web_http_client_head_secure_start(&http_client, NX_NULL, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
892 EXPECT_EQ(NX_PTR_ERROR, status);
893
894 status = nx_web_http_client_head_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
895 EXPECT_EQ(NX_PTR_ERROR, status);
896
897 status = nx_web_http_client_head_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_NULL, NX_WAIT_FOREVER);
898 EXPECT_EQ(NX_PTR_ERROR, status);
899
900 nx_web_http_client_delete(&http_client);
901
902 if(error_counter > 0)
903 {
904 return(1);
905 }
906
907 return(NX_SUCCESS);
908 }
909
nx_web_http_client_delete_secure_start_test(void)910 UINT nx_web_http_client_delete_secure_start_test(void)
911 {
912 NX_WEB_HTTP_CLIENT http_client;
913 NXD_ADDRESS ip_addr;
914 CHAR *resource = "test";
915 UINT status;
916 UINT error_counter = 0;
917
918 nx_web_http_client_delete(&http_client);
919
920 /* Control block not initialized. */
921 status = nx_web_http_client_delete_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
922 EXPECT_EQ(NX_PTR_ERROR, status);
923
924 /* Create web server instance for test. */
925 status = nx_web_http_client_create(&http_client, "nx_web_http_client_delete_secure_start",
926 &ip_0, &pool_0, TEST_WINDOW_SIZE);
927
928 status = nx_web_http_client_delete_secure_start(NX_NULL, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
929 EXPECT_EQ(NX_PTR_ERROR, status);
930
931 status = nx_web_http_client_delete_secure_start(&http_client, NX_NULL, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
932 EXPECT_EQ(NX_PTR_ERROR, status);
933
934 status = nx_web_http_client_delete_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, NX_NULL, "www.abc.com", "name", "password", tls_callback, NX_WAIT_FOREVER);
935 EXPECT_EQ(NX_PTR_ERROR, status);
936
937 status = nx_web_http_client_delete_secure_start(&http_client, &ip_addr, NX_WEB_HTTPS_SERVER_PORT, resource, "www.abc.com", "name", "password", NX_NULL, NX_WAIT_FOREVER);
938 EXPECT_EQ(NX_PTR_ERROR, status);
939
940 nx_web_http_client_delete(&http_client);
941
942 if(error_counter > 0)
943 {
944 return(1);
945 }
946
947 return(NX_SUCCESS);
948 }
949 #endif /* NX_WEB_HTTPS_ENABLE */
950
nx_web_http_client_response_body_get_test(void)951 UINT nx_web_http_client_response_body_get_test(void)
952 {
953 NX_WEB_HTTP_CLIENT http_client;
954 NX_PACKET *packet_ptr;
955 UINT status;
956 UINT error_counter = 0;
957
958 nx_web_http_client_delete(&http_client);
959
960 /* Control block not initialized. */
961 status = nx_web_http_client_response_body_get(&http_client, &packet_ptr, NX_WAIT_FOREVER);
962 EXPECT_EQ(NX_PTR_ERROR, status);
963
964 /* Create web server instance for test. */
965 status = nx_web_http_client_create(&http_client, "nx_web_http_client_response_body_get",
966 &ip_0, &pool_0, TEST_WINDOW_SIZE);
967
968 status = nx_web_http_client_response_body_get(NX_NULL, &packet_ptr, NX_WAIT_FOREVER);
969 EXPECT_EQ(NX_PTR_ERROR, status);
970
971 status = nx_web_http_client_response_body_get(&http_client, NX_NULL, NX_WAIT_FOREVER);
972 EXPECT_EQ(NX_PTR_ERROR, status);
973
974 nx_web_http_client_delete(&http_client);
975
976 if(error_counter > 0)
977 {
978 return(1);
979 }
980
981 return(NX_SUCCESS);
982 }
983
nx_web_http_client_put_packet_test(void)984 UINT nx_web_http_client_put_packet_test(void)
985 {
986 NX_WEB_HTTP_CLIENT http_client;
987 NX_PACKET packet;
988 UINT status;
989 UINT error_counter = 0;
990
991 nx_web_http_client_delete(&http_client);
992
993 /* Control block not initialized. */
994 status = nx_web_http_client_put_packet(&http_client, &packet, NX_WAIT_FOREVER);
995 EXPECT_EQ(NX_PTR_ERROR, status);
996
997 /* Create web server instance for test. */
998 status = nx_web_http_client_create(&http_client, "nx_web_http_client_put_packet",
999 &ip_0, &pool_0, TEST_WINDOW_SIZE);
1000
1001 status = nx_web_http_client_put_packet(NX_NULL, &packet, NX_WAIT_FOREVER);
1002 EXPECT_EQ(NX_PTR_ERROR, status);
1003
1004 status = nx_web_http_client_put_packet(&http_client, NX_NULL, NX_WAIT_FOREVER);
1005 EXPECT_EQ(NX_PTR_ERROR, status);
1006
1007 nx_web_http_client_delete(&http_client);
1008
1009 if(error_counter > 0)
1010 {
1011 return(1);
1012 }
1013
1014 return(NX_SUCCESS);
1015 }
1016
1017
response_header_callback(NX_WEB_HTTP_CLIENT * client_ptr,CHAR * field_name,UINT field_name_length,CHAR * field_value,UINT field_value_length)1018 static VOID response_header_callback(NX_WEB_HTTP_CLIENT *client_ptr, CHAR *field_name, UINT field_name_length,
1019 CHAR *field_value, UINT field_value_length)
1020 {
1021
1022 }
1023
nx_web_http_client_response_header_callback_set_test(void)1024 UINT nx_web_http_client_response_header_callback_set_test(void)
1025 {
1026 NX_WEB_HTTP_CLIENT http_client;
1027 UINT status;
1028 UINT error_counter = 0;
1029
1030 /* Create web server instance for test. */
1031 status = nx_web_http_client_create(&http_client, "nx_web_http_client_response_header_callback_set",
1032 &ip_0, &pool_0, TEST_WINDOW_SIZE);
1033
1034 status = nx_web_http_client_response_header_callback_set(NX_NULL, response_header_callback);
1035 EXPECT_EQ(NX_PTR_ERROR, status);
1036
1037 status = nx_web_http_client_response_header_callback_set(&http_client, NX_NULL);
1038 EXPECT_EQ(NX_PTR_ERROR, status);
1039
1040 nx_web_http_client_delete(&http_client);
1041
1042 if(error_counter > 0)
1043 {
1044 return(1);
1045 }
1046
1047 return(NX_SUCCESS);
1048 }
1049
nx_web_http_client_request_initialize_test(void)1050 UINT nx_web_http_client_request_initialize_test(void)
1051 {
1052 NX_WEB_HTTP_CLIENT http_client;
1053 CHAR *resource = "resource";
1054 UINT status;
1055 UINT error_counter = 0;
1056
1057 /* Create web server instance for test. */
1058 status = nx_web_http_client_create(&http_client, "nx_web_http_client_request_initialize",
1059 &ip_0, &pool_0, TEST_WINDOW_SIZE);
1060
1061 status = nx_web_http_client_request_initialize(NX_NULL, NX_WEB_HTTP_METHOD_GET, resource, "www.abc.com", 0, NX_FALSE,
1062 "name", "password", NX_WAIT_FOREVER);
1063 EXPECT_EQ(NX_PTR_ERROR, status);
1064
1065 status = nx_web_http_client_request_initialize(&http_client, NX_WEB_HTTP_METHOD_GET, NX_NULL, "www.abc.com", 0, NX_FALSE,
1066 "name", "password", NX_WAIT_FOREVER);
1067 EXPECT_EQ(NX_PTR_ERROR, status);
1068
1069 status = nx_web_http_client_request_initialize(&http_client, NX_WEB_HTTP_METHOD_NONE, resource, "www.abc.com", 0, NX_FALSE,
1070 "name", "password", NX_WAIT_FOREVER);
1071 EXPECT_EQ(NX_WEB_HTTP_METHOD_ERROR, status);
1072
1073 /* Test method parameters. */
1074 status = nx_web_http_client_request_initialize(&http_client, NX_WEB_HTTP_METHOD_PUT, resource, "www.abc.com", 0, NX_FALSE,
1075 "name", "password", NX_WAIT_FOREVER);
1076 EXPECT_EQ(NX_WEB_HTTP_METHOD_ERROR, status);
1077
1078 status = nx_web_http_client_request_initialize(&http_client, NX_WEB_HTTP_METHOD_POST, resource, "www.abc.com", 0, NX_FALSE,
1079 "name", "password", NX_WAIT_FOREVER);
1080 EXPECT_EQ(NX_WEB_HTTP_METHOD_ERROR, status);
1081
1082 nx_web_http_client_delete(&http_client);
1083
1084 if(error_counter > 0)
1085 {
1086 return(1);
1087 }
1088
1089 return(NX_SUCCESS);
1090 }
1091
nx_web_http_client_request_send_test(void)1092 UINT nx_web_http_client_request_send_test(void)
1093 {
1094 NX_WEB_HTTP_CLIENT http_client;
1095 UINT status;
1096 UINT error_counter = 0;
1097
1098 /* Create web server instance for test. */
1099 status = nx_web_http_client_create(&http_client, "nx_web_http_client_request_send",
1100 &ip_0, &pool_0, TEST_WINDOW_SIZE);
1101
1102 status = nx_web_http_client_request_send(NX_NULL, NX_WAIT_FOREVER);
1103 EXPECT_EQ(NX_PTR_ERROR, status);
1104
1105 nx_web_http_client_delete(&http_client);
1106
1107 if(error_counter > 0)
1108 {
1109 return(1);
1110 }
1111
1112 return(NX_SUCCESS);
1113 }
1114
nx_web_http_client_request_header_add_test(void)1115 UINT nx_web_http_client_request_header_add_test(void)
1116 {
1117 NX_WEB_HTTP_CLIENT http_client;
1118 UINT status;
1119 UINT error_counter = 0;
1120
1121 /* Create web server instance for test. */
1122 status = nx_web_http_client_create(&http_client, "nx_web_http_client_request_header_add",
1123 &ip_0, &pool_0, TEST_WINDOW_SIZE);
1124
1125 status = nx_web_http_client_request_header_add(NX_NULL, "field_name", sizeof("field_name"),
1126 "field_value", sizeof("field_value"), NX_WAIT_FOREVER);
1127 EXPECT_EQ(NX_PTR_ERROR, status);
1128
1129 status = nx_web_http_client_request_header_add(&http_client, NX_NULL, sizeof("field_name"),
1130 "field_value", sizeof("field_value"), NX_WAIT_FOREVER);
1131 EXPECT_EQ(NX_PTR_ERROR, status);
1132
1133 status = nx_web_http_client_request_header_add(&http_client, "field_name", sizeof("field_name"),
1134 NX_NULL, sizeof("field_value"), NX_WAIT_FOREVER);
1135 EXPECT_EQ(NX_PTR_ERROR, status);
1136
1137 nx_web_http_client_delete(&http_client);
1138
1139 if(error_counter > 0)
1140 {
1141 return(1);
1142 }
1143
1144 return(NX_SUCCESS);
1145 }
1146
nx_web_http_client_connect_test(void)1147 UINT nx_web_http_client_connect_test(void)
1148 {
1149 NX_WEB_HTTP_CLIENT http_client;
1150 UINT status;
1151 NXD_ADDRESS ip_addr;
1152 UINT error_counter = 0;
1153
1154 status = nx_web_http_client_connect(NX_NULL, &ip_addr, NX_WEB_HTTP_SERVER_PORT, NX_WAIT_FOREVER);
1155 EXPECT_EQ(NX_PTR_ERROR, status);
1156
1157 status = nx_web_http_client_connect(&http_client, NX_NULL, NX_WEB_HTTP_SERVER_PORT, NX_WAIT_FOREVER);
1158 EXPECT_EQ(NX_PTR_ERROR, status);
1159
1160 if(error_counter > 0)
1161 {
1162 return(1);
1163 }
1164
1165 return(NX_SUCCESS);
1166 }
1167
1168 #ifdef NX_WEB_HTTPS_ENABLE
nx_web_http_client_secure_connect_test(void)1169 UINT nx_web_http_client_secure_connect_test(void)
1170 {
1171 NX_WEB_HTTP_CLIENT http_client;
1172 UINT status;
1173 NXD_ADDRESS ip_addr;
1174 UINT error_counter = 0;
1175
1176 status = nx_web_http_client_secure_connect(NX_NULL, &ip_addr, NX_WEB_HTTP_SERVER_PORT, tls_callback, NX_WAIT_FOREVER);
1177 EXPECT_EQ(NX_PTR_ERROR, status);
1178
1179 status = nx_web_http_client_secure_connect(&http_client, NX_NULL, NX_WEB_HTTP_SERVER_PORT, tls_callback, NX_WAIT_FOREVER);
1180 EXPECT_EQ(NX_PTR_ERROR, status);
1181
1182 status = nx_web_http_client_secure_connect(&http_client, &ip_addr, NX_WEB_HTTP_SERVER_PORT, NX_NULL, NX_WAIT_FOREVER);
1183 EXPECT_EQ(NX_PTR_ERROR, status);
1184
1185 if(error_counter > 0)
1186 {
1187 return(1);
1188 }
1189
1190 return(NX_SUCCESS);
1191 }
1192 #endif
1193
nx_web_http_server_callback_data_send_test(VOID * stack_memory,UINT stack_size)1194 UINT nx_web_http_server_callback_data_send_test(VOID *stack_memory, UINT stack_size)
1195 {
1196 NX_WEB_HTTP_SERVER http_server;
1197 UCHAR *data_ptr = "data to send";
1198 UINT data_length = sizeof("data to send");
1199 UINT status;
1200 UINT error_counter = 0;
1201
1202 /* Control block not initialized. */
1203 status = nx_web_http_server_callback_data_send(&http_server, data_ptr, data_length);
1204 EXPECT_EQ(NX_PTR_ERROR, status);
1205
1206 /* Create web server instance for test. */
1207
1208 status = nx_web_http_server_create(&http_server, "nx_web_http_server_callback_data_send",
1209 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1210 stack_memory, stack_size, &pool_0,
1211 server_auth_check, server_req_notify);
1212
1213 status = nx_web_http_server_callback_data_send(NX_NULL, data_ptr, data_length);
1214 EXPECT_EQ(NX_PTR_ERROR, status);
1215
1216 status = nx_web_http_server_callback_data_send(&http_server, NX_NULL, data_length);
1217 EXPECT_EQ(NX_PTR_ERROR, status);
1218
1219 nx_web_http_server_delete(&http_server);
1220
1221 if(error_counter > 0)
1222 {
1223 return(1);
1224 }
1225
1226 return(NX_SUCCESS);
1227 }
1228
nx_web_http_server_callback_response_send_test(VOID * stack_memory,UINT stack_size)1229 UINT nx_web_http_server_callback_response_send_test(VOID *stack_memory, UINT stack_size)
1230 {
1231 NX_WEB_HTTP_SERVER http_server;
1232 CHAR *header = "header";
1233 CHAR *information = "info";
1234 CHAR *additional_info = "additional info";
1235 UINT status;
1236 UINT error_counter = 0;
1237
1238
1239 status = nx_web_http_server_callback_response_send(NX_NULL, header, information, additional_info);
1240 EXPECT_EQ(NX_PTR_ERROR, status);
1241
1242 status = nx_web_http_server_callback_response_send(&http_server, NX_NULL, information, additional_info);
1243 EXPECT_EQ(NX_PTR_ERROR, status);
1244
1245 if(error_counter > 0)
1246 {
1247 return(1);
1248 }
1249
1250 return(NX_SUCCESS);
1251 }
1252
nx_web_http_server_content_get_test(VOID * stack_memory,UINT stack_size)1253 UINT nx_web_http_server_content_get_test(VOID *stack_memory, UINT stack_size)
1254 {
1255 NX_WEB_HTTP_SERVER http_server;
1256 UINT status;
1257 NX_PACKET packet;
1258 CHAR dest_buffer[100];
1259 CHAR dest_size = sizeof(dest_buffer);
1260 UINT actual_size;
1261 UINT error_counter = 0;
1262
1263 /* Control block not initialized. */
1264 status = nx_web_http_server_content_get(&http_server, &packet, 0, dest_buffer, dest_size, &actual_size);
1265 EXPECT_EQ(NX_PTR_ERROR, status);
1266
1267 nx_web_http_server_delete(&http_server);
1268
1269 /* Create web server instance for test. */
1270 status = nx_web_http_server_create(&http_server, "nx_web_http_server_content_get",
1271 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1272 stack_memory, stack_size, &pool_0,
1273 server_auth_check, server_req_notify);
1274
1275 status = nx_web_http_server_content_get(NX_NULL, &packet, 0, dest_buffer, dest_size, &actual_size);
1276 EXPECT_EQ(NX_PTR_ERROR, status);
1277
1278 status = nx_web_http_server_content_get(&http_server, NX_NULL, 0, dest_buffer, dest_size, &actual_size);
1279 EXPECT_EQ(NX_PTR_ERROR, status);
1280
1281 status = nx_web_http_server_content_get(&http_server, &packet, 0, NX_NULL, dest_size, &actual_size);
1282 EXPECT_EQ(NX_PTR_ERROR, status);
1283
1284 status = nx_web_http_server_content_get(&http_server, &packet, 0, dest_buffer, dest_size, NX_NULL);
1285 EXPECT_EQ(NX_PTR_ERROR, status);
1286
1287 nx_web_http_server_delete(&http_server);
1288
1289 if(error_counter > 0)
1290 {
1291 return(1);
1292 }
1293
1294 return(NX_SUCCESS);
1295 }
1296
nx_web_http_server_create_test(VOID * stack_memory,UINT stack_size)1297 UINT nx_web_http_server_create_test(VOID *stack_memory, UINT stack_size)
1298 {
1299 NX_WEB_HTTP_SERVER http_server;
1300 UINT status;
1301 UINT error_counter = 0;
1302
1303
1304 status = nx_web_http_server_create(NX_NULL, "nx_web_http_server_create",
1305 NX_NULL, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1306 stack_memory, stack_size, &pool_0,
1307 server_auth_check, server_req_notify);
1308 EXPECT_EQ(NX_PTR_ERROR, status);
1309
1310 nx_web_http_server_delete(&http_server);
1311
1312 status = nx_web_http_server_create(&http_server, "nx_web_http_server_create",
1313 NX_NULL, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1314 stack_memory, stack_size, &pool_0,
1315 server_auth_check, server_req_notify);
1316 EXPECT_EQ(NX_PTR_ERROR, status);
1317
1318 nx_web_http_server_delete(&http_server);
1319
1320 status = nx_web_http_server_create(&http_server, "nx_web_http_server_create",
1321 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1322 NX_NULL, stack_size, &pool_0,
1323 server_auth_check, server_req_notify);
1324 EXPECT_EQ(NX_PTR_ERROR, status);
1325
1326 nx_web_http_server_delete(&http_server);
1327
1328 status = nx_web_http_server_create(&http_server, "nx_web_http_server_create",
1329 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1330 stack_memory, stack_size, NX_NULL,
1331 server_auth_check, server_req_notify);
1332 EXPECT_EQ(NX_PTR_ERROR, status);
1333
1334 nx_web_http_server_delete(&http_server);
1335
1336 /* Create server - expect successful return for following checks. */
1337 status = nx_web_http_server_create(&http_server, "nx_web_http_server_create",
1338 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1339 stack_memory, stack_size, &pool_0,
1340 server_auth_check, server_req_notify);
1341 EXPECT_EQ(NX_SUCCESS, status);
1342
1343 EXPECT_EQ((ULONG)(&http_server), http_server.nx_web_http_server_tcpserver.nx_tcpserver_reserved);
1344 EXPECT_EQ(&ip_0, http_server.nx_web_http_server_ip_ptr);
1345 EXPECT_EQ(&pool_0, http_server.nx_web_http_server_packet_pool_ptr);
1346 EXPECT_EQ(server_auth_check, http_server.nx_web_http_server_authentication_check);
1347 EXPECT_EQ(server_req_notify, http_server.nx_web_http_server_request_notify);
1348 EXPECT_EQ(NX_WEB_HTTP_SERVER_ID, http_server.nx_web_http_server_id);
1349 EXPECT_EQ(NX_WEB_HTTP_SERVER_PORT, http_server.nx_web_http_server_listen_port);
1350
1351 nx_web_http_server_delete(&http_server);
1352
1353 if(error_counter > 0)
1354 {
1355 return(1);
1356 }
1357
1358 return(NX_SUCCESS);
1359 }
1360
nx_web_http_server_delete_test(VOID * stack_memory,UINT stack_size)1361 UINT nx_web_http_server_delete_test(VOID *stack_memory, UINT stack_size)
1362 {
1363 NX_WEB_HTTP_SERVER http_server;
1364 UINT status;
1365 UINT error_counter = 0;
1366
1367 /* Create web server instance for test. */
1368 status = nx_web_http_server_create(&http_server, "nx_web_http_server_delete",
1369 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1370 stack_memory, stack_size, &pool_0,
1371 server_auth_check, server_req_notify);
1372
1373 status = nx_web_http_server_delete(NX_NULL);
1374 EXPECT_EQ(NX_PTR_ERROR, status);
1375
1376 status = nx_web_http_server_delete(&http_server);
1377
1378 EXPECT_EQ(NX_SUCCESS, status);
1379
1380 if(error_counter > 0)
1381 {
1382 return(1);
1383 }
1384
1385 return(NX_SUCCESS);
1386 }
1387
1388
nx_web_http_server_param_get_test(VOID * stack_memory,UINT stack_size)1389 UINT nx_web_http_server_param_get_test(VOID *stack_memory, UINT stack_size)
1390 {
1391 NX_PACKET packet;
1392 CHAR param_buf[100];
1393 UINT param_size;
1394 UINT status;
1395 UINT error_counter = 0;
1396
1397 status = nx_web_http_server_param_get(NX_NULL, 1, param_buf, ¶m_size, sizeof(param_buf));
1398 EXPECT_EQ(NX_PTR_ERROR, status);
1399
1400 status = nx_web_http_server_param_get(&packet, 1, NX_NULL, ¶m_size, sizeof(param_buf));
1401 EXPECT_EQ(NX_PTR_ERROR, status);
1402
1403 status = nx_web_http_server_param_get(&packet, 1, param_buf, NX_NULL, sizeof(param_buf));
1404 EXPECT_EQ(NX_PTR_ERROR, status);
1405
1406 if(error_counter > 0)
1407 {
1408 return(1);
1409 }
1410
1411 return(NX_SUCCESS);
1412 }
1413
nx_web_http_server_query_get_test(VOID * stack_memory,UINT stack_size)1414 UINT nx_web_http_server_query_get_test(VOID *stack_memory, UINT stack_size)
1415 {
1416 NX_PACKET packet;
1417 CHAR param_buf[100];
1418 UINT param_size;
1419 UINT status;
1420 UINT error_counter = 0;
1421
1422 status = nx_web_http_server_query_get(NX_NULL, 1, param_buf, ¶m_size, sizeof(param_buf));
1423 EXPECT_EQ(NX_PTR_ERROR, status);
1424
1425 status = nx_web_http_server_query_get(&packet, 1, NX_NULL, ¶m_size, sizeof(param_buf));
1426 EXPECT_EQ(NX_PTR_ERROR, status);
1427
1428 status = nx_web_http_server_query_get(&packet, 1, param_buf, NX_NULL, sizeof(param_buf));
1429 EXPECT_EQ(NX_PTR_ERROR, status);
1430
1431 if(error_counter > 0)
1432 {
1433 return(1);
1434 }
1435
1436 return(NX_SUCCESS);
1437 }
1438
nx_web_http_server_start_test(VOID * stack_memory,UINT stack_size)1439 UINT nx_web_http_server_start_test(VOID *stack_memory, UINT stack_size)
1440 {
1441 NX_WEB_HTTP_SERVER http_server;
1442 UINT status;
1443 UINT error_counter = 0;
1444
1445 status = nx_web_http_server_start(&http_server);
1446 EXPECT_EQ(NX_PTR_ERROR, status);
1447
1448 status = nx_web_http_server_start(NX_NULL);
1449 EXPECT_EQ(NX_PTR_ERROR, status);
1450
1451 if(error_counter > 0)
1452 {
1453 return(1);
1454 }
1455
1456 return(NX_SUCCESS);
1457 }
1458
1459 #ifdef NX_WEB_HTTPS_ENABLE
nx_web_http_server_secure_configure_test(VOID * stack_memory,UINT stack_size)1460 UINT nx_web_http_server_secure_configure_test(VOID *stack_memory, UINT stack_size)
1461 {
1462 NX_WEB_HTTP_SERVER http_server;
1463
1464 const NX_SECURE_TLS_CRYPTO crypto_table;
1465 UCHAR metadata_buffer[100];
1466 UCHAR packet_buffer[100];
1467 NX_SECURE_X509_CERT identity_certificate;
1468 NX_SECURE_X509_CERT *trusted_certificates[1];
1469 NX_SECURE_X509_CERT *remote_certificates[1];
1470 UCHAR remote_certificate_buffer[100];
1471 UINT status;
1472 UINT error_counter = 0;
1473
1474 /* Create web server instance for test. */
1475 status = nx_web_http_server_create(&http_server, "nx_web_http_server_secure_configure",
1476 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1477 stack_memory, stack_size, &pool_0,
1478 server_auth_check, server_req_notify);
1479
1480 status = nx_web_http_server_secure_configure(NX_NULL, &crypto_table, metadata_buffer, sizeof(metadata_buffer),
1481 packet_buffer, sizeof(packet_buffer), &identity_certificate,
1482 trusted_certificates, 1, remote_certificates, 1,
1483 remote_certificate_buffer, sizeof(remote_certificate_buffer));
1484 EXPECT_EQ(NX_PTR_ERROR, status);
1485
1486 status = nx_web_http_server_secure_configure(&http_server, NX_NULL, metadata_buffer, sizeof(metadata_buffer),
1487 packet_buffer, sizeof(packet_buffer), &identity_certificate,
1488 trusted_certificates, 1, remote_certificates, 1,
1489 remote_certificate_buffer, sizeof(remote_certificate_buffer));
1490 EXPECT_EQ(NX_PTR_ERROR, status);
1491
1492 status = nx_web_http_server_secure_configure(&http_server, &crypto_table, NX_NULL, sizeof(metadata_buffer),
1493 packet_buffer, sizeof(packet_buffer), &identity_certificate,
1494 trusted_certificates, 1, remote_certificates, 1,
1495 remote_certificate_buffer, sizeof(remote_certificate_buffer));
1496 EXPECT_EQ(NX_PTR_ERROR, status);
1497
1498 status = nx_web_http_server_secure_configure(&http_server, &crypto_table, metadata_buffer, sizeof(metadata_buffer),
1499 NX_NULL, sizeof(packet_buffer), &identity_certificate,
1500 trusted_certificates, 1, remote_certificates, 1,
1501 remote_certificate_buffer, sizeof(remote_certificate_buffer));
1502 EXPECT_EQ(NX_PTR_ERROR, status);
1503
1504 status = nx_web_http_server_secure_configure(&http_server, &crypto_table, metadata_buffer, sizeof(metadata_buffer),
1505 packet_buffer, sizeof(packet_buffer), NX_NULL,
1506 trusted_certificates, 1, remote_certificates, 1,
1507 remote_certificate_buffer, sizeof(remote_certificate_buffer));
1508 EXPECT_EQ(NX_PTR_ERROR, status);
1509
1510 status = nx_web_http_server_delete(&http_server);
1511 EXPECT_EQ(NX_SUCCESS, status);
1512
1513 if(error_counter > 0)
1514 {
1515 return(1);
1516 }
1517
1518 return(NX_SUCCESS);
1519 }
1520 #endif
1521
nx_web_http_server_stop_test(VOID * stack_memory,UINT stack_size)1522 UINT nx_web_http_server_stop_test(VOID *stack_memory, UINT stack_size)
1523 {
1524 NX_WEB_HTTP_SERVER http_server;
1525 UINT status;
1526 UINT error_counter = 0;
1527
1528 status = nx_web_http_server_stop(&http_server);
1529 EXPECT_EQ(NX_PTR_ERROR, status);
1530
1531 status = nx_web_http_server_stop(NX_NULL);
1532 EXPECT_EQ(NX_PTR_ERROR, status);
1533
1534 if(error_counter > 0)
1535 {
1536 return(1);
1537 }
1538
1539 return(NX_SUCCESS);
1540 }
1541
nx_web_http_server_content_get_extended_test(VOID * stack_memory,UINT stack_size)1542 UINT nx_web_http_server_content_get_extended_test(VOID *stack_memory, UINT stack_size)
1543 {
1544 NX_WEB_HTTP_SERVER http_server;
1545 NX_PACKET packet;
1546 CHAR buffer[100];
1547 UINT content_size;
1548 UINT status;
1549 UINT error_counter = 0;
1550
1551 /* Control block not initialized. */
1552 status = nx_web_http_server_content_get_extended(&http_server, &packet, 0, buffer, sizeof(buffer), &content_size);
1553 EXPECT_EQ(NX_PTR_ERROR, status);
1554
1555 /* Create web server instance for test. */
1556 status = nx_web_http_server_create(&http_server, "nx_web_http_server_content_get_extended",
1557 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1558 stack_memory, stack_size, &pool_0,
1559 server_auth_check, server_req_notify);
1560
1561 status = nx_web_http_server_content_get_extended(NX_NULL, &packet, 0, buffer, sizeof(buffer), &content_size);
1562 EXPECT_EQ(NX_PTR_ERROR, status);
1563
1564 status = nx_web_http_server_content_get_extended(&http_server, NX_NULL, 0, buffer, sizeof(buffer), &content_size);
1565 EXPECT_EQ(NX_PTR_ERROR, status);
1566
1567 status = nx_web_http_server_content_get_extended(&http_server, &packet, 0, NX_NULL, sizeof(buffer), &content_size);
1568 EXPECT_EQ(NX_PTR_ERROR, status);
1569
1570 status = nx_web_http_server_content_get_extended(&http_server, &packet, 0, buffer, sizeof(buffer), NX_NULL);
1571 EXPECT_EQ(NX_PTR_ERROR, status);
1572
1573 status = nx_web_http_server_delete(&http_server);
1574 EXPECT_EQ(NX_SUCCESS, status);
1575
1576 if(error_counter > 0)
1577 {
1578 return(1);
1579 }
1580
1581 return(NX_SUCCESS);
1582 }
1583
nx_web_http_server_content_length_get_test(VOID * stack_memory,UINT stack_size)1584 UINT nx_web_http_server_content_length_get_test(VOID *stack_memory, UINT stack_size)
1585 {
1586 NX_PACKET packet;
1587 ULONG length;
1588 UINT status;
1589 UINT error_counter = 0;
1590
1591 status = nx_web_http_server_content_length_get(NX_NULL, &length);
1592 EXPECT_EQ(NX_PTR_ERROR, status);
1593
1594 status = nx_web_http_server_content_length_get(&packet, NX_NULL);
1595 EXPECT_EQ(NX_PTR_ERROR, status);
1596
1597 if(error_counter > 0)
1598 {
1599 return(1);
1600 }
1601
1602 return(NX_SUCCESS);
1603 }
1604
1605 #ifdef NX_WEB_HTTP_MULTIPART_ENABLE
nx_web_http_server_get_entity_header_test(VOID * stack_memory,UINT stack_size)1606 UINT nx_web_http_server_get_entity_header_test(VOID *stack_memory, UINT stack_size)
1607 {
1608 NX_WEB_HTTP_SERVER http_server;
1609 NX_PACKET *packet_ptr;
1610 UCHAR buffer[100];
1611 UINT status;
1612 UINT error_counter = 0;
1613
1614 status = nx_web_http_server_get_entity_header(&http_server, &packet_ptr, buffer, sizeof(buffer));
1615 EXPECT_EQ(NX_PTR_ERROR, status);
1616
1617 /* Create web server instance for test. */
1618 status = nx_web_http_server_create(&http_server, "nx_web_http_server_get_entity_header",
1619 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1620 stack_memory, stack_size, &pool_0,
1621 server_auth_check, server_req_notify);
1622
1623 status = nx_web_http_server_get_entity_header(NX_NULL, &packet_ptr, buffer, sizeof(buffer));
1624 EXPECT_EQ(NX_PTR_ERROR, status);
1625
1626 status = nx_web_http_server_get_entity_header(&http_server, NX_NULL, buffer, sizeof(buffer));
1627 EXPECT_EQ(NX_PTR_ERROR, status);
1628
1629 status = nx_web_http_server_get_entity_header(&http_server, &packet_ptr, NX_NULL, sizeof(buffer));
1630 EXPECT_EQ(NX_PTR_ERROR, status);
1631
1632 status = nx_web_http_server_delete(&http_server);
1633 EXPECT_EQ(NX_SUCCESS, status);
1634
1635 if(error_counter > 0)
1636 {
1637 return(1);
1638 }
1639
1640 return(NX_SUCCESS);
1641 }
1642
nx_web_http_server_get_entity_content_test(VOID * stack_memory,UINT stack_size)1643 UINT nx_web_http_server_get_entity_content_test(VOID *stack_memory, UINT stack_size)
1644 {
1645 NX_WEB_HTTP_SERVER http_server;
1646 NX_PACKET *packet_ptr;
1647 ULONG offset;
1648 ULONG length;
1649 UINT status;
1650 UINT error_counter = 0;
1651
1652 status = nx_web_http_server_get_entity_content(&http_server, &packet_ptr, &offset, &length);
1653 EXPECT_EQ(NX_PTR_ERROR, status);
1654
1655 /* Create web server instance for test. */
1656 status = nx_web_http_server_create(&http_server, "nx_web_http_server_get_entity_content",
1657 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1658 stack_memory, stack_size, &pool_0,
1659 server_auth_check, server_req_notify);
1660
1661 status = nx_web_http_server_get_entity_content(NX_NULL, &packet_ptr, &offset, &length);
1662 EXPECT_EQ(NX_PTR_ERROR, status);
1663
1664 status = nx_web_http_server_get_entity_content(&http_server, NX_NULL, &offset, &length);
1665 EXPECT_EQ(NX_PTR_ERROR, status);
1666
1667 status = nx_web_http_server_get_entity_content(&http_server, &packet_ptr, NX_NULL, &length);
1668 EXPECT_EQ(NX_PTR_ERROR, status);
1669
1670 status = nx_web_http_server_get_entity_content(&http_server, &packet_ptr, &offset, NX_NULL);
1671 EXPECT_EQ(NX_PTR_ERROR, status);
1672
1673 status = nx_web_http_server_delete(&http_server);
1674 EXPECT_EQ(NX_SUCCESS, status);
1675
1676 if(error_counter > 0)
1677 {
1678 return(1);
1679 }
1680
1681 return(NX_SUCCESS);
1682 }
1683 #endif
1684
nx_web_http_server_callback_generate_response_header_test(VOID * stack_memory,UINT stack_size)1685 UINT nx_web_http_server_callback_generate_response_header_test(VOID *stack_memory, UINT stack_size)
1686 {
1687 NX_WEB_HTTP_SERVER http_server;
1688 NX_PACKET *packet_ptr;
1689 CHAR *status_code = "404";
1690 CHAR *content_type = "text";
1691 CHAR *header = "header";
1692 UINT status;
1693 UINT error_counter = 0;
1694
1695 status = nx_web_http_server_callback_generate_response_header(&http_server, &packet_ptr, status_code, 100, content_type, header);
1696 EXPECT_EQ(NX_PTR_ERROR, status);
1697
1698 /* Create web server instance for test. */
1699 status = nx_web_http_server_create(&http_server, "nx_web_http_server_callback_generate_response_header",
1700 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1701 stack_memory, stack_size, &pool_0,
1702 server_auth_check, server_req_notify);
1703
1704 status = nx_web_http_server_callback_generate_response_header(NX_NULL, &packet_ptr, status_code, 100, content_type, header);
1705 EXPECT_EQ(NX_PTR_ERROR, status);
1706
1707 status = nx_web_http_server_callback_generate_response_header(&http_server, NX_NULL, status_code, 100, content_type, header);
1708 EXPECT_EQ(NX_PTR_ERROR, status);
1709
1710 status = nx_web_http_server_callback_generate_response_header(&http_server, &packet_ptr, NX_NULL, 100, content_type, header);
1711 EXPECT_EQ(NX_PTR_ERROR, status);
1712
1713 status = nx_web_http_server_delete(&http_server);
1714 EXPECT_EQ(NX_SUCCESS, status);
1715
1716 if(error_counter > 0)
1717 {
1718 return(1);
1719 }
1720
1721 return(NX_SUCCESS);
1722 }
1723
nx_web_http_server_callback_packet_send_test(VOID * stack_memory,UINT stack_size)1724 UINT nx_web_http_server_callback_packet_send_test(VOID *stack_memory, UINT stack_size)
1725 {
1726 NX_WEB_HTTP_SERVER http_server;
1727 NX_PACKET packet;
1728 UINT status;
1729 UINT error_counter = 0;
1730
1731 status = nx_web_http_server_callback_packet_send(&http_server, &packet);
1732 EXPECT_EQ(NX_PTR_ERROR, status);
1733
1734 /* Create web server instance for test. */
1735 status = nx_web_http_server_create(&http_server, "nx_web_http_server_callback_packet_send",
1736 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1737 stack_memory, stack_size, &pool_0,
1738 server_auth_check, server_req_notify);
1739
1740 status = nx_web_http_server_callback_packet_send(NX_NULL, &packet);
1741 EXPECT_EQ(NX_PTR_ERROR, status);
1742
1743 status = nx_web_http_server_callback_packet_send(&http_server, NX_NULL);
1744 EXPECT_EQ(NX_PTR_ERROR, status);
1745
1746 status = nx_web_http_server_delete(&http_server);
1747 EXPECT_EQ(NX_SUCCESS, status);
1748
1749 if(error_counter > 0)
1750 {
1751 return(1);
1752 }
1753
1754 return(NX_SUCCESS);
1755 }
1756
gmt_callback(NX_WEB_HTTP_SERVER_DATE * date)1757 static VOID gmt_callback(NX_WEB_HTTP_SERVER_DATE *date)
1758 {
1759
1760 }
1761
nx_web_http_server_gmt_callback_set_test(VOID * stack_memory,UINT stack_size)1762 UINT nx_web_http_server_gmt_callback_set_test(VOID *stack_memory, UINT stack_size)
1763 {
1764 NX_WEB_HTTP_SERVER http_server;
1765 UINT status;
1766 UINT error_counter = 0;
1767
1768 status = nx_web_http_server_gmt_callback_set(&http_server, gmt_callback);
1769 EXPECT_EQ(NX_PTR_ERROR, status);
1770
1771 /* Create web server instance for test. */
1772 status = nx_web_http_server_create(&http_server, "nx_web_http_server_gmt_callback_set",
1773 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1774 stack_memory, stack_size, &pool_0,
1775 server_auth_check, server_req_notify);
1776
1777 status = nx_web_http_server_gmt_callback_set(NX_NULL, gmt_callback);
1778 EXPECT_EQ(NX_PTR_ERROR, status);
1779
1780 status = nx_web_http_server_gmt_callback_set(&http_server, NX_NULL);
1781 EXPECT_EQ(NX_PTR_ERROR, status);
1782
1783 status = nx_web_http_server_delete(&http_server);
1784 EXPECT_EQ(NX_SUCCESS, status);
1785
1786 if(error_counter > 0)
1787 {
1788 return(1);
1789 }
1790
1791 return(NX_SUCCESS);
1792 }
1793
1794
1795
cache_info_callback(CHAR * resource,UINT * age,NX_WEB_HTTP_SERVER_DATE * date)1796 UINT cache_info_callback(CHAR *resource, UINT *age, NX_WEB_HTTP_SERVER_DATE *date)
1797 {
1798 return(NX_SUCCESS);
1799 }
1800
1801
nx_web_http_server_cache_info_callback_set_test(VOID * stack_memory,UINT stack_size)1802 UINT nx_web_http_server_cache_info_callback_set_test(VOID *stack_memory, UINT stack_size)
1803 {
1804 NX_WEB_HTTP_SERVER http_server;
1805 UINT status;
1806 UINT error_counter = 0;
1807
1808 status = nx_web_http_server_cache_info_callback_set (&http_server, cache_info_callback);
1809 EXPECT_EQ(NX_PTR_ERROR, status);
1810
1811 /* Create web server instance for test. */
1812 status = nx_web_http_server_create(&http_server, "nx_web_http_server_cache_info_callback_set ",
1813 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1814 stack_memory, stack_size, &pool_0,
1815 server_auth_check, server_req_notify);
1816
1817 status = nx_web_http_server_cache_info_callback_set (NX_NULL, cache_info_callback);
1818 EXPECT_EQ(NX_PTR_ERROR, status);
1819
1820 status = nx_web_http_server_cache_info_callback_set (&http_server, NX_NULL);
1821 EXPECT_EQ(NX_PTR_ERROR, status);
1822
1823 status = nx_web_http_server_delete(&http_server);
1824 EXPECT_EQ(NX_SUCCESS, status);
1825
1826 if(error_counter > 0)
1827 {
1828 return(1);
1829 }
1830
1831 return(NX_SUCCESS);
1832 }
1833
nx_web_http_server_mime_maps_additional_set_test(VOID * stack_memory,UINT stack_size)1834 UINT nx_web_http_server_mime_maps_additional_set_test(VOID *stack_memory, UINT stack_size)
1835 {
1836 NX_WEB_HTTP_SERVER http_server;
1837 NX_WEB_HTTP_SERVER_MIME_MAP mime_map;
1838 UINT status;
1839 UINT error_counter = 0;
1840
1841 status = nx_web_http_server_mime_maps_additional_set(&http_server, &mime_map, 1);
1842 EXPECT_EQ(NX_PTR_ERROR, status);
1843
1844 /* Create web server instance for test. */
1845 status = nx_web_http_server_create(&http_server, "nx_web_http_server_mime_maps_additional_set",
1846 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1847 stack_memory, stack_size, &pool_0,
1848 server_auth_check, server_req_notify);
1849
1850 status = nx_web_http_server_mime_maps_additional_set(NX_NULL, &mime_map, 1);
1851 EXPECT_EQ(NX_PTR_ERROR, status);
1852
1853 status = nx_web_http_server_mime_maps_additional_set(&http_server, NX_NULL, 1);
1854 EXPECT_EQ(NX_PTR_ERROR, status);
1855
1856 status = nx_web_http_server_delete(&http_server);
1857 EXPECT_EQ(NX_SUCCESS, status);
1858
1859 if(error_counter > 0)
1860 {
1861 return(1);
1862 }
1863
1864 return(NX_SUCCESS);
1865 }
1866
nx_web_http_server_type_get_test(VOID * stack_memory,UINT stack_size)1867 UINT nx_web_http_server_type_get_test(VOID *stack_memory, UINT stack_size)
1868 {
1869 NX_WEB_HTTP_SERVER http_server;
1870 CHAR name[100];
1871 CHAR type_string[100];
1872 UINT string_size;
1873 UINT status;
1874 UINT error_counter = 0;
1875
1876 status = nx_web_http_server_type_get(&http_server, name, type_string, &string_size);
1877 EXPECT_EQ(NX_PTR_ERROR, status);
1878
1879 /* Create web server instance for test. */
1880 status = nx_web_http_server_create(&http_server, "nx_web_http_server_type_get",
1881 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1882 stack_memory, stack_size, &pool_0,
1883 server_auth_check, server_req_notify);
1884
1885 status = nx_web_http_server_type_get(NX_NULL, name, type_string, &string_size);
1886 EXPECT_EQ(NX_PTR_ERROR, status);
1887
1888 status = nx_web_http_server_type_get(&http_server, NX_NULL, type_string, &string_size);
1889 EXPECT_EQ(NX_PTR_ERROR, status);
1890
1891 status = nx_web_http_server_type_get(&http_server, name, NX_NULL, &string_size);
1892 EXPECT_EQ(NX_PTR_ERROR, status);
1893
1894 status = nx_web_http_server_type_get(&http_server, name, type_string, NX_NULL);
1895 EXPECT_EQ(NX_PTR_ERROR, status);
1896
1897 status = nx_web_http_server_delete(&http_server);
1898 EXPECT_EQ(NX_SUCCESS, status);
1899
1900 if(error_counter > 0)
1901 {
1902 return(1);
1903 }
1904
1905 return(NX_SUCCESS);
1906 }
1907
nx_web_http_server_packet_content_find_test(VOID * stack_memory,UINT stack_size)1908 UINT nx_web_http_server_packet_content_find_test(VOID *stack_memory, UINT stack_size)
1909 {
1910 NX_WEB_HTTP_SERVER http_server;
1911 NX_PACKET *packet_ptr;
1912 ULONG length;
1913 UINT status;
1914 UINT error_counter = 0;
1915
1916 status = nx_web_http_server_packet_content_find(&http_server, &packet_ptr, &length);
1917 EXPECT_EQ(NX_PTR_ERROR, status);
1918
1919 /* Create web server instance for test. */
1920 status = nx_web_http_server_create(&http_server, "nx_web_http_server_packet_content_find",
1921 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1922 stack_memory, stack_size, &pool_0,
1923 server_auth_check, server_req_notify);
1924
1925 status = nx_web_http_server_packet_content_find(NX_NULL, &packet_ptr, &length);
1926 EXPECT_EQ(NX_PTR_ERROR, status);
1927
1928 status = nx_web_http_server_packet_content_find(&http_server, NX_NULL, &length);
1929 EXPECT_EQ(NX_PTR_ERROR, status);
1930
1931 status = nx_web_http_server_packet_content_find(&http_server, &packet_ptr, NX_NULL);
1932 EXPECT_EQ(NX_PTR_ERROR, status);
1933
1934 status = nx_web_http_server_delete(&http_server);
1935 EXPECT_EQ(NX_SUCCESS, status);
1936
1937 if(error_counter > 0)
1938 {
1939 return(1);
1940 }
1941
1942 return(NX_SUCCESS);
1943 }
1944
nx_web_http_server_packet_get_test(VOID * stack_memory,UINT stack_size)1945 UINT nx_web_http_server_packet_get_test(VOID *stack_memory, UINT stack_size)
1946 {
1947 NX_WEB_HTTP_SERVER http_server;
1948 NX_PACKET *packet_ptr;
1949 UINT status;
1950 UINT error_counter = 0;
1951
1952 status = nx_web_http_server_packet_get(&http_server, &packet_ptr);
1953 EXPECT_EQ(NX_PTR_ERROR, status);
1954
1955 /* Create web server instance for test. */
1956 status = nx_web_http_server_create(&http_server, "nx_web_http_server_packet_get",
1957 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1958 stack_memory, stack_size, &pool_0,
1959 server_auth_check, server_req_notify);
1960
1961 status = nx_web_http_server_packet_get(NX_NULL, &packet_ptr);
1962 EXPECT_EQ(NX_PTR_ERROR, status);
1963
1964 status = nx_web_http_server_packet_get(&http_server, NX_NULL);
1965 EXPECT_EQ(NX_PTR_ERROR, status);
1966
1967 status = nx_web_http_server_delete(&http_server);
1968 EXPECT_EQ(NX_SUCCESS, status);
1969
1970 if(error_counter > 0)
1971 {
1972 return(1);
1973 }
1974
1975 return(NX_SUCCESS);
1976 }
1977
invalid_username_password_callback(CHAR * resource,NXD_ADDRESS * client_nxd_address,UINT request_type)1978 static UINT invalid_username_password_callback(CHAR *resource, NXD_ADDRESS *client_nxd_address, UINT request_type)
1979 {
1980 return(NX_SUCCESS);
1981 }
1982
nx_web_http_server_invalid_userpassword_notify_set_test(VOID * stack_memory,UINT stack_size)1983 UINT nx_web_http_server_invalid_userpassword_notify_set_test(VOID *stack_memory, UINT stack_size)
1984 {
1985 NX_WEB_HTTP_SERVER http_server;
1986 UINT status;
1987 UINT error_counter = 0;
1988
1989 /* Create web server instance for test. */
1990 status = nx_web_http_server_create(&http_server, "nx_web_http_server_invalid_userpassword_notify_set",
1991 &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,
1992 stack_memory, stack_size, &pool_0,
1993 server_auth_check, server_req_notify);
1994
1995 status = nx_web_http_server_invalid_userpassword_notify_set(NX_NULL, invalid_username_password_callback);
1996 EXPECT_EQ(NX_PTR_ERROR, status);
1997
1998 status = nx_web_http_server_invalid_userpassword_notify_set(&http_server, NX_NULL);
1999 EXPECT_EQ(NX_PTR_ERROR, status);
2000
2001 status = nx_web_http_server_delete(&http_server);
2002 EXPECT_EQ(NX_SUCCESS, status);
2003
2004 if(error_counter > 0)
2005 {
2006 return(1);
2007 }
2008
2009 return(NX_SUCCESS);
2010 }
2011
2012 /********************************************************************************
2013 * Python used to generate skeleton test cases:
2014 #!/bin/python
2015
2016 def gen_client_tests(input_list):
2017 ret_str = ""
2018 for name in input_list:
2019 ret_str += "\nUINT " + name + "(void)\n{"
2020 ret_str += "\nNX_WEB_HTTP_CLIENT http_client;"
2021 ret_str += "\nUINT status;"
2022 ret_str += "\n "
2023 ret_str += "\n / * Create web server instance for test. * /"
2024 ret_str += "\n status = nx_web_http_client_create(&http_client, \"" + name + "\","
2025 ret_str += "\n &ip_0, &pool_0, TEST_WINDOW_SIZE);"
2026 ret_str += "\n "
2027 ret_str += "\n status = " + name + "(&http_client, );"
2028 ret_str += "\n EXPECT_EQ(NX_PTR_ERROR, status);"
2029 ret_str += "\n "
2030 ret_str += "\n return(NX_SUCCESS);\n}\n"
2031 return ret_str
2032
2033 def gen_server_tests(input_list):
2034 ret_str = ""
2035 for name in input_list:
2036 ret_str += "\nUINT " + name + "_test(VOID *stack_memory, UINT stack_size)\n{"
2037 ret_str += "\nNX_WEB_HTTP_SERVER http_server;"
2038 ret_str += "\nUINT status;"
2039 ret_str += "\n / * Create web server instance for test. * /"
2040 ret_str += "\n status = nx_web_http_server_create(&http_server, \"" + name + "\","
2041 ret_str += "\n &ip_0, NX_WEB_HTTP_SERVER_PORT, NX_NULL,"
2042 ret_str += "\n stack_memory, stack_size, &pool_0,"
2043 ret_str += "\n server_auth_check, server_req_notify);"
2044 ret_str += "\n "
2045 ret_str += "\n status = " + name + "(&http_server, );"
2046 ret_str += "\n EXPECT_EQ(NX_PTR_ERROR, status);"
2047 ret_str += "\n "
2048 ret_str += "\n return(NX_SUCCESS);\n}\n"
2049 return ret_str
2050
2051 def gen_server_prototypes(input_list):
2052 ret_str = ""
2053 for name in input_list:
2054 ret_str += "\nUINT " + name + "_test(VOID *stack_memory, UINT stack_size);"
2055 return ret_str
2056
2057
2058 def gen_client_prototypes(input_list):
2059 ret_str = ""
2060 for name in input_list:
2061 ret_str += "\nUINT " + name + "_test(void);"
2062 return ret_str
2063
2064 def gen_server_calls(input_list):
2065 ret_str = ""
2066 for name in input_list:
2067 ret_str += "\n status = " + name + "_test(stack_memory, sizeof(stack_memory));"
2068 ret_str += "\n if(status != NX_SUCCESS)"
2069 ret_str += "\n {"
2070 ret_str += "\n test_control_return(1);"
2071 ret_str += "\n }"
2072 ret_str += "\n "
2073 return ret_str
2074
2075 def gen_client_calls(input_list):
2076 ret_str = ""
2077 for name in input_list:
2078 ret_str += "\n status = " + name + "_test();"
2079 ret_str += "\n if(status != NX_SUCCESS)"
2080 ret_str += "\n {"
2081 ret_str += "\n test_control_return(1);"
2082 ret_str += "\n }"
2083 ret_str += "\n"
2084 return ret_str
2085
2086 def gen_all_tests():
2087 ret_str = ""
2088 ret_str += gen_client_prototypes(client_api_list)
2089 ret_str += gen_server_prototypes(server_api_list)
2090 ret_str += gen_client_calls(client_api_list)
2091 ret_str += gen_server_calls(server_api_list)
2092 ret_str += gen_client_tests(client_api_list)
2093 ret_str += gen_server_tests(server_api_list)
2094 return ret_str
2095
2096 def write_tests():
2097 f = open("./test.c", "w")
2098 tests = gen_all_tests()
2099 f.write(tests)
2100 f.close()
2101
2102 client_api_list = [ "nx_web_http_client_create",
2103 "nx_web_http_client_delete",
2104 "nx_web_http_client_get_start",
2105 "nx_web_http_client_put_start",
2106 "nx_web_http_client_post_start",
2107 "nx_web_http_client_head_start",
2108 "nx_web_http_client_delete_start",
2109 "nx_web_http_client_get_secure_start",
2110 "nx_web_http_client_put_secure_start",
2111 "nx_web_http_client_post_secure_start",
2112 "nx_web_http_client_head_secure_start",
2113 "nx_web_http_client_delete_secure_start",
2114 "nx_web_http_client_response_body_get",
2115 "nx_web_http_client_put_packet",
2116 "nx_web_http_client_response_header_callback_set",
2117 "nx_web_http_client_request_initialize",
2118 "nx_web_http_client_request_send",
2119 "nx_web_http_client_request_header_add",
2120 "nx_web_http_client_connect",
2121 "nx_web_http_client_secure_connect" ]
2122
2123 server_api_list = [ "nx_web_http_server_callback_data_send",
2124 "nx_web_http_server_callback_response_send",
2125 "nx_web_http_server_content_get",
2126 "nx_web_http_server_create",
2127 "nx_web_http_server_delete",
2128 "nx_web_http_server_param_get",
2129 "nx_web_http_server_query_get",
2130 "nx_web_http_server_start",
2131 "nx_web_http_server_secure_configure",
2132 "nx_web_http_server_stop",
2133 "nx_web_http_server_content_get_extended",
2134 "nx_web_http_server_content_length_get",
2135 "nx_web_http_server_get_entity_header",
2136 "nx_web_http_server_get_entity_content",
2137 "nx_web_http_server_callback_generate_response_header",
2138 "nx_web_http_server_callback_packet_send",
2139 "nx_web_http_server_gmt_callback_set",
2140 "nx_web_http_server_cache_info_callback_set ",
2141 "nx_web_http_server_mime_maps_additional_set",
2142 "nx_web_http_server_type_get",
2143 "nx_web_http_server_packet_content_find",
2144 "nx_web_http_server_packet_get",
2145 "nx_web_http_server_invalid_userpassword_notify_set" ]
2146
2147 */
2148
2149
2150
