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>
32 #include <sys/types.h>
36 #include <CUnit/CUnit.h>
38 #include "pcep_msg_encoding.h"
39 #include "pcep_msg_messages.h"
40 #include "pcep_msg_tools.h"
41 #include "pcep_msg_tools_test.h"
42 #include "pcep_utils_double_linked_list.h"
43 #include "pcep_utils_logging.h"
44 #include "pcep_utils_memory.h"
46 const uint8_t any_obj_class
= 255;
48 uint16_t pcep_open_hexbyte_strs_length
= 28;
49 const char *pcep_open_odl_hexbyte_strs
[] = {
50 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e",
51 "78", "55", "00", "10", "00", "04", "00", "00", "00", "3f",
52 "00", "1a", "00", "04", "00", "00", "00", "00"};
54 /* PCEP INITIATE str received from ODL with 4 objects: [SRP, LSP, Endpoints,
55 * ERO] The LSP has a SYMBOLIC_PATH_NAME TLV. The ERO has 2 IPV4 Endpoints. */
56 uint16_t pcep_initiate_hexbyte_strs_length
= 68;
57 const char *pcep_initiate_hexbyte_strs
[] = {
58 "20", "0c", "00", "44", "21", "12", "00", "0c", "00", "00", "00", "00",
59 "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
60 "00", "11", "00", "08", "66", "61", "39", "33", "33", "39", "32", "39",
61 "04", "10", "00", "0c", "7f", "00", "00", "01", "28", "28", "28", "28",
62 "07", "10", "00", "14", "01", "08", "0a", "00", "01", "01", "18", "00",
63 "01", "08", "0a", "00", "07", "04", "18", "00"};
65 uint16_t pcep_initiate2_hexbyte_strs_length
= 72;
66 const char *pcep_initiate2_hexbyte_strs
[] = {
67 "20", "0c", "00", "48", "21", "12", "00", "14", "00", "00", "00", "00",
68 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
69 "20", "10", "00", "14", "00", "00", "00", "09", "00", "11", "00", "08",
70 "36", "65", "31", "31", "38", "39", "32", "31", "04", "10", "00", "0c",
71 "c0", "a8", "14", "05", "01", "01", "01", "01", "07", "10", "00", "10",
72 "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
74 uint16_t pcep_update_hexbyte_strs_length
= 48;
75 const char *pcep_update_hexbyte_strs
[] = {
76 "20", "0b", "00", "30", "21", "12", "00", "14", "00", "00", "00", "00",
77 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
78 "20", "10", "00", "08", "00", "02", "a0", "09", "07", "10", "00", "10",
79 "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
81 /* Test that pcep_msg_read() can read multiple messages in 1 call */
82 uint16_t pcep_open_initiate_hexbyte_strs_length
= 100;
83 const char *pcep_open_initiate_odl_hexbyte_strs
[] = {
84 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e", "78", "55",
85 "00", "10", "00", "04", "00", "00", "00", "3f", "00", "1a", "00", "04",
86 "00", "00", "00", "00", "20", "0c", "00", "48", "21", "12", "00", "14",
87 "00", "00", "00", "00", "00", "00", "00", "01", "00", "1c", "00", "04",
88 "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
89 "00", "11", "00", "08", "36", "65", "31", "31", "38", "39", "32", "31",
90 "04", "10", "00", "0c", "c0", "a8", "14", "05", "01", "01", "01", "01",
91 "07", "10", "00", "10", "05", "0c", "10", "01", "03", "e8", "a0", "00",
92 "01", "01", "01", "01"};
94 uint16_t pcep_open_cisco_pce_hexbyte_strs_length
= 28;
95 const char *pcep_open_cisco_pce_hexbyte_strs
[] = {
96 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "3c",
97 "78", "00", "00", "10", "00", "04", "00", "00", "00", "05",
98 "00", "1a", "00", "04", "00", "00", "00", "0a"};
100 uint16_t pcep_update_cisco_pce_hexbyte_strs_length
= 100;
101 const char *pcep_update_cisco_pce_hexbyte_strs
[] = {
102 "20", "0b", "00", "64", "21", "10", "00", "14", "00", "00", "00", "00",
103 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
104 "20", "10", "00", "18", "80", "00", "f0", "89", "00", "07", "00", "0c",
105 "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
106 "07", "10", "00", "28", "24", "0c", "10", "01", "04", "65", "50", "00",
107 "0a", "0a", "0a", "05", "24", "0c", "10", "01", "04", "65", "20", "00",
108 "0a", "0a", "0a", "02", "24", "0c", "10", "01", "04", "65", "10", "00",
109 "0a", "0a", "0a", "01", "06", "10", "00", "0c", "00", "00", "00", "02",
110 "41", "f0", "00", "00"};
112 uint16_t pcep_report_cisco_pcc_hexbyte_strs_length
= 148;
113 const char *pcep_report_cisco_pcc_hexbyte_strs
[] = {
114 "20", "0a", "00", "94", "21", "10", "00", "14", "00", "00", "00", "00",
115 "00", "00", "00", "00", "00", "1c", "00", "04", "00", "00", "00", "01",
116 "20", "10", "00", "3c", "80", "00", "f0", "09", "00", "12", "00", "10",
117 "0a", "0a", "0a", "06", "00", "02", "00", "0f", "0a", "0a", "0a", "06",
118 "0a", "0a", "0a", "01", "00", "11", "00", "0d", "63", "66", "67", "5f",
119 "52", "36", "2d", "74", "6f", "2d", "52", "31", "00", "00", "00", "00",
120 "ff", "e1", "00", "06", "00", "00", "05", "dd", "70", "00", "00", "00",
121 "07", "10", "00", "04", "09", "10", "00", "14", "00", "00", "00", "00",
122 "00", "00", "00", "00", "00", "00", "00", "00", "07", "07", "01", "00",
123 "05", "12", "00", "08", "00", "00", "00", "00", "05", "52", "00", "08",
124 "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "00", "02",
125 "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "01", "04",
126 "41", "80", "00", "00"};
128 /* Cisco PcInitiate with the following objects:
129 * SRP, LSP, Endpoint, Inter-layer, Switch-layer, ERO
131 uint16_t pcep_initiate_cisco_pcc_hexbyte_strs_length
= 104;
132 const char *pcep_initiate_cisco_pcc_hexbyte_strs
[] = {
133 "20", "0c", "00", "68", "21", "10", "00", "14", "00", "00", "00", "00",
134 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
135 "20", "10", "00", "30", "00", "00", "00", "89", "00", "11", "00", "13",
136 "50", "4f", "4c", "31", "5f", "50", "43", "49", "4e", "49", "54", "41",
137 "54", "45", "5f", "54", "45", "53", "54", "00", "00", "07", "00", "0c",
138 "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
139 "04", "10", "00", "0c", "0a", "0a", "0a", "0a", "0a", "0a", "0a", "04",
140 "24", "10", "00", "08", "00", "00", "01", "4d", "25", "10", "00", "08",
141 "00", "00", "00", "64", "07", "10", "00", "04"};
143 struct pcep_message
*create_message(uint8_t msg_type
, uint8_t obj1_class
,
144 uint8_t obj2_class
, uint8_t obj3_class
,
146 int convert_hexstrs_to_binary(const char *hexbyte_strs
[],
147 uint16_t hexbyte_strs_length
);
149 int pcep_tools_test_suite_setup(void)
151 pceplib_memory_reset();
155 int pcep_tools_test_suite_teardown(void)
158 pceplib_memory_dump();
162 void pcep_tools_test_setup(void)
166 void pcep_tools_test_teardown(void)
170 /* Reads an array of hexbyte strs, and writes them to a temporary file.
171 * The caller should close the returned file. */
172 int convert_hexstrs_to_binary(const char *hexbyte_strs
[],
173 uint16_t hexbyte_strs_length
)
176 oldumask
= umask(S_IXUSR
|S_IXGRP
|S_IWOTH
|S_IROTH
|S_IXOTH
);
177 /* Set umask before anything for security */
179 char tmpfile
[] = "/tmp/pceplib_XXXXXX";
180 int fd
= mkstemp(tmpfile
);
186 for (; i
< hexbyte_strs_length
; i
++) {
187 uint8_t byte
= (uint8_t)strtol(hexbyte_strs
[i
], 0, 16);
188 if (write(fd
, (char *)&byte
, 1) < 0) {
193 /* Go back to the beginning of the file */
194 lseek(fd
, 0, SEEK_SET
);
198 static bool pcep_obj_has_tlv(struct pcep_object_header
*obj_hdr
)
200 if (obj_hdr
->tlv_list
== NULL
) {
204 return (obj_hdr
->tlv_list
->num_entries
> 0);
207 void test_pcep_msg_read_pcep_initiate()
209 int fd
= convert_hexstrs_to_binary(pcep_initiate_hexbyte_strs
,
210 pcep_initiate_hexbyte_strs_length
);
212 CU_ASSERT_TRUE(fd
>=0);
215 double_linked_list
*msg_list
= pcep_msg_read(fd
);
216 CU_ASSERT_PTR_NOT_NULL(msg_list
);
217 assert(msg_list
!= NULL
);
218 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
220 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
221 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
222 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
223 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
224 pcep_initiate_hexbyte_strs_length
);
226 /* Verify each of the object types */
229 double_linked_list_node
*node
= msg
->obj_list
->head
;
230 struct pcep_object_header
*obj_hdr
=
231 (struct pcep_object_header
*)node
->data
;
232 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
233 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
234 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
235 pcep_object_get_length_by_hdr(obj_hdr
));
236 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
238 /* LSP object and its TLV*/
239 node
= node
->next_node
;
240 obj_hdr
= (struct pcep_object_header
*)node
->data
;
241 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
242 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
243 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
244 CU_ASSERT_EQUAL(((struct pcep_object_lsp
*)obj_hdr
)->plsp_id
, 0);
245 CU_ASSERT_TRUE(((struct pcep_object_lsp
*)obj_hdr
)->flag_d
);
246 CU_ASSERT_TRUE(((struct pcep_object_lsp
*)obj_hdr
)->flag_a
);
247 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_s
);
248 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_r
);
249 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_c
);
252 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
253 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
254 struct pcep_object_tlv_header
*tlv
=
255 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
256 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
257 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 8);
259 /* Endpoints object */
260 node
= node
->next_node
;
261 obj_hdr
= (struct pcep_object_header
*)node
->data
;
262 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ENDPOINTS
);
263 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
264 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
265 pcep_object_get_length_by_hdr(obj_hdr
));
266 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
269 node
= node
->next_node
;
270 obj_hdr
= (struct pcep_object_header
*)node
->data
;
271 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
272 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
273 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
276 double_linked_list
*ero_subobj_list
=
277 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
278 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
279 assert(ero_subobj_list
!= NULL
);
280 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 2);
281 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
282 struct pcep_object_ro_subobj
*subobj_hdr
=
283 (struct pcep_object_ro_subobj
*)subobj_node
->data
;
284 CU_ASSERT_EQUAL(subobj_hdr
->ro_subobj_type
, RO_SUBOBJ_TYPE_IPV4
);
285 struct in_addr ero_subobj_ip
;
286 inet_pton(AF_INET
, "10.0.1.1", &ero_subobj_ip
);
288 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->ip_addr
.s_addr
,
289 ero_subobj_ip
.s_addr
);
291 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->prefix_length
, 24);
294 (struct pcep_object_ro_subobj
*)subobj_node
->next_node
->data
;
295 CU_ASSERT_EQUAL(subobj_hdr
->ro_subobj_type
, RO_SUBOBJ_TYPE_IPV4
);
296 inet_pton(AF_INET
, "10.0.7.4", &ero_subobj_ip
);
298 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->ip_addr
.s_addr
,
299 ero_subobj_ip
.s_addr
);
301 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->prefix_length
, 24);
303 pcep_msg_free_message_list(msg_list
);
308 void test_pcep_msg_read_pcep_initiate2()
310 int fd
= convert_hexstrs_to_binary(pcep_initiate2_hexbyte_strs
,
311 pcep_initiate2_hexbyte_strs_length
);
313 CU_ASSERT_TRUE(fd
>=0);
316 double_linked_list
*msg_list
= pcep_msg_read(fd
);
317 CU_ASSERT_PTR_NOT_NULL(msg_list
);
318 assert(msg_list
!= NULL
);
319 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
321 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
322 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
323 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
324 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
325 pcep_initiate2_hexbyte_strs_length
);
327 /* Verify each of the object types */
330 double_linked_list_node
*node
= msg
->obj_list
->head
;
331 struct pcep_object_header
*obj_hdr
=
332 (struct pcep_object_header
*)node
->data
;
333 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
334 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
335 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
336 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
337 /* TODO test the TLVs */
339 /* LSP object and its TLV*/
340 node
= node
->next_node
;
341 obj_hdr
= (struct pcep_object_header
*)node
->data
;
342 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
343 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
344 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
347 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
348 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
349 struct pcep_object_tlv_header
*tlv
=
350 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
351 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
352 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 8);
354 /* Endpoints object */
355 node
= node
->next_node
;
356 obj_hdr
= (struct pcep_object_header
*)node
->data
;
357 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ENDPOINTS
);
358 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
359 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
360 pcep_object_get_length_by_hdr(obj_hdr
));
361 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
364 node
= node
->next_node
;
365 obj_hdr
= (struct pcep_object_header
*)node
->data
;
366 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
367 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
368 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 16);
371 double_linked_list
*ero_subobj_list
=
372 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
373 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
374 assert(ero_subobj_list
!= NULL
);
375 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 0);
376 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
377 CU_ASSERT_PTR_NULL(subobj_node
);
378 /* We no longer support draft07 SR sub-object type=5, and only support
379 type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
380 pcep_object_ro_subobj *) subobj_node->data;
381 CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
382 struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
383 subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
384 PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
385 CU_ASSERT_FALSE(subobj_sr->flag_c);
386 CU_ASSERT_FALSE(subobj_sr->flag_s);
387 CU_ASSERT_FALSE(subobj_sr->flag_f);
388 CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
389 CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
393 pcep_msg_free_message_list(msg_list
);
397 void test_pcep_msg_read_pcep_open()
399 int fd
= convert_hexstrs_to_binary(pcep_open_odl_hexbyte_strs
,
400 pcep_open_hexbyte_strs_length
);
402 CU_ASSERT_TRUE(fd
>=0);
405 double_linked_list
*msg_list
= pcep_msg_read(fd
);
406 CU_ASSERT_PTR_NOT_NULL(msg_list
);
407 assert(msg_list
!= NULL
);
408 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
410 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
411 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
412 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
413 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
414 pcep_open_hexbyte_strs_length
);
416 /* Verify the Open message */
417 struct pcep_object_header
*obj_hdr
=
418 (struct pcep_object_header
*)msg
->obj_list
->head
->data
;
419 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_OPEN
);
420 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_OPEN
);
421 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 24);
422 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
424 /* Open TLV: Stateful PCE Capability */
425 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 2);
426 double_linked_list_node
*tlv_node
= obj_hdr
->tlv_list
->head
;
427 struct pcep_object_tlv_header
*tlv
=
428 (struct pcep_object_tlv_header
*)tlv_node
->data
;
429 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY
);
430 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
432 /* Open TLV: SR PCE Capability */
433 tlv_node
= tlv_node
->next_node
;
434 tlv
= (struct pcep_object_tlv_header
*)tlv_node
->data
;
435 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY
);
436 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
438 pcep_msg_free_message_list(msg_list
);
442 void test_pcep_msg_read_pcep_update()
444 int fd
= convert_hexstrs_to_binary(pcep_update_hexbyte_strs
,
445 pcep_update_hexbyte_strs_length
);
447 CU_ASSERT_TRUE(fd
>=0);
450 double_linked_list
*msg_list
= pcep_msg_read(fd
);
451 CU_ASSERT_PTR_NOT_NULL(msg_list
);
452 assert(msg_list
!= NULL
);
453 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
455 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
456 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 3);
458 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_UPDATE
);
459 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
460 pcep_update_hexbyte_strs_length
);
462 /* Verify each of the object types */
464 double_linked_list_node
*node
= msg
->obj_list
->head
;
467 struct pcep_object_header
*obj_hdr
=
468 (struct pcep_object_header
*)node
->data
;
469 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
470 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
471 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
472 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
475 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
476 struct pcep_object_tlv_header
*tlv
=
477 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
478 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
479 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
480 /* TODO verify the path setup type */
483 node
= node
->next_node
;
484 obj_hdr
= (struct pcep_object_header
*)node
->data
;
485 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
486 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
487 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
488 pcep_object_get_length_by_hdr(obj_hdr
));
489 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
492 node
= node
->next_node
;
493 obj_hdr
= (struct pcep_object_header
*)node
->data
;
494 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
495 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
496 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 16);
499 double_linked_list
*ero_subobj_list
=
500 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
501 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
502 assert(ero_subobj_list
!= NULL
);
503 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 0);
504 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
505 CU_ASSERT_PTR_NULL(subobj_node
);
506 /* We no longer support draft07 SR sub-object type=5, and only support
507 type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
508 pcep_object_ro_subobj *) subobj_node->data;
509 CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
510 struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
511 subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
512 PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
513 CU_ASSERT_FALSE(subobj_sr->flag_c);
514 CU_ASSERT_FALSE(subobj_sr->flag_s);
515 CU_ASSERT_FALSE(subobj_sr->flag_f);
516 CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
517 CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
521 pcep_msg_free_message_list(msg_list
);
525 void test_pcep_msg_read_pcep_open_initiate()
527 int fd
= convert_hexstrs_to_binary(
528 pcep_open_initiate_odl_hexbyte_strs
,
529 pcep_open_initiate_hexbyte_strs_length
);
531 CU_ASSERT_TRUE(fd
>=0);
534 double_linked_list
*msg_list
= pcep_msg_read(fd
);
535 CU_ASSERT_PTR_NOT_NULL(msg_list
);
536 assert(msg_list
!= NULL
);
537 CU_ASSERT_EQUAL(msg_list
->num_entries
, 2);
539 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
540 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
541 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
542 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
543 pcep_open_hexbyte_strs_length
);
545 msg
= (struct pcep_message
*)msg_list
->head
->next_node
->data
;
546 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
547 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
548 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
549 pcep_initiate2_hexbyte_strs_length
);
551 pcep_msg_free_message_list(msg_list
);
555 void test_pcep_msg_read_pcep_open_cisco_pce()
557 int fd
= convert_hexstrs_to_binary(
558 pcep_open_cisco_pce_hexbyte_strs
,
559 pcep_open_cisco_pce_hexbyte_strs_length
);
561 CU_ASSERT_TRUE(fd
>=0);
564 double_linked_list
*msg_list
= pcep_msg_read(fd
);
565 CU_ASSERT_PTR_NOT_NULL(msg_list
);
566 assert(msg_list
!= NULL
);
567 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
569 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
570 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
571 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
572 pcep_open_hexbyte_strs_length
);
573 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
576 struct pcep_object_open
*open
=
577 (struct pcep_object_open
*)msg
->obj_list
->head
->data
;
578 CU_ASSERT_EQUAL(open
->header
.object_class
, PCEP_OBJ_CLASS_OPEN
);
579 CU_ASSERT_EQUAL(open
->header
.object_type
, PCEP_OBJ_TYPE_OPEN
);
580 CU_ASSERT_EQUAL(open
->header
.encoded_object_length
, 24);
581 CU_ASSERT_EQUAL(open
->open_deadtimer
, 120);
582 CU_ASSERT_EQUAL(open
->open_keepalive
, 60);
583 CU_ASSERT_EQUAL(open
->open_sid
, 0);
584 CU_ASSERT_EQUAL(open
->open_version
, 1);
585 CU_ASSERT_PTR_NOT_NULL(open
->header
.tlv_list
);
586 assert(open
->header
.tlv_list
!= NULL
);
587 CU_ASSERT_EQUAL(open
->header
.tlv_list
->num_entries
, 2);
589 /* Stateful PCE Capability TLV */
590 double_linked_list_node
*tlv_node
= open
->header
.tlv_list
->head
;
591 struct pcep_object_tlv_stateful_pce_capability
*pce_cap_tlv
=
592 (struct pcep_object_tlv_stateful_pce_capability
*)
594 CU_ASSERT_EQUAL(pce_cap_tlv
->header
.type
,
595 PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY
);
596 CU_ASSERT_EQUAL(pce_cap_tlv
->header
.encoded_tlv_length
, 4);
597 CU_ASSERT_TRUE(pce_cap_tlv
->flag_u_lsp_update_capability
);
598 CU_ASSERT_TRUE(pce_cap_tlv
->flag_i_lsp_instantiation_capability
);
599 CU_ASSERT_FALSE(pce_cap_tlv
->flag_s_include_db_version
);
600 CU_ASSERT_FALSE(pce_cap_tlv
->flag_t_triggered_resync
);
601 CU_ASSERT_FALSE(pce_cap_tlv
->flag_d_delta_lsp_sync
);
602 CU_ASSERT_FALSE(pce_cap_tlv
->flag_f_triggered_initial_sync
);
604 /* SR PCE Capability TLV */
605 tlv_node
= tlv_node
->next_node
;
606 struct pcep_object_tlv_sr_pce_capability
*sr_pce_cap_tlv
=
607 (struct pcep_object_tlv_sr_pce_capability
*)tlv_node
->data
;
608 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->header
.type
,
609 PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY
);
610 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->header
.encoded_tlv_length
, 4);
611 CU_ASSERT_FALSE(sr_pce_cap_tlv
->flag_n
);
612 CU_ASSERT_FALSE(sr_pce_cap_tlv
->flag_x
);
613 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->max_sid_depth
, 10);
615 pcep_msg_free_message_list(msg_list
);
619 void test_pcep_msg_read_pcep_update_cisco_pce()
621 int fd
= convert_hexstrs_to_binary(
622 pcep_update_cisco_pce_hexbyte_strs
,
623 pcep_update_cisco_pce_hexbyte_strs_length
);
625 CU_ASSERT_TRUE(fd
>=0);
628 double_linked_list
*msg_list
= pcep_msg_read(fd
);
629 CU_ASSERT_PTR_NOT_NULL(msg_list
);
630 assert(msg_list
!= NULL
);
631 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
633 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
634 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_UPDATE
);
635 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
636 pcep_update_cisco_pce_hexbyte_strs_length
);
637 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
640 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
641 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
642 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
643 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
644 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
645 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
646 assert(srp
->header
.tlv_list
!= NULL
);
647 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
648 CU_ASSERT_EQUAL(srp
->srp_id_number
, 1);
649 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
651 /* SRP Path Setup Type TLV */
652 double_linked_list_node
*tlv_node
= srp
->header
.tlv_list
->head
;
653 struct pcep_object_tlv_path_setup_type
*pst_tlv
=
654 (struct pcep_object_tlv_path_setup_type
*)tlv_node
->data
;
655 CU_ASSERT_EQUAL(pst_tlv
->header
.type
,
656 PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
657 CU_ASSERT_EQUAL(pst_tlv
->header
.encoded_tlv_length
, 4);
658 CU_ASSERT_EQUAL(pst_tlv
->path_setup_type
, 1);
661 obj_node
= obj_node
->next_node
;
662 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
663 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
664 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
665 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 24);
666 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
667 assert(lsp
->header
.tlv_list
!= NULL
);
668 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 1);
669 CU_ASSERT_EQUAL(lsp
->plsp_id
, 524303);
670 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
671 CU_ASSERT_TRUE(lsp
->flag_a
);
672 CU_ASSERT_TRUE(lsp
->flag_c
);
673 CU_ASSERT_TRUE(lsp
->flag_d
);
674 CU_ASSERT_FALSE(lsp
->flag_r
);
675 CU_ASSERT_FALSE(lsp
->flag_s
);
677 /* LSP Vendor Info TLV */
678 tlv_node
= lsp
->header
.tlv_list
->head
;
679 struct pcep_object_tlv_vendor_info
*vendor_tlv
=
680 (struct pcep_object_tlv_vendor_info
*)tlv_node
->data
;
681 CU_ASSERT_EQUAL(vendor_tlv
->header
.type
, PCEP_OBJ_TLV_TYPE_VENDOR_INFO
);
682 CU_ASSERT_EQUAL(vendor_tlv
->header
.encoded_tlv_length
, 12);
683 CU_ASSERT_EQUAL(vendor_tlv
->enterprise_number
, 9);
684 CU_ASSERT_EQUAL(vendor_tlv
->enterprise_specific_info
, 0x00030004);
687 obj_node
= obj_node
->next_node
;
688 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
689 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
690 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
691 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 40);
692 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
693 CU_ASSERT_PTR_NOT_NULL(ero
->sub_objects
);
694 assert(ero
->sub_objects
!= NULL
);
695 CU_ASSERT_EQUAL(ero
->sub_objects
->num_entries
, 3);
698 double_linked_list_node
*ero_subobj_node
= ero
->sub_objects
->head
;
699 struct pcep_ro_subobj_sr
*sr_subobj_ipv4_node
=
700 (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
701 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
703 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
704 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
705 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
706 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
707 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
708 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
709 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
710 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73748480);
712 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
715 ero_subobj_node
= ero_subobj_node
->next_node
;
716 sr_subobj_ipv4_node
= (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
717 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
719 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
720 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
721 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
722 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
723 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
724 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
725 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
726 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73736192);
728 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
731 ero_subobj_node
= ero_subobj_node
->next_node
;
732 sr_subobj_ipv4_node
= (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
733 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
735 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
736 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
737 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
738 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
739 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
740 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
741 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
742 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73732096);
744 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
748 obj_node
= obj_node
->next_node
;
749 struct pcep_object_metric
*metric
=
750 (struct pcep_object_metric
*)obj_node
->data
;
751 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
752 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
753 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
754 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
755 CU_ASSERT_FALSE(metric
->flag_b
);
756 CU_ASSERT_FALSE(metric
->flag_c
);
757 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_TE
);
758 CU_ASSERT_EQUAL(metric
->value
, 30.0);
760 pcep_msg_free_message_list(msg_list
);
764 void test_pcep_msg_read_pcep_report_cisco_pcc()
766 int fd
= convert_hexstrs_to_binary(
767 pcep_report_cisco_pcc_hexbyte_strs
,
768 pcep_report_cisco_pcc_hexbyte_strs_length
);
770 CU_ASSERT_TRUE(fd
>=0);
773 double_linked_list
*msg_list
= pcep_msg_read(fd
);
774 CU_ASSERT_PTR_NOT_NULL(msg_list
);
775 assert(msg_list
!= NULL
);
776 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
778 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
779 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_REPORT
);
780 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
781 pcep_report_cisco_pcc_hexbyte_strs_length
);
782 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 8);
785 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
786 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
787 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
788 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
789 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
790 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
791 assert(srp
->header
.tlv_list
!= NULL
);
792 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
793 CU_ASSERT_EQUAL(srp
->srp_id_number
, 0);
794 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
796 /* SRP Path Setup Type TLV */
797 double_linked_list_node
*tlv_node
= srp
->header
.tlv_list
->head
;
798 struct pcep_object_tlv_path_setup_type
*pst_tlv
=
799 (struct pcep_object_tlv_path_setup_type
*)tlv_node
->data
;
800 CU_ASSERT_EQUAL(pst_tlv
->header
.type
,
801 PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
802 CU_ASSERT_EQUAL(pst_tlv
->header
.encoded_tlv_length
, 4);
803 CU_ASSERT_EQUAL(pst_tlv
->path_setup_type
, 1);
806 obj_node
= obj_node
->next_node
;
807 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
808 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
809 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
810 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 60);
811 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
812 /* The TLV with ID 65505 is not recognized, and its not in the list */
813 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 2);
814 CU_ASSERT_EQUAL(lsp
->plsp_id
, 524303);
815 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
816 CU_ASSERT_TRUE(lsp
->flag_a
);
817 CU_ASSERT_TRUE(lsp
->flag_d
);
818 CU_ASSERT_FALSE(lsp
->flag_c
);
819 CU_ASSERT_FALSE(lsp
->flag_r
);
820 CU_ASSERT_FALSE(lsp
->flag_s
);
822 /* LSP IPv4 LSP Identifier TLV */
823 tlv_node
= lsp
->header
.tlv_list
->head
;
824 struct pcep_object_tlv_ipv4_lsp_identifier
*ipv4_lsp_id
=
825 (struct pcep_object_tlv_ipv4_lsp_identifier
*)tlv_node
->data
;
826 CU_ASSERT_EQUAL(ipv4_lsp_id
->header
.type
,
827 PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS
);
828 CU_ASSERT_EQUAL(ipv4_lsp_id
->header
.encoded_tlv_length
, 16);
829 CU_ASSERT_EQUAL(ipv4_lsp_id
->ipv4_tunnel_sender
.s_addr
,
831 CU_ASSERT_EQUAL(ipv4_lsp_id
->ipv4_tunnel_endpoint
.s_addr
,
833 CU_ASSERT_EQUAL(ipv4_lsp_id
->extended_tunnel_id
.s_addr
,
835 CU_ASSERT_EQUAL(ipv4_lsp_id
->tunnel_id
, 15);
836 CU_ASSERT_EQUAL(ipv4_lsp_id
->lsp_id
, 2);
838 /* LSP Symbolic Path Name TLV */
839 tlv_node
= tlv_node
->next_node
;
840 struct pcep_object_tlv_symbolic_path_name
*sym_path_name
=
841 (struct pcep_object_tlv_symbolic_path_name
*)tlv_node
->data
;
842 CU_ASSERT_EQUAL(sym_path_name
->header
.type
,
843 PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
844 CU_ASSERT_EQUAL(sym_path_name
->header
.encoded_tlv_length
, 13);
845 CU_ASSERT_EQUAL(sym_path_name
->symbolic_path_name_length
, 13);
847 strncmp(sym_path_name
->symbolic_path_name
, "cfg_R6-to-R1", 13),
851 obj_node
= obj_node
->next_node
;
852 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
853 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
854 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
855 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 4);
856 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
857 CU_ASSERT_PTR_NOT_NULL(ero
->sub_objects
);
858 assert(ero
->sub_objects
!= NULL
);
859 CU_ASSERT_EQUAL(ero
->sub_objects
->num_entries
, 0);
862 obj_node
= obj_node
->next_node
;
863 struct pcep_object_lspa
*lspa
=
864 (struct pcep_object_lspa
*)obj_node
->data
;
865 CU_ASSERT_EQUAL(lspa
->header
.object_class
, PCEP_OBJ_CLASS_LSPA
);
866 CU_ASSERT_EQUAL(lspa
->header
.object_type
, PCEP_OBJ_TYPE_LSPA
);
867 CU_ASSERT_EQUAL(lspa
->header
.encoded_object_length
, 20);
868 CU_ASSERT_PTR_NULL(lspa
->header
.tlv_list
);
869 CU_ASSERT_TRUE(lspa
->flag_local_protection
);
870 CU_ASSERT_EQUAL(lspa
->holding_priority
, 7);
871 CU_ASSERT_EQUAL(lspa
->setup_priority
, 7);
872 CU_ASSERT_EQUAL(lspa
->lspa_include_all
, 0);
873 CU_ASSERT_EQUAL(lspa
->lspa_include_any
, 0);
874 CU_ASSERT_EQUAL(lspa
->lspa_exclude_any
, 0);
876 /* Bandwidth object 1 */
877 obj_node
= obj_node
->next_node
;
878 struct pcep_object_bandwidth
*bandwidth
=
879 (struct pcep_object_bandwidth
*)obj_node
->data
;
880 CU_ASSERT_EQUAL(bandwidth
->header
.object_class
,
881 PCEP_OBJ_CLASS_BANDWIDTH
);
882 CU_ASSERT_EQUAL(bandwidth
->header
.object_type
,
883 PCEP_OBJ_TYPE_BANDWIDTH_REQ
);
884 CU_ASSERT_EQUAL(bandwidth
->header
.encoded_object_length
, 8);
885 CU_ASSERT_EQUAL(bandwidth
->bandwidth
, 0);
887 /* Bandwidth object 2 */
888 obj_node
= obj_node
->next_node
;
889 bandwidth
= (struct pcep_object_bandwidth
*)obj_node
->data
;
890 CU_ASSERT_EQUAL(bandwidth
->header
.object_class
,
891 PCEP_OBJ_CLASS_BANDWIDTH
);
892 CU_ASSERT_EQUAL(bandwidth
->header
.object_type
,
893 PCEP_OBJ_TYPE_BANDWIDTH_CISCO
);
894 CU_ASSERT_EQUAL(bandwidth
->header
.encoded_object_length
, 8);
895 CU_ASSERT_EQUAL(bandwidth
->bandwidth
, 0);
897 /* Metric object 1 */
898 obj_node
= obj_node
->next_node
;
899 struct pcep_object_metric
*metric
=
900 (struct pcep_object_metric
*)obj_node
->data
;
901 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
902 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
903 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
904 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
905 CU_ASSERT_FALSE(metric
->flag_b
);
906 CU_ASSERT_FALSE(metric
->flag_c
);
907 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_TE
);
908 CU_ASSERT_EQUAL(metric
->value
, 0);
910 /* Metric object 2 */
911 obj_node
= obj_node
->next_node
;
912 metric
= (struct pcep_object_metric
*)obj_node
->data
;
913 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
914 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
915 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
916 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
917 CU_ASSERT_TRUE(metric
->flag_b
);
918 CU_ASSERT_FALSE(metric
->flag_c
);
919 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_AGGREGATE_BW
);
920 CU_ASSERT_EQUAL(metric
->value
, 16.0);
922 pcep_msg_free_message_list(msg_list
);
926 void test_pcep_msg_read_pcep_initiate_cisco_pcc()
928 int fd
= convert_hexstrs_to_binary(
929 pcep_initiate_cisco_pcc_hexbyte_strs
,
930 pcep_initiate_cisco_pcc_hexbyte_strs_length
);
932 CU_ASSERT_TRUE(fd
>=0);
935 double_linked_list
*msg_list
= pcep_msg_read(fd
);
936 CU_ASSERT_PTR_NOT_NULL(msg_list
);
937 assert(msg_list
!= NULL
);
938 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
940 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
941 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
942 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
943 pcep_initiate_cisco_pcc_hexbyte_strs_length
);
944 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 6);
947 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
948 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
949 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
950 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
951 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
952 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
953 assert(srp
->header
.tlv_list
!= NULL
);
954 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
955 CU_ASSERT_EQUAL(srp
->srp_id_number
, 1);
956 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
959 obj_node
= obj_node
->next_node
;
960 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
961 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
962 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
963 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 48);
964 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
965 assert(lsp
->header
.tlv_list
!= NULL
);
966 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 2);
967 CU_ASSERT_EQUAL(lsp
->plsp_id
, 0);
968 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
969 CU_ASSERT_TRUE(lsp
->flag_a
);
970 CU_ASSERT_TRUE(lsp
->flag_d
);
971 CU_ASSERT_TRUE(lsp
->flag_c
);
972 CU_ASSERT_FALSE(lsp
->flag_r
);
973 CU_ASSERT_FALSE(lsp
->flag_s
);
975 /* Endpoint object */
976 obj_node
= obj_node
->next_node
;
977 struct pcep_object_endpoints_ipv4
*endpoint
=
978 (struct pcep_object_endpoints_ipv4
*)obj_node
->data
;
979 CU_ASSERT_EQUAL(endpoint
->header
.object_class
,
980 PCEP_OBJ_CLASS_ENDPOINTS
);
981 CU_ASSERT_EQUAL(endpoint
->header
.object_type
,
982 PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
983 CU_ASSERT_EQUAL(endpoint
->header
.encoded_object_length
, 12);
984 CU_ASSERT_PTR_NULL(endpoint
->header
.tlv_list
);
985 CU_ASSERT_EQUAL(endpoint
->src_ipv4
.s_addr
, htonl(0x0a0a0a0a));
986 CU_ASSERT_EQUAL(endpoint
->dst_ipv4
.s_addr
, htonl(0x0a0a0a04));
988 /* Inter-Layer object */
989 obj_node
= obj_node
->next_node
;
990 struct pcep_object_inter_layer
*inter_layer
=
991 (struct pcep_object_inter_layer
*)obj_node
->data
;
992 CU_ASSERT_EQUAL(inter_layer
->header
.object_class
,
993 PCEP_OBJ_CLASS_INTER_LAYER
);
994 CU_ASSERT_EQUAL(inter_layer
->header
.object_type
,
995 PCEP_OBJ_TYPE_INTER_LAYER
);
996 CU_ASSERT_EQUAL(inter_layer
->header
.encoded_object_length
, 8);
997 CU_ASSERT_PTR_NULL(inter_layer
->header
.tlv_list
);
998 CU_ASSERT_TRUE(inter_layer
->flag_i
);
999 CU_ASSERT_FALSE(inter_layer
->flag_m
);
1000 CU_ASSERT_TRUE(inter_layer
->flag_t
);
1002 /* Switch-Layer object */
1003 obj_node
= obj_node
->next_node
;
1004 struct pcep_object_switch_layer
*switch_layer
=
1005 (struct pcep_object_switch_layer
*)obj_node
->data
;
1006 CU_ASSERT_EQUAL(switch_layer
->header
.object_class
,
1007 PCEP_OBJ_CLASS_SWITCH_LAYER
);
1008 CU_ASSERT_EQUAL(switch_layer
->header
.object_type
,
1009 PCEP_OBJ_TYPE_SWITCH_LAYER
);
1010 CU_ASSERT_EQUAL(switch_layer
->header
.encoded_object_length
, 8);
1011 CU_ASSERT_PTR_NULL(switch_layer
->header
.tlv_list
);
1012 assert(switch_layer
->header
.tlv_list
== NULL
);
1013 CU_ASSERT_PTR_NOT_NULL(switch_layer
->switch_layer_rows
);
1014 assert(switch_layer
->switch_layer_rows
!= NULL
);
1015 CU_ASSERT_EQUAL(switch_layer
->switch_layer_rows
->num_entries
, 1);
1016 struct pcep_object_switch_layer_row
*switch_layer_row
=
1017 (struct pcep_object_switch_layer_row
*)
1018 switch_layer
->switch_layer_rows
->head
->data
;
1019 CU_ASSERT_EQUAL(switch_layer_row
->lsp_encoding_type
, 0);
1020 CU_ASSERT_EQUAL(switch_layer_row
->switching_type
, 0);
1021 CU_ASSERT_FALSE(switch_layer_row
->flag_i
);
1024 obj_node
= obj_node
->next_node
;
1025 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
1026 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
1027 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
1028 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 4);
1029 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
1031 pcep_msg_free_message_list(msg_list
);
1035 void test_validate_message_header()
1037 uint8_t pcep_message_invalid_version
[] = {0x40, 0x01, 0x04, 0x00};
1038 uint8_t pcep_message_invalid_flags
[] = {0x22, 0x01, 0x04, 0x00};
1039 uint8_t pcep_message_invalid_length
[] = {0x20, 0x01, 0x00, 0x00};
1040 uint8_t pcep_message_invalid_type
[] = {0x20, 0xff, 0x04, 0x00};
1041 uint8_t pcep_message_valid
[] = {0x20, 0x01, 0x00, 0x04};
1043 /* Verify invalid message header version */
1045 pcep_decode_validate_msg_header(pcep_message_invalid_version
)
1048 /* Verify invalid message header flags */
1050 pcep_decode_validate_msg_header(pcep_message_invalid_flags
)
1053 /* Verify invalid message header lengths */
1055 pcep_decode_validate_msg_header(pcep_message_invalid_length
)
1057 pcep_message_invalid_length
[3] = 0x05;
1059 pcep_decode_validate_msg_header(pcep_message_invalid_length
)
1062 /* Verify invalid message header types */
1064 pcep_decode_validate_msg_header(pcep_message_invalid_type
) < 0);
1065 pcep_message_invalid_type
[1] = 0x00;
1067 pcep_decode_validate_msg_header(pcep_message_invalid_type
) < 0);
1069 /* Verify a valid message header */
1070 CU_ASSERT_EQUAL(pcep_decode_validate_msg_header(pcep_message_valid
), 4);
1073 /* Internal util function */
1074 struct pcep_message
*create_message(uint8_t msg_type
, uint8_t obj1_class
,
1075 uint8_t obj2_class
, uint8_t obj3_class
,
1078 struct pcep_message
*msg
=
1079 pceplib_malloc(PCEPLIB_MESSAGES
, sizeof(struct pcep_message
));
1080 msg
->obj_list
= dll_initialize();
1081 msg
->msg_header
= pceplib_malloc(PCEPLIB_MESSAGES
,
1082 sizeof(struct pcep_message_header
));
1083 msg
->msg_header
->type
= msg_type
;
1084 msg
->encoded_message
= NULL
;
1086 if (obj1_class
> 0) {
1087 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1088 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1089 obj_hdr
->object_class
= obj1_class
;
1090 obj_hdr
->tlv_list
= NULL
;
1091 dll_append(msg
->obj_list
, obj_hdr
);
1094 if (obj2_class
> 0) {
1095 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1096 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1097 obj_hdr
->object_class
= obj2_class
;
1098 obj_hdr
->tlv_list
= NULL
;
1099 dll_append(msg
->obj_list
, obj_hdr
);
1102 if (obj3_class
> 0) {
1103 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1104 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1105 obj_hdr
->object_class
= obj3_class
;
1106 obj_hdr
->tlv_list
= NULL
;
1107 dll_append(msg
->obj_list
, obj_hdr
);
1110 if (obj4_class
> 0) {
1111 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1112 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1113 obj_hdr
->object_class
= obj4_class
;
1114 obj_hdr
->tlv_list
= NULL
;
1115 dll_append(msg
->obj_list
, obj_hdr
);
1121 void test_validate_message_objects()
1123 /* Valid Open message */
1124 struct pcep_message
*msg
=
1125 create_message(PCEP_TYPE_OPEN
, PCEP_OBJ_CLASS_OPEN
, 0, 0, 0);
1126 CU_ASSERT_TRUE(validate_message_objects(msg
));
1127 pcep_msg_free_message(msg
);
1129 /* Valid KeepAlive message */
1130 msg
= create_message(PCEP_TYPE_KEEPALIVE
, 0, 0, 0, 0);
1131 CU_ASSERT_TRUE(validate_message_objects(msg
));
1132 pcep_msg_free_message(msg
);
1134 /* Valid PcReq message */
1135 /* Using object_class=255 to verify it can take any object */
1136 msg
= create_message(PCEP_TYPE_PCREQ
, PCEP_OBJ_CLASS_RP
,
1137 PCEP_OBJ_CLASS_ENDPOINTS
, any_obj_class
, 0);
1138 CU_ASSERT_TRUE(validate_message_objects(msg
));
1139 pcep_msg_free_message(msg
);
1141 /* Valid PcRep message */
1142 msg
= create_message(PCEP_TYPE_PCREP
, PCEP_OBJ_CLASS_RP
, any_obj_class
,
1144 CU_ASSERT_TRUE(validate_message_objects(msg
));
1145 pcep_msg_free_message(msg
);
1147 /* Valid Notify message */
1148 msg
= create_message(PCEP_TYPE_PCNOTF
, PCEP_OBJ_CLASS_NOTF
,
1149 any_obj_class
, 0, 0);
1150 CU_ASSERT_TRUE(validate_message_objects(msg
));
1151 pcep_msg_free_message(msg
);
1153 /* Valid Error message */
1154 msg
= create_message(PCEP_TYPE_ERROR
, PCEP_OBJ_CLASS_ERROR
,
1155 any_obj_class
, 0, 0);
1156 CU_ASSERT_TRUE(validate_message_objects(msg
));
1157 pcep_msg_free_message(msg
);
1159 /* Valid Close message */
1160 msg
= create_message(PCEP_TYPE_CLOSE
, PCEP_OBJ_CLASS_CLOSE
, 0, 0, 0);
1161 CU_ASSERT_TRUE(validate_message_objects(msg
));
1162 pcep_msg_free_message(msg
);
1164 /* Valid Report message */
1165 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
,
1166 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1167 CU_ASSERT_TRUE(validate_message_objects(msg
));
1168 pcep_msg_free_message(msg
);
1170 /* Valid Update message */
1171 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
,
1172 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1173 CU_ASSERT_TRUE(validate_message_objects(msg
));
1174 pcep_msg_free_message(msg
);
1176 /* Valid Initiate message */
1177 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
,
1178 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1179 CU_ASSERT_TRUE(validate_message_objects(msg
));
1180 pcep_msg_free_message(msg
);
1183 void test_validate_message_objects_invalid()
1185 /* unsupported message ID = 0
1186 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1187 struct pcep_message
*msg
= create_message(0, any_obj_class
, 0, 0, 0);
1188 CU_ASSERT_FALSE(validate_message_objects(msg
));
1189 pcep_msg_free_message(msg
);
1192 * {PCEP_OBJ_CLASS_OPEN, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1193 msg
= create_message(PCEP_TYPE_OPEN
, 0, 0, 0, 0);
1194 CU_ASSERT_FALSE(validate_message_objects(msg
));
1195 pcep_msg_free_message(msg
);
1197 msg
= create_message(PCEP_TYPE_OPEN
, any_obj_class
, 0, 0, 0);
1198 CU_ASSERT_FALSE(validate_message_objects(msg
));
1199 pcep_msg_free_message(msg
);
1201 msg
= create_message(PCEP_TYPE_OPEN
, PCEP_OBJ_CLASS_OPEN
, any_obj_class
,
1203 CU_ASSERT_FALSE(validate_message_objects(msg
));
1204 pcep_msg_free_message(msg
);
1206 /* KeepAlive message
1207 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1208 msg
= create_message(PCEP_TYPE_KEEPALIVE
, any_obj_class
, 0, 0, 0);
1209 CU_ASSERT_FALSE(validate_message_objects(msg
));
1210 pcep_msg_free_message(msg
);
1213 * {PCEP_OBJ_CLASS_RP, PCEP_OBJ_CLASS_ENDPOINTS, ANY_OBJECT, ANY_OBJECT}
1215 msg
= create_message(PCEP_TYPE_PCREQ
, 0, 0, 0, 0);
1216 CU_ASSERT_FALSE(validate_message_objects(msg
));
1217 pcep_msg_free_message(msg
);
1219 msg
= create_message(PCEP_TYPE_PCREQ
, PCEP_OBJ_CLASS_RP
, any_obj_class
,
1221 CU_ASSERT_FALSE(validate_message_objects(msg
));
1222 pcep_msg_free_message(msg
);
1225 * {PCEP_OBJ_CLASS_RP, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1226 msg
= create_message(PCEP_TYPE_PCREP
, 0, 0, 0, 0);
1227 CU_ASSERT_FALSE(validate_message_objects(msg
));
1228 pcep_msg_free_message(msg
);
1230 msg
= create_message(PCEP_TYPE_PCREP
, any_obj_class
, 0, 0, 0);
1231 CU_ASSERT_FALSE(validate_message_objects(msg
));
1232 pcep_msg_free_message(msg
);
1235 * {PCEP_OBJ_CLASS_NOTF, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1236 msg
= create_message(PCEP_TYPE_PCNOTF
, 0, 0, 0, 0);
1237 CU_ASSERT_FALSE(validate_message_objects(msg
));
1238 pcep_msg_free_message(msg
);
1240 msg
= create_message(PCEP_TYPE_PCNOTF
, any_obj_class
, 0, 0, 0);
1241 CU_ASSERT_FALSE(validate_message_objects(msg
));
1242 pcep_msg_free_message(msg
);
1245 * {PCEP_OBJ_CLASS_ERROR, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1246 msg
= create_message(PCEP_TYPE_ERROR
, 0, 0, 0, 0);
1247 CU_ASSERT_FALSE(validate_message_objects(msg
));
1248 pcep_msg_free_message(msg
);
1250 msg
= create_message(PCEP_TYPE_ERROR
, any_obj_class
, 0, 0, 0);
1251 CU_ASSERT_FALSE(validate_message_objects(msg
));
1252 pcep_msg_free_message(msg
);
1255 * {PCEP_OBJ_CLASS_CLOSE, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1256 msg
= create_message(PCEP_TYPE_CLOSE
, 0, 0, 0, 0);
1257 CU_ASSERT_FALSE(validate_message_objects(msg
));
1258 pcep_msg_free_message(msg
);
1260 msg
= create_message(PCEP_TYPE_CLOSE
, any_obj_class
, 0, 0, 0);
1261 CU_ASSERT_FALSE(validate_message_objects(msg
));
1262 pcep_msg_free_message(msg
);
1264 /* unsupported message ID = 8
1265 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1266 msg
= create_message(8, any_obj_class
, 0, 0, 0);
1267 CU_ASSERT_FALSE(validate_message_objects(msg
));
1268 pcep_msg_free_message(msg
);
1270 /* unsupported message ID = 9
1271 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1272 msg
= create_message(9, any_obj_class
, 0, 0, 0);
1273 CU_ASSERT_FALSE(validate_message_objects(msg
));
1274 pcep_msg_free_message(msg
);
1277 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1278 msg
= create_message(PCEP_TYPE_REPORT
, 0, 0, 0, 0);
1279 CU_ASSERT_FALSE(validate_message_objects(msg
));
1280 pcep_msg_free_message(msg
);
1282 msg
= create_message(PCEP_TYPE_REPORT
, any_obj_class
, 0, 0, 0);
1283 CU_ASSERT_FALSE(validate_message_objects(msg
));
1284 pcep_msg_free_message(msg
);
1286 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1287 CU_ASSERT_FALSE(validate_message_objects(msg
));
1288 pcep_msg_free_message(msg
);
1290 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
,
1291 any_obj_class
, 0, 0);
1292 CU_ASSERT_FALSE(validate_message_objects(msg
));
1293 pcep_msg_free_message(msg
);
1296 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1297 msg
= create_message(PCEP_TYPE_UPDATE
, 0, 0, 0, 0);
1298 CU_ASSERT_FALSE(validate_message_objects(msg
));
1299 pcep_msg_free_message(msg
);
1301 msg
= create_message(PCEP_TYPE_UPDATE
, any_obj_class
, 0, 0, 0);
1302 CU_ASSERT_FALSE(validate_message_objects(msg
));
1303 pcep_msg_free_message(msg
);
1305 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1306 CU_ASSERT_FALSE(validate_message_objects(msg
));
1307 pcep_msg_free_message(msg
);
1309 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
,
1310 any_obj_class
, 0, 0);
1311 CU_ASSERT_FALSE(validate_message_objects(msg
));
1312 pcep_msg_free_message(msg
);
1315 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1316 msg
= create_message(PCEP_TYPE_INITIATE
, 0, 0, 0, 0);
1317 CU_ASSERT_FALSE(validate_message_objects(msg
));
1318 pcep_msg_free_message(msg
);
1320 msg
= create_message(PCEP_TYPE_INITIATE
, any_obj_class
, 0, 0, 0);
1321 CU_ASSERT_FALSE(validate_message_objects(msg
));
1322 pcep_msg_free_message(msg
);
1324 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1325 CU_ASSERT_FALSE(validate_message_objects(msg
));
1326 pcep_msg_free_message(msg
);
1328 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
,
1329 any_obj_class
, 0, 0);
1330 CU_ASSERT_FALSE(validate_message_objects(msg
));
1331 pcep_msg_free_message(msg
);