pceplib/test/pcep_msg_messages_test.c

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