]> git.proxmox.com Git - mirror_frr.git/blame - pceplib/test/pcep_msg_messages_test.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
pceplib: Clean scan-build static analyzer messages.
[mirror_frr.git] / pceplib / test / pcep_msg_messages_test.c
CommitLineData
74971473
JG		 1/*
2 * This file is part of the PCEPlib, a PCEP protocol library.
3 *
4 * Copyright (C) 2020 Volta Networks https://voltanet.io/
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public License
17 * along with this program. If not, see <https://www.gnu.org/licenses/>.
18 *
19 * Author : Brady Johnson <brady@voltanet.io>
20 *
21 */
22
23
1f8031f7
DL		 24#ifdef HAVE_CONFIG_H
25#include "config.h"
26#endif
27
74971473 28#include <stdlib.h>
fadf00aa 29#include <assert.h>
74971473
JG		 30
31#include <CUnit/CUnit.h>
32
33#include "pcep_msg_encoding.h"
34#include "pcep_msg_messages.h"
35#include "pcep_msg_objects.h"
36#include "pcep_msg_tools.h"
37#include "pcep_utils_double_linked_list.h"
38#include "pcep_utils_memory.h"
39#include "pcep_msg_messages_test.h"
40
41/*
42 * Notice:
43 * All of these message Unit Tests encode the created messages by explicitly
44 * calling pcep_encode_message() thus testing the message creation and the
45 * message encoding.
46 */
47
48static struct pcep_versioning *versioning = NULL;
49
50int pcep_messages_test_suite_setup(void)
51{
52 pceplib_memory_reset();
53 return 0;
54}
55
56int pcep_messages_test_suite_teardown(void)
57{
58 printf("\n");
59 pceplib_memory_dump();
60 return 0;
61}
62
63void pcep_messages_test_setup()
64{
65 versioning = create_default_pcep_versioning();
66}
67
68void pcep_messages_test_teardown()
69{
70 destroy_pcep_versioning(versioning);
71}
72
73void test_pcep_msg_create_open()
74{
75 uint8_t keepalive = 30;
76 uint8_t deadtimer = 60;
77 uint8_t sid = 255;
78
79 struct pcep_message *message =
80 pcep_msg_create_open(keepalive, deadtimer, sid);
81 CU_ASSERT_PTR_NOT_NULL(message);
82 pcep_encode_message(message, versioning);
fadf00aa 83 assert(message != NULL);
74971473
JG		 84 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
85 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 86 assert(message->obj_list != NULL);
74971473
JG		 87 CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
88 CU_ASSERT_EQUAL(message->encoded_message_length,
89 MESSAGE_HEADER_LENGTH
90 + pcep_object_get_length(PCEP_OBJ_CLASS_OPEN,
91 PCEP_OBJ_TYPE_OPEN));
fadf00aa 92 assert(message->msg_header != NULL);
74971473
JG		 93 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_OPEN);
94 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
95 PCEP_MESSAGE_HEADER_VERSION);
96
97 /* Just check the class and type, the rest of the hdr fields
98 * are verified in pcep-objects-test.c */
99 struct pcep_object_open *open_obj =
100 (struct pcep_object_open *)message->obj_list->head->data;
101 CU_ASSERT_EQUAL(open_obj->header.object_class, PCEP_OBJ_CLASS_OPEN);
102 CU_ASSERT_EQUAL(open_obj->header.object_type, PCEP_OBJ_TYPE_OPEN);
103
104 CU_ASSERT_EQUAL(open_obj->open_deadtimer, deadtimer);
105 CU_ASSERT_EQUAL(open_obj->open_keepalive, keepalive);
106 CU_ASSERT_EQUAL(open_obj->open_sid, sid);
107 CU_ASSERT_EQUAL(open_obj->open_version, PCEP_OBJECT_OPEN_VERSION);
108 pcep_msg_free_message(message);
109}
110
111
112void test_pcep_msg_create_request()
113{
114 /* First test with NULL objects */
115 struct pcep_message *message =
116 pcep_msg_create_request(NULL, NULL, NULL);
117 CU_ASSERT_PTR_NULL(message);
118
119 /* Test IPv4 */
120 struct pcep_object_rp *rp_obj =
121 pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
7ed8c4b1 122 struct in_addr src_addr={}, dst_addr={};
74971473
JG		 123 struct pcep_object_endpoints_ipv4 *ipv4_obj =
124 pcep_obj_create_endpoint_ipv4(&src_addr, &dst_addr);
125 message = pcep_msg_create_request(rp_obj, ipv4_obj, NULL);
126
127 CU_ASSERT_PTR_NOT_NULL(message);
128 pcep_encode_message(message, versioning);
fadf00aa 129 assert(message != NULL);
74971473
JG		 130 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
131 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
132 CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
133 CU_ASSERT_EQUAL(
134 message->encoded_message_length,
135 MESSAGE_HEADER_LENGTH
136 + pcep_object_get_length_by_hdr(&rp_obj->header)
137 + pcep_object_get_length_by_hdr(&ipv4_obj->header));
fadf00aa 138 assert(message->msg_header != NULL);
74971473
JG		 139 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREQ);
140 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
141 PCEP_MESSAGE_HEADER_VERSION);
142 pcep_msg_free_message(message);
143
144 /* Test IPv6 */
145 rp_obj = pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
146 struct in6_addr src_addr_ipv6, dst_addr_ipv6;
147 struct pcep_object_endpoints_ipv6 *ipv6_obj =
148 pcep_obj_create_endpoint_ipv6(&src_addr_ipv6, &dst_addr_ipv6);
149 message = pcep_msg_create_request_ipv6(rp_obj, ipv6_obj, NULL);
150
151 CU_ASSERT_PTR_NOT_NULL(message);
152 pcep_encode_message(message, versioning);
fadf00aa 153 assert(message != NULL);
74971473
JG		 154 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
155 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 156 assert(message->obj_list != NULL);
74971473
JG		 157 CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
158 CU_ASSERT_EQUAL(
159 message->encoded_message_length,
160 MESSAGE_HEADER_LENGTH
161 + pcep_object_get_length_by_hdr(&rp_obj->header)
162 + pcep_object_get_length_by_hdr(&ipv6_obj->header));
fadf00aa 163 assert(message->msg_header != NULL);
74971473
JG		 164 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREQ);
165 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
166 PCEP_MESSAGE_HEADER_VERSION);
167 pcep_msg_free_message(message);
168
169 /* The objects get deleted with the message, so they need to be created
170 * again */
171 rp_obj = pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
172 ipv4_obj = pcep_obj_create_endpoint_ipv4(&src_addr, &dst_addr);
173 struct pcep_object_bandwidth *bandwidth_obj =
174 pcep_obj_create_bandwidth(4.2);
175 double_linked_list *obj_list = dll_initialize();
176 dll_append(obj_list, bandwidth_obj);
177 message = pcep_msg_create_request(rp_obj, ipv4_obj, obj_list);
178
179 CU_ASSERT_PTR_NOT_NULL(message);
180 pcep_encode_message(message, versioning);
fadf00aa 181 assert(message != NULL);
74971473
JG		 182 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
183 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 184 assert(message->obj_list != NULL);
74971473
JG		 185 CU_ASSERT_EQUAL(message->obj_list->num_entries, 3);
186 CU_ASSERT_EQUAL(
187 message->encoded_message_length,
188 MESSAGE_HEADER_LENGTH
189 + pcep_object_get_length_by_hdr(&rp_obj->header)
190 + pcep_object_get_length_by_hdr(&ipv4_obj->header)
191 + pcep_object_get_length_by_hdr(
192 &bandwidth_obj->header));
fadf00aa 193 assert(message->msg_header != NULL);
74971473
JG		 194 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREQ);
195 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
196 PCEP_MESSAGE_HEADER_VERSION);
197 pcep_msg_free_message(message);
198}
199
200
201void test_pcep_msg_create_request_svec()
202{
203}
204
205
206void test_pcep_msg_create_reply_nopath()
207{
208 struct pcep_object_rp *rp_obj =
209 pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
210 struct pcep_object_nopath *nopath_obj = pcep_obj_create_nopath(
211 false, false, PCEP_NOPATH_TLV_ERR_NO_TLV);
212 double_linked_list *obj_list = dll_initialize();
213 dll_append(obj_list, nopath_obj);
214
215 struct pcep_message *message = pcep_msg_create_reply(rp_obj, obj_list);
216 CU_ASSERT_PTR_NOT_NULL(message);
217 pcep_encode_message(message, versioning);
fadf00aa 218 assert(message != NULL);
74971473
JG		 219 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
220 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 221 assert(message->obj_list != NULL);
74971473
JG		 222 CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
223 CU_ASSERT_EQUAL(message->encoded_message_length,
224 (MESSAGE_HEADER_LENGTH
225 + pcep_object_get_length_by_hdr(&rp_obj->header)
226 + pcep_object_get_length_by_hdr(&nopath_obj->header)));
fadf00aa 227 assert(message->msg_header != NULL);
74971473
JG		 228 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREP);
229 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
230 PCEP_MESSAGE_HEADER_VERSION);
231 pcep_msg_free_message(message);
232}
233
234
235void test_pcep_msg_create_reply()
236{
237 /* First test with NULL ero and rp objects */
238 struct pcep_message *message = pcep_msg_create_reply(NULL, NULL);
239
240 CU_ASSERT_PTR_NOT_NULL(message);
241 pcep_encode_message(message, versioning);
fadf00aa 242 assert(message != NULL);
74971473
JG		 243 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
244 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
245 CU_ASSERT_EQUAL(message->obj_list->num_entries, 0);
246 CU_ASSERT_EQUAL(message->encoded_message_length, MESSAGE_HEADER_LENGTH);
fadf00aa 247 assert(message->msg_header != NULL);
74971473
JG		 248 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREP);
249 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
250 PCEP_MESSAGE_HEADER_VERSION);
251 pcep_msg_free_message(message);
252
253 double_linked_list *ero_subobj_list = dll_initialize();
254 struct pcep_object_ro_subobj *ero_subobj =
255 (struct pcep_object_ro_subobj *)
256 pcep_obj_create_ro_subobj_32label(true, 1, 10);
257 dll_append(ero_subobj_list, ero_subobj);
258 struct pcep_object_ro *ero = pcep_obj_create_ero(ero_subobj_list);
259
260 double_linked_list *object_list = dll_initialize();
261 dll_append(object_list, ero);
262 struct pcep_object_rp *rp_obj =
263 pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
264 message = pcep_msg_create_reply(rp_obj, object_list);
265 CU_ASSERT_PTR_NOT_NULL(message);
266 pcep_encode_message(message, versioning);
267 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
268 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 269 assert(message->obj_list != NULL);
74971473
JG		 270 CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
271 CU_ASSERT_EQUAL(message->encoded_message_length,
272 MESSAGE_HEADER_LENGTH
273 + pcep_object_get_length_by_hdr(&rp_obj->header)
274 + OBJECT_HEADER_LENGTH
275 + OBJECT_RO_SUBOBJ_HEADER_LENGTH
276 + 6 /* size of the 32label */);
277 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREP);
278 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
279 PCEP_MESSAGE_HEADER_VERSION);
280 pcep_msg_free_message(message);
281}
282
283
284void test_pcep_msg_create_close()
285{
286 uint8_t reason = PCEP_CLOSE_REASON_UNREC_MSG;
287
288 struct pcep_message *message = pcep_msg_create_close(reason);
289 CU_ASSERT_PTR_NOT_NULL(message);
290 pcep_encode_message(message, versioning);
fadf00aa 291 assert(message != NULL);
74971473
JG		 292 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
293 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 294 assert(message->obj_list != NULL);
74971473
JG		 295 CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
296 CU_ASSERT_EQUAL(message->encoded_message_length,
297 MESSAGE_HEADER_LENGTH
298 + pcep_object_get_length(PCEP_OBJ_CLASS_CLOSE,
299 PCEP_OBJ_TYPE_CLOSE));
fadf00aa 300 assert(message->msg_header != NULL);
74971473
JG		 301 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_CLOSE);
302 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
303 PCEP_MESSAGE_HEADER_VERSION);
304
305 /* Just check the class and type, the rest of the hdr fields
306 * are verified in pcep-objects-test.c */
307 struct pcep_object_close *close_obj =
308 (struct pcep_object_close *)message->obj_list->head->data;
fadf00aa 309 assert(close_obj != NULL);
74971473
JG		 310 CU_ASSERT_EQUAL(close_obj->header.object_class, PCEP_OBJ_CLASS_CLOSE);
311 CU_ASSERT_EQUAL(close_obj->header.object_type, PCEP_OBJ_TYPE_CLOSE);
312 CU_ASSERT_EQUAL(close_obj->reason, reason);
313 pcep_msg_free_message(message);
314}
315
316
317void test_pcep_msg_create_error()
318{
319 uint8_t error_type = PCEP_ERRT_RECEPTION_OF_INV_OBJECT;
320 uint8_t error_value = PCEP_ERRV_KEEPALIVEWAIT_TIMED_OUT;
321
322 struct pcep_message *message =
323 pcep_msg_create_error(error_type, error_value);
324 CU_ASSERT_PTR_NOT_NULL(message);
325 pcep_encode_message(message, versioning);
fadf00aa 326 assert(message != NULL);
74971473
JG		 327 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
328 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 329 assert(message->obj_list != NULL);
74971473
JG		 330 CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
331 CU_ASSERT_EQUAL(message->encoded_message_length,
332 MESSAGE_HEADER_LENGTH
333 + pcep_object_get_length(PCEP_OBJ_CLASS_ERROR,
334 PCEP_OBJ_TYPE_ERROR));
fadf00aa 335 assert(message->msg_header != NULL);
74971473
JG		 336 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_ERROR);
337 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
338 PCEP_MESSAGE_HEADER_VERSION);
339
340 /* Just check the class and type, the rest of the hdr fields
341 * are verified in pcep-objects-test.c */
342 struct pcep_object_error *error_obj =
343 (struct pcep_object_error *)message->obj_list->head->data;
344 CU_ASSERT_EQUAL(error_obj->header.object_class, PCEP_OBJ_CLASS_ERROR);
345 CU_ASSERT_EQUAL(error_obj->header.object_type, PCEP_OBJ_TYPE_ERROR);
346
347 CU_ASSERT_EQUAL(error_obj->error_type, error_type);
348 CU_ASSERT_EQUAL(error_obj->error_value, error_value);
349 pcep_msg_free_message(message);
350}
351
352
353void test_pcep_msg_create_keepalive()
354{
355 struct pcep_message *message = pcep_msg_create_keepalive();
356 CU_ASSERT_PTR_NOT_NULL(message);
357 pcep_encode_message(message, versioning);
fadf00aa 358 assert(message != NULL);
74971473
JG		 359 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
360 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 361 assert(message->obj_list != NULL);
74971473
JG		 362 CU_ASSERT_EQUAL(message->obj_list->num_entries, 0);
363 CU_ASSERT_EQUAL(message->encoded_message_length, MESSAGE_HEADER_LENGTH);
fadf00aa 364 assert(message->msg_header != NULL);
74971473
JG		 365 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_KEEPALIVE);
366 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
367 PCEP_MESSAGE_HEADER_VERSION);
368 pcep_msg_free_message(message);
369}
370
371void test_pcep_msg_create_report()
372{
373 double_linked_list *obj_list = dll_initialize();
374
375 /* Should return NULL if obj_list is empty */
376 struct pcep_message *message = pcep_msg_create_report(NULL);
377 CU_ASSERT_PTR_NULL(message);
378
379 struct pcep_object_lsp *lsp =
380 pcep_obj_create_lsp(100, PCEP_LSP_OPERATIONAL_UP, true, true,
381 true, true, true, NULL);
382 dll_append(obj_list, lsp);
383 message = pcep_msg_create_report(obj_list);
384 CU_ASSERT_PTR_NOT_NULL(message);
385 pcep_encode_message(message, versioning);
fadf00aa 386 assert(message != NULL);
74971473
JG		 387 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
388 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 389 assert(message->obj_list != NULL);
74971473
JG		 390 CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
391 CU_ASSERT_EQUAL(message->encoded_message_length,
392 MESSAGE_HEADER_LENGTH
393 + lsp->header.encoded_object_length);
fadf00aa 394 assert(message->msg_header != NULL);
74971473
JG		 395 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_REPORT);
396 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
397 PCEP_MESSAGE_HEADER_VERSION);
398
399 pcep_msg_free_message(message);
400}
401
402void test_pcep_msg_create_update()
403{
404 double_linked_list *obj_list = dll_initialize();
405 double_linked_list *ero_subobj_list = dll_initialize();
406
407 struct pcep_message *message = pcep_msg_create_update(NULL);
408 CU_ASSERT_PTR_NULL(message);
409
410 /* Should return NULL if obj_list is empty */
411 message = pcep_msg_create_update(obj_list);
412 CU_ASSERT_PTR_NULL(message);
7ed8c4b1
JG		 413 if (message != NULL) {
414 pcep_msg_free_message(message);
415 message = NULL;
416 }
74971473
JG		 417
418 struct pcep_object_srp *srp = pcep_obj_create_srp(false, 100, NULL);
419 struct pcep_object_lsp *lsp =
420 pcep_obj_create_lsp(100, PCEP_LSP_OPERATIONAL_UP, true, true,
421 true, true, true, NULL);
422 dll_append(ero_subobj_list, pcep_obj_create_ro_subobj_asn(0x0102));
423 struct pcep_object_ro *ero = pcep_obj_create_ero(ero_subobj_list);
424
425 /* Should return NULL if obj_list does not have 3 entries */
426 dll_append(obj_list, srp);
427 dll_append(obj_list, lsp);
428 message = pcep_msg_create_update(obj_list);
429 CU_ASSERT_PTR_NULL(message);
430
431 dll_append(obj_list, ero);
7ed8c4b1
JG		 432 if (message != NULL) {
433 pcep_msg_free_message(message);
434 message = NULL;
435 }
74971473
JG		 436 message = pcep_msg_create_update(obj_list);
437 CU_ASSERT_PTR_NOT_NULL(message);
438 pcep_encode_message(message, versioning);
fadf00aa 439 assert(message != NULL);
74971473
JG		 440 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
441 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 442 assert(message->obj_list != NULL);
74971473
JG		 443 CU_ASSERT_EQUAL(message->obj_list->num_entries, 3);
444 CU_ASSERT_EQUAL(message->encoded_message_length,
445 MESSAGE_HEADER_LENGTH
446 + srp->header.encoded_object_length
447 + lsp->header.encoded_object_length
448 + ero->header.encoded_object_length);
fadf00aa 449 assert(message->msg_header != NULL);
74971473
JG		 450 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_UPDATE);
451 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
452 PCEP_MESSAGE_HEADER_VERSION);
453
454 pcep_msg_free_message(message);
455}
456
457void test_pcep_msg_create_initiate()
458{
459 double_linked_list *obj_list = dll_initialize();
460 double_linked_list *ero_subobj_list = dll_initialize();
461
462 /* Should return NULL if obj_list is empty */
463 struct pcep_message *message = pcep_msg_create_initiate(NULL);
464 CU_ASSERT_PTR_NULL(message);
7ed8c4b1
JG		 465 if (message != NULL) {
466 pcep_msg_free_message(message);
467 message = NULL;
468 }
74971473
JG		 469
470 struct pcep_object_srp *srp = pcep_obj_create_srp(false, 100, NULL);
471 struct pcep_object_lsp *lsp =
472 pcep_obj_create_lsp(100, PCEP_LSP_OPERATIONAL_UP, true, true,
473 true, true, true, NULL);
474 dll_append(ero_subobj_list, pcep_obj_create_ro_subobj_asn(0x0102));
475 struct pcep_object_ro *ero = pcep_obj_create_ero(ero_subobj_list);
476
477 /* Should return NULL if obj_list does not have 2 entries */
478 dll_append(obj_list, srp);
479 message = pcep_msg_create_initiate(obj_list);
480 CU_ASSERT_PTR_NULL(message);
7ed8c4b1
JG		 481 if (message != NULL) {
482 pcep_msg_free_message(message);
483 message = NULL;
484 }
74971473
JG		 485
486 dll_append(obj_list, lsp);
487 dll_append(obj_list, ero);
488 message = pcep_msg_create_initiate(obj_list);
489 CU_ASSERT_PTR_NOT_NULL(message);
490 pcep_encode_message(message, versioning);
fadf00aa 491 assert(message != NULL);
74971473
JG		 492 CU_ASSERT_PTR_NOT_NULL(message->msg_header);
493 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 494 assert(message->obj_list != NULL);
74971473
JG		 495 CU_ASSERT_EQUAL(message->obj_list->num_entries, 3);
496 CU_ASSERT_EQUAL(message->encoded_message_length,
497 MESSAGE_HEADER_LENGTH
498 + srp->header.encoded_object_length
499 + lsp->header.encoded_object_length
500 + ero->header.encoded_object_length);
fadf00aa 501 assert(message->msg_header != NULL);
74971473
JG		 502 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_INITIATE);
503 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
504 PCEP_MESSAGE_HEADER_VERSION);
505
506 pcep_msg_free_message(message);
507}
508
509void test_pcep_msg_create_notify(void)
510{
511 struct pcep_object_notify *notify_obj = pcep_obj_create_notify(
512 PCEP_NOTIFY_TYPE_PENDING_REQUEST_CANCELLED,
513 PCEP_NOTIFY_VALUE_PCC_CANCELLED_REQUEST);
514
515 /* Should return NULL if the notify obj is empty */
516 struct pcep_message *message = pcep_msg_create_notify(NULL, NULL);
517 CU_ASSERT_PTR_NULL(message);
518
519 message = pcep_msg_create_notify(notify_obj, NULL);
520 CU_ASSERT_PTR_NOT_NULL(message);
521 pcep_encode_message(message, versioning);
fadf00aa 522 assert(message != NULL);
74971473 523 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 524 assert(message->obj_list != NULL);
74971473
JG		 525 CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
526 CU_ASSERT_EQUAL(message->encoded_message_length,
527 MESSAGE_HEADER_LENGTH
528 + notify_obj->header.encoded_object_length);
fadf00aa 529 assert(message->msg_header != NULL);
74971473
JG		 530 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCNOTF);
531 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
532 PCEP_MESSAGE_HEADER_VERSION);
533
534 pcep_msg_free_message(message);
535
536 struct pcep_object_rp *rp_obj =
537 pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
538 double_linked_list *obj_list = dll_initialize();
539 dll_append(obj_list, rp_obj);
540 notify_obj = pcep_obj_create_notify(
541 PCEP_NOTIFY_TYPE_PENDING_REQUEST_CANCELLED,
542 PCEP_NOTIFY_VALUE_PCC_CANCELLED_REQUEST);
543
544 message = pcep_msg_create_notify(notify_obj, obj_list);
545 CU_ASSERT_PTR_NOT_NULL(message);
546 pcep_encode_message(message, versioning);
fadf00aa 547 assert(message != NULL);
74971473 548 CU_ASSERT_PTR_NOT_NULL(message->obj_list);
fadf00aa 549 assert(message->obj_list != NULL);
74971473
JG		 550 CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
551 CU_ASSERT_EQUAL(message->encoded_message_length,
552 MESSAGE_HEADER_LENGTH
553 + notify_obj->header.encoded_object_length
554 + rp_obj->header.encoded_object_length);
555 CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCNOTF);
556 CU_ASSERT_EQUAL(message->msg_header->pcep_version,
557 PCEP_MESSAGE_HEADER_VERSION);
558
559 pcep_msg_free_message(message);
560}
FRRouting mirror