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