2 * This file is part of the PCEPlib, a PCEP protocol library.
4 * Copyright (C) 2020 Volta Networks https://voltanet.io/
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.
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.
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/>.
19 * Author : Brady Johnson <brady@voltanet.io>
31 #include <sys/types.h>
35 #include <CUnit/CUnit.h>
37 #include "pcep_msg_encoding.h"
38 #include "pcep_msg_messages.h"
39 #include "pcep_msg_tools.h"
40 #include "pcep_msg_tools_test.h"
41 #include "pcep_utils_double_linked_list.h"
42 #include "pcep_utils_logging.h"
43 #include "pcep_utils_memory.h"
45 const uint8_t any_obj_class
= 255;
47 uint16_t pcep_open_hexbyte_strs_length
= 28;
48 const char *pcep_open_odl_hexbyte_strs
[] = {
49 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e",
50 "78", "55", "00", "10", "00", "04", "00", "00", "00", "3f",
51 "00", "1a", "00", "04", "00", "00", "00", "00"};
53 /* PCEP INITIATE str received from ODL with 4 objects: [SRP, LSP, Endpoints,
54 * ERO] The LSP has a SYMBOLIC_PATH_NAME TLV. The ERO has 2 IPV4 Endpoints. */
55 uint16_t pcep_initiate_hexbyte_strs_length
= 68;
56 const char *pcep_initiate_hexbyte_strs
[] = {
57 "20", "0c", "00", "44", "21", "12", "00", "0c", "00", "00", "00", "00",
58 "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
59 "00", "11", "00", "08", "66", "61", "39", "33", "33", "39", "32", "39",
60 "04", "10", "00", "0c", "7f", "00", "00", "01", "28", "28", "28", "28",
61 "07", "10", "00", "14", "01", "08", "0a", "00", "01", "01", "18", "00",
62 "01", "08", "0a", "00", "07", "04", "18", "00"};
64 uint16_t pcep_initiate2_hexbyte_strs_length
= 72;
65 const char *pcep_initiate2_hexbyte_strs
[] = {
66 "20", "0c", "00", "48", "21", "12", "00", "14", "00", "00", "00", "00",
67 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
68 "20", "10", "00", "14", "00", "00", "00", "09", "00", "11", "00", "08",
69 "36", "65", "31", "31", "38", "39", "32", "31", "04", "10", "00", "0c",
70 "c0", "a8", "14", "05", "01", "01", "01", "01", "07", "10", "00", "10",
71 "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
73 uint16_t pcep_update_hexbyte_strs_length
= 48;
74 const char *pcep_update_hexbyte_strs
[] = {
75 "20", "0b", "00", "30", "21", "12", "00", "14", "00", "00", "00", "00",
76 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
77 "20", "10", "00", "08", "00", "02", "a0", "09", "07", "10", "00", "10",
78 "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
80 /* Test that pcep_msg_read() can read multiple messages in 1 call */
81 uint16_t pcep_open_initiate_hexbyte_strs_length
= 100;
82 const char *pcep_open_initiate_odl_hexbyte_strs
[] = {
83 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e", "78", "55",
84 "00", "10", "00", "04", "00", "00", "00", "3f", "00", "1a", "00", "04",
85 "00", "00", "00", "00", "20", "0c", "00", "48", "21", "12", "00", "14",
86 "00", "00", "00", "00", "00", "00", "00", "01", "00", "1c", "00", "04",
87 "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
88 "00", "11", "00", "08", "36", "65", "31", "31", "38", "39", "32", "31",
89 "04", "10", "00", "0c", "c0", "a8", "14", "05", "01", "01", "01", "01",
90 "07", "10", "00", "10", "05", "0c", "10", "01", "03", "e8", "a0", "00",
91 "01", "01", "01", "01"};
93 uint16_t pcep_open_cisco_pce_hexbyte_strs_length
= 28;
94 const char *pcep_open_cisco_pce_hexbyte_strs
[] = {
95 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "3c",
96 "78", "00", "00", "10", "00", "04", "00", "00", "00", "05",
97 "00", "1a", "00", "04", "00", "00", "00", "0a"};
99 uint16_t pcep_update_cisco_pce_hexbyte_strs_length
= 100;
100 const char *pcep_update_cisco_pce_hexbyte_strs
[] = {
101 "20", "0b", "00", "64", "21", "10", "00", "14", "00", "00", "00", "00",
102 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
103 "20", "10", "00", "18", "80", "00", "f0", "89", "00", "07", "00", "0c",
104 "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
105 "07", "10", "00", "28", "24", "0c", "10", "01", "04", "65", "50", "00",
106 "0a", "0a", "0a", "05", "24", "0c", "10", "01", "04", "65", "20", "00",
107 "0a", "0a", "0a", "02", "24", "0c", "10", "01", "04", "65", "10", "00",
108 "0a", "0a", "0a", "01", "06", "10", "00", "0c", "00", "00", "00", "02",
109 "41", "f0", "00", "00"};
111 uint16_t pcep_report_cisco_pcc_hexbyte_strs_length
= 148;
112 const char *pcep_report_cisco_pcc_hexbyte_strs
[] = {
113 "20", "0a", "00", "94", "21", "10", "00", "14", "00", "00", "00", "00",
114 "00", "00", "00", "00", "00", "1c", "00", "04", "00", "00", "00", "01",
115 "20", "10", "00", "3c", "80", "00", "f0", "09", "00", "12", "00", "10",
116 "0a", "0a", "0a", "06", "00", "02", "00", "0f", "0a", "0a", "0a", "06",
117 "0a", "0a", "0a", "01", "00", "11", "00", "0d", "63", "66", "67", "5f",
118 "52", "36", "2d", "74", "6f", "2d", "52", "31", "00", "00", "00", "00",
119 "ff", "e1", "00", "06", "00", "00", "05", "dd", "70", "00", "00", "00",
120 "07", "10", "00", "04", "09", "10", "00", "14", "00", "00", "00", "00",
121 "00", "00", "00", "00", "00", "00", "00", "00", "07", "07", "01", "00",
122 "05", "12", "00", "08", "00", "00", "00", "00", "05", "52", "00", "08",
123 "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "00", "02",
124 "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "01", "04",
125 "41", "80", "00", "00"};
127 /* Cisco PcInitiate with the following objects:
128 * SRP, LSP, Endpoint, Inter-layer, Switch-layer, ERO
130 uint16_t pcep_initiate_cisco_pcc_hexbyte_strs_length
= 104;
131 const char *pcep_initiate_cisco_pcc_hexbyte_strs
[] = {
132 "20", "0c", "00", "68", "21", "10", "00", "14", "00", "00", "00", "00",
133 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
134 "20", "10", "00", "30", "00", "00", "00", "89", "00", "11", "00", "13",
135 "50", "4f", "4c", "31", "5f", "50", "43", "49", "4e", "49", "54", "41",
136 "54", "45", "5f", "54", "45", "53", "54", "00", "00", "07", "00", "0c",
137 "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
138 "04", "10", "00", "0c", "0a", "0a", "0a", "0a", "0a", "0a", "0a", "04",
139 "24", "10", "00", "08", "00", "00", "01", "4d", "25", "10", "00", "08",
140 "00", "00", "00", "64", "07", "10", "00", "04"};
142 struct pcep_message
*create_message(uint8_t msg_type
, uint8_t obj1_class
,
143 uint8_t obj2_class
, uint8_t obj3_class
,
145 int convert_hexstrs_to_binary(const char *hexbyte_strs
[],
146 uint16_t hexbyte_strs_length
);
148 int pcep_tools_test_suite_setup(void)
150 pceplib_memory_reset();
154 int pcep_tools_test_suite_teardown(void)
157 pceplib_memory_dump();
161 void pcep_tools_test_setup(void)
165 void pcep_tools_test_teardown(void)
169 /* Reads an array of hexbyte strs, and writes them to a temporary file.
170 * The caller should close the returned file. */
171 int convert_hexstrs_to_binary(const char *hexbyte_strs
[],
172 uint16_t hexbyte_strs_length
)
175 oldumask
= umask(S_IXUSR
|S_IXGRP
|S_IWOTH
|S_IROTH
|S_IXOTH
);
176 /* Set umask before anything for security */
178 char tmpfile
[] = "/tmp/pceplib_XXXXXX";
179 int fd
= mkstemp(tmpfile
);
185 for (; i
< hexbyte_strs_length
; i
++) {
186 uint8_t byte
= (uint8_t)strtol(hexbyte_strs
[i
], 0, 16);
187 if (write(fd
, (char *)&byte
, 1) < 0) {
192 /* Go back to the beginning of the file */
193 lseek(fd
, 0, SEEK_SET
);
197 static bool pcep_obj_has_tlv(struct pcep_object_header
*obj_hdr
)
199 if (obj_hdr
->tlv_list
== NULL
) {
203 return (obj_hdr
->tlv_list
->num_entries
> 0);
206 void test_pcep_msg_read_pcep_initiate()
208 int fd
= convert_hexstrs_to_binary(pcep_initiate_hexbyte_strs
,
209 pcep_initiate_hexbyte_strs_length
);
211 CU_ASSERT_TRUE(fd
>=0);
214 double_linked_list
*msg_list
= pcep_msg_read(fd
);
215 CU_ASSERT_PTR_NOT_NULL(msg_list
);
216 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
218 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
219 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
220 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
221 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
222 pcep_initiate_hexbyte_strs_length
);
224 /* Verify each of the object types */
227 double_linked_list_node
*node
= msg
->obj_list
->head
;
228 struct pcep_object_header
*obj_hdr
=
229 (struct pcep_object_header
*)node
->data
;
230 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
231 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
232 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
233 pcep_object_get_length_by_hdr(obj_hdr
));
234 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
236 /* LSP object and its TLV*/
237 node
= node
->next_node
;
238 obj_hdr
= (struct pcep_object_header
*)node
->data
;
239 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
240 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
241 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
242 CU_ASSERT_EQUAL(((struct pcep_object_lsp
*)obj_hdr
)->plsp_id
, 0);
243 CU_ASSERT_TRUE(((struct pcep_object_lsp
*)obj_hdr
)->flag_d
);
244 CU_ASSERT_TRUE(((struct pcep_object_lsp
*)obj_hdr
)->flag_a
);
245 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_s
);
246 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_r
);
247 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_c
);
250 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
251 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
252 struct pcep_object_tlv_header
*tlv
=
253 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
254 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
255 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 8);
257 /* Endpoints object */
258 node
= node
->next_node
;
259 obj_hdr
= (struct pcep_object_header
*)node
->data
;
260 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ENDPOINTS
);
261 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
262 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
263 pcep_object_get_length_by_hdr(obj_hdr
));
264 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
267 node
= node
->next_node
;
268 obj_hdr
= (struct pcep_object_header
*)node
->data
;
269 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
270 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
271 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
274 double_linked_list
*ero_subobj_list
=
275 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
276 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
277 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 2);
278 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
279 struct pcep_object_ro_subobj
*subobj_hdr
=
280 (struct pcep_object_ro_subobj
*)subobj_node
->data
;
281 CU_ASSERT_EQUAL(subobj_hdr
->ro_subobj_type
, RO_SUBOBJ_TYPE_IPV4
);
282 struct in_addr ero_subobj_ip
;
283 inet_pton(AF_INET
, "10.0.1.1", &ero_subobj_ip
);
285 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->ip_addr
.s_addr
,
286 ero_subobj_ip
.s_addr
);
288 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->prefix_length
, 24);
291 (struct pcep_object_ro_subobj
*)subobj_node
->next_node
->data
;
292 CU_ASSERT_EQUAL(subobj_hdr
->ro_subobj_type
, RO_SUBOBJ_TYPE_IPV4
);
293 inet_pton(AF_INET
, "10.0.7.4", &ero_subobj_ip
);
295 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->ip_addr
.s_addr
,
296 ero_subobj_ip
.s_addr
);
298 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->prefix_length
, 24);
300 pcep_msg_free_message_list(msg_list
);
305 void test_pcep_msg_read_pcep_initiate2()
307 int fd
= convert_hexstrs_to_binary(pcep_initiate2_hexbyte_strs
,
308 pcep_initiate2_hexbyte_strs_length
);
310 CU_ASSERT_TRUE(fd
>=0);
313 double_linked_list
*msg_list
= pcep_msg_read(fd
);
314 CU_ASSERT_PTR_NOT_NULL(msg_list
);
315 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
317 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
318 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
319 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
320 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
321 pcep_initiate2_hexbyte_strs_length
);
323 /* Verify each of the object types */
326 double_linked_list_node
*node
= msg
->obj_list
->head
;
327 struct pcep_object_header
*obj_hdr
=
328 (struct pcep_object_header
*)node
->data
;
329 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
330 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
331 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
332 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
333 /* TODO test the TLVs */
335 /* LSP object and its TLV*/
336 node
= node
->next_node
;
337 obj_hdr
= (struct pcep_object_header
*)node
->data
;
338 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
339 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
340 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
343 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
344 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
345 struct pcep_object_tlv_header
*tlv
=
346 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
347 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
348 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 8);
350 /* Endpoints object */
351 node
= node
->next_node
;
352 obj_hdr
= (struct pcep_object_header
*)node
->data
;
353 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ENDPOINTS
);
354 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
355 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
356 pcep_object_get_length_by_hdr(obj_hdr
));
357 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
360 node
= node
->next_node
;
361 obj_hdr
= (struct pcep_object_header
*)node
->data
;
362 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
363 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
364 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 16);
367 double_linked_list
*ero_subobj_list
=
368 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
369 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
370 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 0);
371 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
372 CU_ASSERT_PTR_NULL(subobj_node
);
373 /* We no longer support draft07 SR sub-object type=5, and only support
374 type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
375 pcep_object_ro_subobj *) subobj_node->data;
376 CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
377 struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
378 subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
379 PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
380 CU_ASSERT_FALSE(subobj_sr->flag_c);
381 CU_ASSERT_FALSE(subobj_sr->flag_s);
382 CU_ASSERT_FALSE(subobj_sr->flag_f);
383 CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
384 CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
388 pcep_msg_free_message_list(msg_list
);
392 void test_pcep_msg_read_pcep_open()
394 int fd
= convert_hexstrs_to_binary(pcep_open_odl_hexbyte_strs
,
395 pcep_open_hexbyte_strs_length
);
397 CU_ASSERT_TRUE(fd
>=0);
400 double_linked_list
*msg_list
= pcep_msg_read(fd
);
401 CU_ASSERT_PTR_NOT_NULL(msg_list
);
402 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
404 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
405 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
406 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
407 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
408 pcep_open_hexbyte_strs_length
);
410 /* Verify the Open message */
411 struct pcep_object_header
*obj_hdr
=
412 (struct pcep_object_header
*)msg
->obj_list
->head
->data
;
413 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_OPEN
);
414 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_OPEN
);
415 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 24);
416 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
418 /* Open TLV: Stateful PCE Capability */
419 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 2);
420 double_linked_list_node
*tlv_node
= obj_hdr
->tlv_list
->head
;
421 struct pcep_object_tlv_header
*tlv
=
422 (struct pcep_object_tlv_header
*)tlv_node
->data
;
423 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY
);
424 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
426 /* Open TLV: SR PCE Capability */
427 tlv_node
= tlv_node
->next_node
;
428 tlv
= (struct pcep_object_tlv_header
*)tlv_node
->data
;
429 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY
);
430 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
432 pcep_msg_free_message_list(msg_list
);
436 void test_pcep_msg_read_pcep_update()
438 int fd
= convert_hexstrs_to_binary(pcep_update_hexbyte_strs
,
439 pcep_update_hexbyte_strs_length
);
441 CU_ASSERT_TRUE(fd
>=0);
444 double_linked_list
*msg_list
= pcep_msg_read(fd
);
445 CU_ASSERT_PTR_NOT_NULL(msg_list
);
446 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
448 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
449 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 3);
451 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_UPDATE
);
452 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
453 pcep_update_hexbyte_strs_length
);
455 /* Verify each of the object types */
457 double_linked_list_node
*node
= msg
->obj_list
->head
;
460 struct pcep_object_header
*obj_hdr
=
461 (struct pcep_object_header
*)node
->data
;
462 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
463 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
464 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
465 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
468 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
469 struct pcep_object_tlv_header
*tlv
=
470 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
471 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
472 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
473 /* TODO verify the path setup type */
476 node
= node
->next_node
;
477 obj_hdr
= (struct pcep_object_header
*)node
->data
;
478 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
479 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
480 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
481 pcep_object_get_length_by_hdr(obj_hdr
));
482 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
485 node
= node
->next_node
;
486 obj_hdr
= (struct pcep_object_header
*)node
->data
;
487 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
488 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
489 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 16);
492 double_linked_list
*ero_subobj_list
=
493 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
494 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
495 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 0);
496 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
497 CU_ASSERT_PTR_NULL(subobj_node
);
498 /* We no longer support draft07 SR sub-object type=5, and only support
499 type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
500 pcep_object_ro_subobj *) subobj_node->data;
501 CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
502 struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
503 subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
504 PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
505 CU_ASSERT_FALSE(subobj_sr->flag_c);
506 CU_ASSERT_FALSE(subobj_sr->flag_s);
507 CU_ASSERT_FALSE(subobj_sr->flag_f);
508 CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
509 CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
513 pcep_msg_free_message_list(msg_list
);
517 void test_pcep_msg_read_pcep_open_initiate()
519 int fd
= convert_hexstrs_to_binary(
520 pcep_open_initiate_odl_hexbyte_strs
,
521 pcep_open_initiate_hexbyte_strs_length
);
523 CU_ASSERT_TRUE(fd
>=0);
526 double_linked_list
*msg_list
= pcep_msg_read(fd
);
527 CU_ASSERT_PTR_NOT_NULL(msg_list
);
528 CU_ASSERT_EQUAL(msg_list
->num_entries
, 2);
530 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
531 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
532 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
533 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
534 pcep_open_hexbyte_strs_length
);
536 msg
= (struct pcep_message
*)msg_list
->head
->next_node
->data
;
537 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
538 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
539 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
540 pcep_initiate2_hexbyte_strs_length
);
542 pcep_msg_free_message_list(msg_list
);
546 void test_pcep_msg_read_pcep_open_cisco_pce()
548 int fd
= convert_hexstrs_to_binary(
549 pcep_open_cisco_pce_hexbyte_strs
,
550 pcep_open_cisco_pce_hexbyte_strs_length
);
552 CU_ASSERT_TRUE(fd
>=0);
555 double_linked_list
*msg_list
= pcep_msg_read(fd
);
556 CU_ASSERT_PTR_NOT_NULL(msg_list
);
557 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
559 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
560 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
561 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
562 pcep_open_hexbyte_strs_length
);
563 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
566 struct pcep_object_open
*open
=
567 (struct pcep_object_open
*)msg
->obj_list
->head
->data
;
568 CU_ASSERT_EQUAL(open
->header
.object_class
, PCEP_OBJ_CLASS_OPEN
);
569 CU_ASSERT_EQUAL(open
->header
.object_type
, PCEP_OBJ_TYPE_OPEN
);
570 CU_ASSERT_EQUAL(open
->header
.encoded_object_length
, 24);
571 CU_ASSERT_EQUAL(open
->open_deadtimer
, 120);
572 CU_ASSERT_EQUAL(open
->open_keepalive
, 60);
573 CU_ASSERT_EQUAL(open
->open_sid
, 0);
574 CU_ASSERT_EQUAL(open
->open_version
, 1);
575 CU_ASSERT_PTR_NOT_NULL(open
->header
.tlv_list
);
576 CU_ASSERT_EQUAL(open
->header
.tlv_list
->num_entries
, 2);
578 /* Stateful PCE Capability TLV */
579 double_linked_list_node
*tlv_node
= open
->header
.tlv_list
->head
;
580 struct pcep_object_tlv_stateful_pce_capability
*pce_cap_tlv
=
581 (struct pcep_object_tlv_stateful_pce_capability
*)
583 CU_ASSERT_EQUAL(pce_cap_tlv
->header
.type
,
584 PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY
);
585 CU_ASSERT_EQUAL(pce_cap_tlv
->header
.encoded_tlv_length
, 4);
586 CU_ASSERT_TRUE(pce_cap_tlv
->flag_u_lsp_update_capability
);
587 CU_ASSERT_TRUE(pce_cap_tlv
->flag_i_lsp_instantiation_capability
);
588 CU_ASSERT_FALSE(pce_cap_tlv
->flag_s_include_db_version
);
589 CU_ASSERT_FALSE(pce_cap_tlv
->flag_t_triggered_resync
);
590 CU_ASSERT_FALSE(pce_cap_tlv
->flag_d_delta_lsp_sync
);
591 CU_ASSERT_FALSE(pce_cap_tlv
->flag_f_triggered_initial_sync
);
593 /* SR PCE Capability TLV */
594 tlv_node
= tlv_node
->next_node
;
595 struct pcep_object_tlv_sr_pce_capability
*sr_pce_cap_tlv
=
596 (struct pcep_object_tlv_sr_pce_capability
*)tlv_node
->data
;
597 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->header
.type
,
598 PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY
);
599 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->header
.encoded_tlv_length
, 4);
600 CU_ASSERT_FALSE(sr_pce_cap_tlv
->flag_n
);
601 CU_ASSERT_FALSE(sr_pce_cap_tlv
->flag_x
);
602 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->max_sid_depth
, 10);
604 pcep_msg_free_message_list(msg_list
);
608 void test_pcep_msg_read_pcep_update_cisco_pce()
610 int fd
= convert_hexstrs_to_binary(
611 pcep_update_cisco_pce_hexbyte_strs
,
612 pcep_update_cisco_pce_hexbyte_strs_length
);
614 CU_ASSERT_TRUE(fd
>=0);
617 double_linked_list
*msg_list
= pcep_msg_read(fd
);
618 CU_ASSERT_PTR_NOT_NULL(msg_list
);
619 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
621 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
622 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_UPDATE
);
623 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
624 pcep_update_cisco_pce_hexbyte_strs_length
);
625 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
628 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
629 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
630 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
631 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
632 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
633 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
634 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
635 CU_ASSERT_EQUAL(srp
->srp_id_number
, 1);
636 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
638 /* SRP Path Setup Type TLV */
639 double_linked_list_node
*tlv_node
= srp
->header
.tlv_list
->head
;
640 struct pcep_object_tlv_path_setup_type
*pst_tlv
=
641 (struct pcep_object_tlv_path_setup_type
*)tlv_node
->data
;
642 CU_ASSERT_EQUAL(pst_tlv
->header
.type
,
643 PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
644 CU_ASSERT_EQUAL(pst_tlv
->header
.encoded_tlv_length
, 4);
645 CU_ASSERT_EQUAL(pst_tlv
->path_setup_type
, 1);
648 obj_node
= obj_node
->next_node
;
649 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
650 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
651 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
652 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 24);
653 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
654 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 1);
655 CU_ASSERT_EQUAL(lsp
->plsp_id
, 524303);
656 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
657 CU_ASSERT_TRUE(lsp
->flag_a
);
658 CU_ASSERT_TRUE(lsp
->flag_c
);
659 CU_ASSERT_TRUE(lsp
->flag_d
);
660 CU_ASSERT_FALSE(lsp
->flag_r
);
661 CU_ASSERT_FALSE(lsp
->flag_s
);
663 /* LSP Vendor Info TLV */
664 tlv_node
= lsp
->header
.tlv_list
->head
;
665 struct pcep_object_tlv_vendor_info
*vendor_tlv
=
666 (struct pcep_object_tlv_vendor_info
*)tlv_node
->data
;
667 CU_ASSERT_EQUAL(vendor_tlv
->header
.type
, PCEP_OBJ_TLV_TYPE_VENDOR_INFO
);
668 CU_ASSERT_EQUAL(vendor_tlv
->header
.encoded_tlv_length
, 12);
669 CU_ASSERT_EQUAL(vendor_tlv
->enterprise_number
, 9);
670 CU_ASSERT_EQUAL(vendor_tlv
->enterprise_specific_info
, 0x00030004);
673 obj_node
= obj_node
->next_node
;
674 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
675 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
676 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
677 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 40);
678 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
679 CU_ASSERT_PTR_NOT_NULL(ero
->sub_objects
);
680 CU_ASSERT_EQUAL(ero
->sub_objects
->num_entries
, 3);
683 double_linked_list_node
*ero_subobj_node
= ero
->sub_objects
->head
;
684 struct pcep_ro_subobj_sr
*sr_subobj_ipv4_node
=
685 (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
686 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
688 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
689 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
690 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
691 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
692 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
693 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
694 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
695 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73748480);
697 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
700 ero_subobj_node
= ero_subobj_node
->next_node
;
701 sr_subobj_ipv4_node
= (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
702 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
704 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
705 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
706 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
707 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
708 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
709 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
710 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
711 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73736192);
713 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
716 ero_subobj_node
= ero_subobj_node
->next_node
;
717 sr_subobj_ipv4_node
= (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
718 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
720 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
721 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
722 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
723 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
724 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
725 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
726 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
727 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73732096);
729 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
733 obj_node
= obj_node
->next_node
;
734 struct pcep_object_metric
*metric
=
735 (struct pcep_object_metric
*)obj_node
->data
;
736 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
737 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
738 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
739 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
740 CU_ASSERT_FALSE(metric
->flag_b
);
741 CU_ASSERT_FALSE(metric
->flag_c
);
742 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_TE
);
743 CU_ASSERT_EQUAL(metric
->value
, 30.0);
745 pcep_msg_free_message_list(msg_list
);
749 void test_pcep_msg_read_pcep_report_cisco_pcc()
751 int fd
= convert_hexstrs_to_binary(
752 pcep_report_cisco_pcc_hexbyte_strs
,
753 pcep_report_cisco_pcc_hexbyte_strs_length
);
755 CU_ASSERT_TRUE(fd
>=0);
758 double_linked_list
*msg_list
= pcep_msg_read(fd
);
759 CU_ASSERT_PTR_NOT_NULL(msg_list
);
760 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
762 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
763 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_REPORT
);
764 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
765 pcep_report_cisco_pcc_hexbyte_strs_length
);
766 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 8);
769 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
770 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
771 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
772 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
773 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
774 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
775 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
776 CU_ASSERT_EQUAL(srp
->srp_id_number
, 0);
777 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
779 /* SRP Path Setup Type TLV */
780 double_linked_list_node
*tlv_node
= srp
->header
.tlv_list
->head
;
781 struct pcep_object_tlv_path_setup_type
*pst_tlv
=
782 (struct pcep_object_tlv_path_setup_type
*)tlv_node
->data
;
783 CU_ASSERT_EQUAL(pst_tlv
->header
.type
,
784 PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
785 CU_ASSERT_EQUAL(pst_tlv
->header
.encoded_tlv_length
, 4);
786 CU_ASSERT_EQUAL(pst_tlv
->path_setup_type
, 1);
789 obj_node
= obj_node
->next_node
;
790 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
791 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
792 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
793 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 60);
794 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
795 /* The TLV with ID 65505 is not recognized, and its not in the list */
796 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 2);
797 CU_ASSERT_EQUAL(lsp
->plsp_id
, 524303);
798 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
799 CU_ASSERT_TRUE(lsp
->flag_a
);
800 CU_ASSERT_TRUE(lsp
->flag_d
);
801 CU_ASSERT_FALSE(lsp
->flag_c
);
802 CU_ASSERT_FALSE(lsp
->flag_r
);
803 CU_ASSERT_FALSE(lsp
->flag_s
);
805 /* LSP IPv4 LSP Identifier TLV */
806 tlv_node
= lsp
->header
.tlv_list
->head
;
807 struct pcep_object_tlv_ipv4_lsp_identifier
*ipv4_lsp_id
=
808 (struct pcep_object_tlv_ipv4_lsp_identifier
*)tlv_node
->data
;
809 CU_ASSERT_EQUAL(ipv4_lsp_id
->header
.type
,
810 PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS
);
811 CU_ASSERT_EQUAL(ipv4_lsp_id
->header
.encoded_tlv_length
, 16);
812 CU_ASSERT_EQUAL(ipv4_lsp_id
->ipv4_tunnel_sender
.s_addr
,
814 CU_ASSERT_EQUAL(ipv4_lsp_id
->ipv4_tunnel_endpoint
.s_addr
,
816 CU_ASSERT_EQUAL(ipv4_lsp_id
->extended_tunnel_id
.s_addr
,
818 CU_ASSERT_EQUAL(ipv4_lsp_id
->tunnel_id
, 15);
819 CU_ASSERT_EQUAL(ipv4_lsp_id
->lsp_id
, 2);
821 /* LSP Symbolic Path Name TLV */
822 tlv_node
= tlv_node
->next_node
;
823 struct pcep_object_tlv_symbolic_path_name
*sym_path_name
=
824 (struct pcep_object_tlv_symbolic_path_name
*)tlv_node
->data
;
825 CU_ASSERT_EQUAL(sym_path_name
->header
.type
,
826 PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
827 CU_ASSERT_EQUAL(sym_path_name
->header
.encoded_tlv_length
, 13);
828 CU_ASSERT_EQUAL(sym_path_name
->symbolic_path_name_length
, 13);
830 strncmp(sym_path_name
->symbolic_path_name
, "cfg_R6-to-R1", 13),
834 obj_node
= obj_node
->next_node
;
835 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
836 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
837 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
838 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 4);
839 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
840 CU_ASSERT_PTR_NOT_NULL(ero
->sub_objects
);
841 CU_ASSERT_EQUAL(ero
->sub_objects
->num_entries
, 0);
844 obj_node
= obj_node
->next_node
;
845 struct pcep_object_lspa
*lspa
=
846 (struct pcep_object_lspa
*)obj_node
->data
;
847 CU_ASSERT_EQUAL(lspa
->header
.object_class
, PCEP_OBJ_CLASS_LSPA
);
848 CU_ASSERT_EQUAL(lspa
->header
.object_type
, PCEP_OBJ_TYPE_LSPA
);
849 CU_ASSERT_EQUAL(lspa
->header
.encoded_object_length
, 20);
850 CU_ASSERT_PTR_NULL(lspa
->header
.tlv_list
);
851 CU_ASSERT_TRUE(lspa
->flag_local_protection
);
852 CU_ASSERT_EQUAL(lspa
->holding_priority
, 7);
853 CU_ASSERT_EQUAL(lspa
->setup_priority
, 7);
854 CU_ASSERT_EQUAL(lspa
->lspa_include_all
, 0);
855 CU_ASSERT_EQUAL(lspa
->lspa_include_any
, 0);
856 CU_ASSERT_EQUAL(lspa
->lspa_exclude_any
, 0);
858 /* Bandwidth object 1 */
859 obj_node
= obj_node
->next_node
;
860 struct pcep_object_bandwidth
*bandwidth
=
861 (struct pcep_object_bandwidth
*)obj_node
->data
;
862 CU_ASSERT_EQUAL(bandwidth
->header
.object_class
,
863 PCEP_OBJ_CLASS_BANDWIDTH
);
864 CU_ASSERT_EQUAL(bandwidth
->header
.object_type
,
865 PCEP_OBJ_TYPE_BANDWIDTH_REQ
);
866 CU_ASSERT_EQUAL(bandwidth
->header
.encoded_object_length
, 8);
867 CU_ASSERT_EQUAL(bandwidth
->bandwidth
, 0);
869 /* Bandwidth object 2 */
870 obj_node
= obj_node
->next_node
;
871 bandwidth
= (struct pcep_object_bandwidth
*)obj_node
->data
;
872 CU_ASSERT_EQUAL(bandwidth
->header
.object_class
,
873 PCEP_OBJ_CLASS_BANDWIDTH
);
874 CU_ASSERT_EQUAL(bandwidth
->header
.object_type
,
875 PCEP_OBJ_TYPE_BANDWIDTH_CISCO
);
876 CU_ASSERT_EQUAL(bandwidth
->header
.encoded_object_length
, 8);
877 CU_ASSERT_EQUAL(bandwidth
->bandwidth
, 0);
879 /* Metric object 1 */
880 obj_node
= obj_node
->next_node
;
881 struct pcep_object_metric
*metric
=
882 (struct pcep_object_metric
*)obj_node
->data
;
883 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
884 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
885 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
886 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
887 CU_ASSERT_FALSE(metric
->flag_b
);
888 CU_ASSERT_FALSE(metric
->flag_c
);
889 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_TE
);
890 CU_ASSERT_EQUAL(metric
->value
, 0);
892 /* Metric object 2 */
893 obj_node
= obj_node
->next_node
;
894 metric
= (struct pcep_object_metric
*)obj_node
->data
;
895 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
896 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
897 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
898 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
899 CU_ASSERT_TRUE(metric
->flag_b
);
900 CU_ASSERT_FALSE(metric
->flag_c
);
901 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_AGGREGATE_BW
);
902 CU_ASSERT_EQUAL(metric
->value
, 16.0);
904 pcep_msg_free_message_list(msg_list
);
908 void test_pcep_msg_read_pcep_initiate_cisco_pcc()
910 int fd
= convert_hexstrs_to_binary(
911 pcep_initiate_cisco_pcc_hexbyte_strs
,
912 pcep_initiate_cisco_pcc_hexbyte_strs_length
);
914 CU_ASSERT_TRUE(fd
>=0);
917 double_linked_list
*msg_list
= pcep_msg_read(fd
);
918 CU_ASSERT_PTR_NOT_NULL(msg_list
);
919 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
921 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
922 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
923 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
924 pcep_initiate_cisco_pcc_hexbyte_strs_length
);
925 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 6);
928 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
929 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
930 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
931 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
932 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
933 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
934 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
935 CU_ASSERT_EQUAL(srp
->srp_id_number
, 1);
936 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
939 obj_node
= obj_node
->next_node
;
940 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
941 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
942 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
943 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 48);
944 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
945 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 2);
946 CU_ASSERT_EQUAL(lsp
->plsp_id
, 0);
947 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
948 CU_ASSERT_TRUE(lsp
->flag_a
);
949 CU_ASSERT_TRUE(lsp
->flag_d
);
950 CU_ASSERT_TRUE(lsp
->flag_c
);
951 CU_ASSERT_FALSE(lsp
->flag_r
);
952 CU_ASSERT_FALSE(lsp
->flag_s
);
954 /* Endpoint object */
955 obj_node
= obj_node
->next_node
;
956 struct pcep_object_endpoints_ipv4
*endpoint
=
957 (struct pcep_object_endpoints_ipv4
*)obj_node
->data
;
958 CU_ASSERT_EQUAL(endpoint
->header
.object_class
,
959 PCEP_OBJ_CLASS_ENDPOINTS
);
960 CU_ASSERT_EQUAL(endpoint
->header
.object_type
,
961 PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
962 CU_ASSERT_EQUAL(endpoint
->header
.encoded_object_length
, 12);
963 CU_ASSERT_PTR_NULL(endpoint
->header
.tlv_list
);
964 CU_ASSERT_EQUAL(endpoint
->src_ipv4
.s_addr
, htonl(0x0a0a0a0a));
965 CU_ASSERT_EQUAL(endpoint
->dst_ipv4
.s_addr
, htonl(0x0a0a0a04));
967 /* Inter-Layer object */
968 obj_node
= obj_node
->next_node
;
969 struct pcep_object_inter_layer
*inter_layer
=
970 (struct pcep_object_inter_layer
*)obj_node
->data
;
971 CU_ASSERT_EQUAL(inter_layer
->header
.object_class
,
972 PCEP_OBJ_CLASS_INTER_LAYER
);
973 CU_ASSERT_EQUAL(inter_layer
->header
.object_type
,
974 PCEP_OBJ_TYPE_INTER_LAYER
);
975 CU_ASSERT_EQUAL(inter_layer
->header
.encoded_object_length
, 8);
976 CU_ASSERT_PTR_NULL(inter_layer
->header
.tlv_list
);
977 CU_ASSERT_TRUE(inter_layer
->flag_i
);
978 CU_ASSERT_FALSE(inter_layer
->flag_m
);
979 CU_ASSERT_TRUE(inter_layer
->flag_t
);
981 /* Switch-Layer object */
982 obj_node
= obj_node
->next_node
;
983 struct pcep_object_switch_layer
*switch_layer
=
984 (struct pcep_object_switch_layer
*)obj_node
->data
;
985 CU_ASSERT_EQUAL(switch_layer
->header
.object_class
,
986 PCEP_OBJ_CLASS_SWITCH_LAYER
);
987 CU_ASSERT_EQUAL(switch_layer
->header
.object_type
,
988 PCEP_OBJ_TYPE_SWITCH_LAYER
);
989 CU_ASSERT_EQUAL(switch_layer
->header
.encoded_object_length
, 8);
990 CU_ASSERT_PTR_NULL(switch_layer
->header
.tlv_list
);
991 CU_ASSERT_PTR_NOT_NULL(switch_layer
->switch_layer_rows
);
992 CU_ASSERT_EQUAL(switch_layer
->switch_layer_rows
->num_entries
, 1);
993 struct pcep_object_switch_layer_row
*switch_layer_row
=
994 (struct pcep_object_switch_layer_row
*)
995 switch_layer
->switch_layer_rows
->head
->data
;
996 CU_ASSERT_EQUAL(switch_layer_row
->lsp_encoding_type
, 0);
997 CU_ASSERT_EQUAL(switch_layer_row
->switching_type
, 0);
998 CU_ASSERT_FALSE(switch_layer_row
->flag_i
);
1001 obj_node
= obj_node
->next_node
;
1002 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
1003 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
1004 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
1005 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 4);
1006 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
1008 pcep_msg_free_message_list(msg_list
);
1012 void test_validate_message_header()
1014 uint8_t pcep_message_invalid_version
[] = {0x40, 0x01, 0x04, 0x00};
1015 uint8_t pcep_message_invalid_flags
[] = {0x22, 0x01, 0x04, 0x00};
1016 uint8_t pcep_message_invalid_length
[] = {0x20, 0x01, 0x00, 0x00};
1017 uint8_t pcep_message_invalid_type
[] = {0x20, 0xff, 0x04, 0x00};
1018 uint8_t pcep_message_valid
[] = {0x20, 0x01, 0x00, 0x04};
1020 /* Verify invalid message header version */
1022 pcep_decode_validate_msg_header(pcep_message_invalid_version
)
1025 /* Verify invalid message header flags */
1027 pcep_decode_validate_msg_header(pcep_message_invalid_flags
)
1030 /* Verify invalid message header lengths */
1032 pcep_decode_validate_msg_header(pcep_message_invalid_length
)
1034 pcep_message_invalid_length
[3] = 0x05;
1036 pcep_decode_validate_msg_header(pcep_message_invalid_length
)
1039 /* Verify invalid message header types */
1041 pcep_decode_validate_msg_header(pcep_message_invalid_type
) < 0);
1042 pcep_message_invalid_type
[1] = 0x00;
1044 pcep_decode_validate_msg_header(pcep_message_invalid_type
) < 0);
1046 /* Verify a valid message header */
1047 CU_ASSERT_EQUAL(pcep_decode_validate_msg_header(pcep_message_valid
), 4);
1050 /* Internal util function */
1051 struct pcep_message
*create_message(uint8_t msg_type
, uint8_t obj1_class
,
1052 uint8_t obj2_class
, uint8_t obj3_class
,
1055 struct pcep_message
*msg
=
1056 pceplib_malloc(PCEPLIB_MESSAGES
, sizeof(struct pcep_message
));
1057 msg
->obj_list
= dll_initialize();
1058 msg
->msg_header
= pceplib_malloc(PCEPLIB_MESSAGES
,
1059 sizeof(struct pcep_message_header
));
1060 msg
->msg_header
->type
= msg_type
;
1061 msg
->encoded_message
= NULL
;
1063 if (obj1_class
> 0) {
1064 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1065 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1066 obj_hdr
->object_class
= obj1_class
;
1067 obj_hdr
->tlv_list
= NULL
;
1068 dll_append(msg
->obj_list
, obj_hdr
);
1071 if (obj2_class
> 0) {
1072 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1073 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1074 obj_hdr
->object_class
= obj2_class
;
1075 obj_hdr
->tlv_list
= NULL
;
1076 dll_append(msg
->obj_list
, obj_hdr
);
1079 if (obj3_class
> 0) {
1080 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1081 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1082 obj_hdr
->object_class
= obj3_class
;
1083 obj_hdr
->tlv_list
= NULL
;
1084 dll_append(msg
->obj_list
, obj_hdr
);
1087 if (obj4_class
> 0) {
1088 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1089 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1090 obj_hdr
->object_class
= obj4_class
;
1091 obj_hdr
->tlv_list
= NULL
;
1092 dll_append(msg
->obj_list
, obj_hdr
);
1098 void test_validate_message_objects()
1100 /* Valid Open message */
1101 struct pcep_message
*msg
=
1102 create_message(PCEP_TYPE_OPEN
, PCEP_OBJ_CLASS_OPEN
, 0, 0, 0);
1103 CU_ASSERT_TRUE(validate_message_objects(msg
));
1104 pcep_msg_free_message(msg
);
1106 /* Valid KeepAlive message */
1107 msg
= create_message(PCEP_TYPE_KEEPALIVE
, 0, 0, 0, 0);
1108 CU_ASSERT_TRUE(validate_message_objects(msg
));
1109 pcep_msg_free_message(msg
);
1111 /* Valid PcReq message */
1112 /* Using object_class=255 to verify it can take any object */
1113 msg
= create_message(PCEP_TYPE_PCREQ
, PCEP_OBJ_CLASS_RP
,
1114 PCEP_OBJ_CLASS_ENDPOINTS
, any_obj_class
, 0);
1115 CU_ASSERT_TRUE(validate_message_objects(msg
));
1116 pcep_msg_free_message(msg
);
1118 /* Valid PcRep message */
1119 msg
= create_message(PCEP_TYPE_PCREP
, PCEP_OBJ_CLASS_RP
, any_obj_class
,
1121 CU_ASSERT_TRUE(validate_message_objects(msg
));
1122 pcep_msg_free_message(msg
);
1124 /* Valid Notify message */
1125 msg
= create_message(PCEP_TYPE_PCNOTF
, PCEP_OBJ_CLASS_NOTF
,
1126 any_obj_class
, 0, 0);
1127 CU_ASSERT_TRUE(validate_message_objects(msg
));
1128 pcep_msg_free_message(msg
);
1130 /* Valid Error message */
1131 msg
= create_message(PCEP_TYPE_ERROR
, PCEP_OBJ_CLASS_ERROR
,
1132 any_obj_class
, 0, 0);
1133 CU_ASSERT_TRUE(validate_message_objects(msg
));
1134 pcep_msg_free_message(msg
);
1136 /* Valid Close message */
1137 msg
= create_message(PCEP_TYPE_CLOSE
, PCEP_OBJ_CLASS_CLOSE
, 0, 0, 0);
1138 CU_ASSERT_TRUE(validate_message_objects(msg
));
1139 pcep_msg_free_message(msg
);
1141 /* Valid Report message */
1142 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
,
1143 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1144 CU_ASSERT_TRUE(validate_message_objects(msg
));
1145 pcep_msg_free_message(msg
);
1147 /* Valid Update message */
1148 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
,
1149 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1150 CU_ASSERT_TRUE(validate_message_objects(msg
));
1151 pcep_msg_free_message(msg
);
1153 /* Valid Initiate message */
1154 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
,
1155 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1156 CU_ASSERT_TRUE(validate_message_objects(msg
));
1157 pcep_msg_free_message(msg
);
1160 void test_validate_message_objects_invalid()
1162 /* unsupported message ID = 0
1163 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1164 struct pcep_message
*msg
= create_message(0, any_obj_class
, 0, 0, 0);
1165 CU_ASSERT_FALSE(validate_message_objects(msg
));
1166 pcep_msg_free_message(msg
);
1169 * {PCEP_OBJ_CLASS_OPEN, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1170 msg
= create_message(PCEP_TYPE_OPEN
, 0, 0, 0, 0);
1171 CU_ASSERT_FALSE(validate_message_objects(msg
));
1172 pcep_msg_free_message(msg
);
1174 msg
= create_message(PCEP_TYPE_OPEN
, any_obj_class
, 0, 0, 0);
1175 CU_ASSERT_FALSE(validate_message_objects(msg
));
1176 pcep_msg_free_message(msg
);
1178 msg
= create_message(PCEP_TYPE_OPEN
, PCEP_OBJ_CLASS_OPEN
, any_obj_class
,
1180 CU_ASSERT_FALSE(validate_message_objects(msg
));
1181 pcep_msg_free_message(msg
);
1183 /* KeepAlive message
1184 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1185 msg
= create_message(PCEP_TYPE_KEEPALIVE
, any_obj_class
, 0, 0, 0);
1186 CU_ASSERT_FALSE(validate_message_objects(msg
));
1187 pcep_msg_free_message(msg
);
1190 * {PCEP_OBJ_CLASS_RP, PCEP_OBJ_CLASS_ENDPOINTS, ANY_OBJECT, ANY_OBJECT}
1192 msg
= create_message(PCEP_TYPE_PCREQ
, 0, 0, 0, 0);
1193 CU_ASSERT_FALSE(validate_message_objects(msg
));
1194 pcep_msg_free_message(msg
);
1196 msg
= create_message(PCEP_TYPE_PCREQ
, PCEP_OBJ_CLASS_RP
, any_obj_class
,
1198 CU_ASSERT_FALSE(validate_message_objects(msg
));
1199 pcep_msg_free_message(msg
);
1202 * {PCEP_OBJ_CLASS_RP, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1203 msg
= create_message(PCEP_TYPE_PCREP
, 0, 0, 0, 0);
1204 CU_ASSERT_FALSE(validate_message_objects(msg
));
1205 pcep_msg_free_message(msg
);
1207 msg
= create_message(PCEP_TYPE_PCREP
, any_obj_class
, 0, 0, 0);
1208 CU_ASSERT_FALSE(validate_message_objects(msg
));
1209 pcep_msg_free_message(msg
);
1212 * {PCEP_OBJ_CLASS_NOTF, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1213 msg
= create_message(PCEP_TYPE_PCNOTF
, 0, 0, 0, 0);
1214 CU_ASSERT_FALSE(validate_message_objects(msg
));
1215 pcep_msg_free_message(msg
);
1217 msg
= create_message(PCEP_TYPE_PCNOTF
, any_obj_class
, 0, 0, 0);
1218 CU_ASSERT_FALSE(validate_message_objects(msg
));
1219 pcep_msg_free_message(msg
);
1222 * {PCEP_OBJ_CLASS_ERROR, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1223 msg
= create_message(PCEP_TYPE_ERROR
, 0, 0, 0, 0);
1224 CU_ASSERT_FALSE(validate_message_objects(msg
));
1225 pcep_msg_free_message(msg
);
1227 msg
= create_message(PCEP_TYPE_ERROR
, any_obj_class
, 0, 0, 0);
1228 CU_ASSERT_FALSE(validate_message_objects(msg
));
1229 pcep_msg_free_message(msg
);
1232 * {PCEP_OBJ_CLASS_CLOSE, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1233 msg
= create_message(PCEP_TYPE_CLOSE
, 0, 0, 0, 0);
1234 CU_ASSERT_FALSE(validate_message_objects(msg
));
1235 pcep_msg_free_message(msg
);
1237 msg
= create_message(PCEP_TYPE_CLOSE
, any_obj_class
, 0, 0, 0);
1238 CU_ASSERT_FALSE(validate_message_objects(msg
));
1239 pcep_msg_free_message(msg
);
1241 /* unsupported message ID = 8
1242 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1243 msg
= create_message(8, any_obj_class
, 0, 0, 0);
1244 CU_ASSERT_FALSE(validate_message_objects(msg
));
1245 pcep_msg_free_message(msg
);
1247 /* unsupported message ID = 9
1248 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1249 msg
= create_message(9, any_obj_class
, 0, 0, 0);
1250 CU_ASSERT_FALSE(validate_message_objects(msg
));
1251 pcep_msg_free_message(msg
);
1254 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1255 msg
= create_message(PCEP_TYPE_REPORT
, 0, 0, 0, 0);
1256 CU_ASSERT_FALSE(validate_message_objects(msg
));
1257 pcep_msg_free_message(msg
);
1259 msg
= create_message(PCEP_TYPE_REPORT
, any_obj_class
, 0, 0, 0);
1260 CU_ASSERT_FALSE(validate_message_objects(msg
));
1261 pcep_msg_free_message(msg
);
1263 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1264 CU_ASSERT_FALSE(validate_message_objects(msg
));
1265 pcep_msg_free_message(msg
);
1267 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
,
1268 any_obj_class
, 0, 0);
1269 CU_ASSERT_FALSE(validate_message_objects(msg
));
1270 pcep_msg_free_message(msg
);
1273 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1274 msg
= create_message(PCEP_TYPE_UPDATE
, 0, 0, 0, 0);
1275 CU_ASSERT_FALSE(validate_message_objects(msg
));
1276 pcep_msg_free_message(msg
);
1278 msg
= create_message(PCEP_TYPE_UPDATE
, any_obj_class
, 0, 0, 0);
1279 CU_ASSERT_FALSE(validate_message_objects(msg
));
1280 pcep_msg_free_message(msg
);
1282 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1283 CU_ASSERT_FALSE(validate_message_objects(msg
));
1284 pcep_msg_free_message(msg
);
1286 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
,
1287 any_obj_class
, 0, 0);
1288 CU_ASSERT_FALSE(validate_message_objects(msg
));
1289 pcep_msg_free_message(msg
);
1292 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1293 msg
= create_message(PCEP_TYPE_INITIATE
, 0, 0, 0, 0);
1294 CU_ASSERT_FALSE(validate_message_objects(msg
));
1295 pcep_msg_free_message(msg
);
1297 msg
= create_message(PCEP_TYPE_INITIATE
, any_obj_class
, 0, 0, 0);
1298 CU_ASSERT_FALSE(validate_message_objects(msg
));
1299 pcep_msg_free_message(msg
);
1301 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1302 CU_ASSERT_FALSE(validate_message_objects(msg
));
1303 pcep_msg_free_message(msg
);
1305 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
,
1306 any_obj_class
, 0, 0);
1307 CU_ASSERT_FALSE(validate_message_objects(msg
));
1308 pcep_msg_free_message(msg
);