Adding upstream version 8.4.4.upstream/8.4.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 560 insertions, 0 deletions

diff --git a/pceplib/test/pcep_msg_messages_test.c b/pceplib/test/pcep_msg_messages_test.c
new file mode 100644
index 0000000..e3a74f9
--- /dev/null
+++ b/pceplib/test/pcep_msg_messages_test.c
@@ -0,0 +1,560 @@
+/*
+ * This file is part of the PCEPlib, a PCEP protocol library.
+ *
+ * Copyright (C) 2020 Volta Networks https://voltanet.io/
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Author : Brady Johnson <brady@voltanet.io>
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <assert.h>
+
+#include <CUnit/CUnit.h>
+
+#include "pcep_msg_encoding.h"
+#include "pcep_msg_messages.h"
+#include "pcep_msg_objects.h"
+#include "pcep_msg_tools.h"
+#include "pcep_utils_double_linked_list.h"
+#include "pcep_utils_memory.h"
+#include "pcep_msg_messages_test.h"
+
+/*
+ * Notice:
+ * All of these message Unit Tests encode the created messages by explicitly
+ * calling pcep_encode_message() thus testing the message creation and the
+ * message encoding.
+ */
+
+static struct pcep_versioning *versioning = NULL;
+
+int pcep_messages_test_suite_setup(void)
+{
+	pceplib_memory_reset();
+	return 0;
+}
+
+int pcep_messages_test_suite_teardown(void)
+{
+	printf("\n");
+	pceplib_memory_dump();
+	return 0;
+}
+
+void pcep_messages_test_setup()
+{
+	versioning = create_default_pcep_versioning();
+}
+
+void pcep_messages_test_teardown()
+{
+	destroy_pcep_versioning(versioning);
+}
+
+void test_pcep_msg_create_open()
+{
+	uint8_t keepalive = 30;
+	uint8_t deadtimer = 60;
+	uint8_t sid = 255;
+
+	struct pcep_message *message =
+		pcep_msg_create_open(keepalive, deadtimer, sid);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ pcep_object_get_length(PCEP_OBJ_CLASS_OPEN,
+							 PCEP_OBJ_TYPE_OPEN));
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_OPEN);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	/* Just check the class and type, the rest of the hdr fields
+	 * are verified in pcep-objects-test.c */
+	struct pcep_object_open *open_obj =
+		(struct pcep_object_open *)message->obj_list->head->data;
+	CU_ASSERT_EQUAL(open_obj->header.object_class, PCEP_OBJ_CLASS_OPEN);
+	CU_ASSERT_EQUAL(open_obj->header.object_type, PCEP_OBJ_TYPE_OPEN);
+
+	CU_ASSERT_EQUAL(open_obj->open_deadtimer, deadtimer);
+	CU_ASSERT_EQUAL(open_obj->open_keepalive, keepalive);
+	CU_ASSERT_EQUAL(open_obj->open_sid, sid);
+	CU_ASSERT_EQUAL(open_obj->open_version, PCEP_OBJECT_OPEN_VERSION);
+	pcep_msg_free_message(message);
+}
+
+
+void test_pcep_msg_create_request()
+{
+	/* First test with NULL objects */
+	struct pcep_message *message =
+		pcep_msg_create_request(NULL, NULL, NULL);
+	CU_ASSERT_PTR_NULL(message);
+
+	/* Test IPv4 */
+	struct pcep_object_rp *rp_obj =
+		pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
+	struct in_addr src_addr = {}, dst_addr = {};
+	struct pcep_object_endpoints_ipv4 *ipv4_obj =
+		pcep_obj_create_endpoint_ipv4(&src_addr, &dst_addr);
+	message = pcep_msg_create_request(rp_obj, ipv4_obj, NULL);
+
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
+	CU_ASSERT_EQUAL(
+		message->encoded_message_length,
+		MESSAGE_HEADER_LENGTH
+			+ pcep_object_get_length_by_hdr(&rp_obj->header)
+			+ pcep_object_get_length_by_hdr(&ipv4_obj->header));
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREQ);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+	pcep_msg_free_message(message);
+
+	/* Test IPv6 */
+	rp_obj = pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
+	struct in6_addr src_addr_ipv6 = {}, dst_addr_ipv6 = {};
+	struct pcep_object_endpoints_ipv6 *ipv6_obj =
+		pcep_obj_create_endpoint_ipv6(&src_addr_ipv6, &dst_addr_ipv6);
+	message = pcep_msg_create_request_ipv6(rp_obj, ipv6_obj, NULL);
+
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
+	CU_ASSERT_EQUAL(
+		message->encoded_message_length,
+		MESSAGE_HEADER_LENGTH
+			+ pcep_object_get_length_by_hdr(&rp_obj->header)
+			+ pcep_object_get_length_by_hdr(&ipv6_obj->header));
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREQ);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+	pcep_msg_free_message(message);
+
+	/* The objects get deleted with the message, so they need to be created
+	 * again */
+	rp_obj = pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
+	ipv4_obj = pcep_obj_create_endpoint_ipv4(&src_addr, &dst_addr);
+	struct pcep_object_bandwidth *bandwidth_obj =
+		pcep_obj_create_bandwidth(4.2);
+	double_linked_list *obj_list = dll_initialize();
+	dll_append(obj_list, bandwidth_obj);
+	message = pcep_msg_create_request(rp_obj, ipv4_obj, obj_list);
+
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 3);
+	CU_ASSERT_EQUAL(
+		message->encoded_message_length,
+		MESSAGE_HEADER_LENGTH
+			+ pcep_object_get_length_by_hdr(&rp_obj->header)
+			+ pcep_object_get_length_by_hdr(&ipv4_obj->header)
+			+ pcep_object_get_length_by_hdr(
+				&bandwidth_obj->header));
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREQ);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+	pcep_msg_free_message(message);
+}
+
+
+void test_pcep_msg_create_request_svec()
+{
+}
+
+
+void test_pcep_msg_create_reply_nopath()
+{
+	struct pcep_object_rp *rp_obj =
+		pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
+	struct pcep_object_nopath *nopath_obj = pcep_obj_create_nopath(
+		false, false, PCEP_NOPATH_TLV_ERR_NO_TLV);
+	double_linked_list *obj_list = dll_initialize();
+	dll_append(obj_list, nopath_obj);
+
+	struct pcep_message *message = pcep_msg_create_reply(rp_obj, obj_list);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			(MESSAGE_HEADER_LENGTH
+			 + pcep_object_get_length_by_hdr(&rp_obj->header)
+			 + pcep_object_get_length_by_hdr(&nopath_obj->header)));
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREP);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+	pcep_msg_free_message(message);
+}
+
+
+void test_pcep_msg_create_reply()
+{
+	/* First test with NULL ero and rp objects */
+	struct pcep_message *message = pcep_msg_create_reply(NULL, NULL);
+
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 0);
+	CU_ASSERT_EQUAL(message->encoded_message_length, MESSAGE_HEADER_LENGTH);
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREP);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+	pcep_msg_free_message(message);
+
+	double_linked_list *ero_subobj_list = dll_initialize();
+	struct pcep_object_ro_subobj *ero_subobj =
+		(struct pcep_object_ro_subobj *)
+			pcep_obj_create_ro_subobj_32label(true, 1, 10);
+	dll_append(ero_subobj_list, ero_subobj);
+	struct pcep_object_ro *ero = pcep_obj_create_ero(ero_subobj_list);
+
+	double_linked_list *object_list = dll_initialize();
+	dll_append(object_list, ero);
+	struct pcep_object_rp *rp_obj =
+		pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
+	message = pcep_msg_create_reply(rp_obj, object_list);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ pcep_object_get_length_by_hdr(&rp_obj->header)
+				+ OBJECT_HEADER_LENGTH
+				+ OBJECT_RO_SUBOBJ_HEADER_LENGTH
+				+ 6 /* size of the 32label */);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCREP);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+	pcep_msg_free_message(message);
+}
+
+
+void test_pcep_msg_create_close()
+{
+	uint8_t reason = PCEP_CLOSE_REASON_UNREC_MSG;
+
+	struct pcep_message *message = pcep_msg_create_close(reason);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ pcep_object_get_length(PCEP_OBJ_CLASS_CLOSE,
+							 PCEP_OBJ_TYPE_CLOSE));
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_CLOSE);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	/* Just check the class and type, the rest of the hdr fields
+	 * are verified in pcep-objects-test.c */
+	struct pcep_object_close *close_obj =
+		(struct pcep_object_close *)message->obj_list->head->data;
+	assert(close_obj != NULL);
+	CU_ASSERT_EQUAL(close_obj->header.object_class, PCEP_OBJ_CLASS_CLOSE);
+	CU_ASSERT_EQUAL(close_obj->header.object_type, PCEP_OBJ_TYPE_CLOSE);
+	CU_ASSERT_EQUAL(close_obj->reason, reason);
+	pcep_msg_free_message(message);
+}
+
+
+void test_pcep_msg_create_error()
+{
+	uint8_t error_type = PCEP_ERRT_RECEPTION_OF_INV_OBJECT;
+	uint8_t error_value = PCEP_ERRV_KEEPALIVEWAIT_TIMED_OUT;
+
+	struct pcep_message *message =
+		pcep_msg_create_error(error_type, error_value);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ pcep_object_get_length(PCEP_OBJ_CLASS_ERROR,
+							 PCEP_OBJ_TYPE_ERROR));
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_ERROR);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	/* Just check the class and type, the rest of the hdr fields
+	 * are verified in pcep-objects-test.c */
+	struct pcep_object_error *error_obj =
+		(struct pcep_object_error *)message->obj_list->head->data;
+	CU_ASSERT_EQUAL(error_obj->header.object_class, PCEP_OBJ_CLASS_ERROR);
+	CU_ASSERT_EQUAL(error_obj->header.object_type, PCEP_OBJ_TYPE_ERROR);
+
+	CU_ASSERT_EQUAL(error_obj->error_type, error_type);
+	CU_ASSERT_EQUAL(error_obj->error_value, error_value);
+	pcep_msg_free_message(message);
+}
+
+
+void test_pcep_msg_create_keepalive()
+{
+	struct pcep_message *message = pcep_msg_create_keepalive();
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 0);
+	CU_ASSERT_EQUAL(message->encoded_message_length, MESSAGE_HEADER_LENGTH);
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_KEEPALIVE);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+	pcep_msg_free_message(message);
+}
+
+void test_pcep_msg_create_report()
+{
+	double_linked_list *obj_list = dll_initialize();
+
+	/* Should return NULL if obj_list is empty */
+	struct pcep_message *message = pcep_msg_create_report(NULL);
+	CU_ASSERT_PTR_NULL(message);
+
+	struct pcep_object_lsp *lsp =
+		pcep_obj_create_lsp(100, PCEP_LSP_OPERATIONAL_UP, true, true,
+				    true, true, true, NULL);
+	dll_append(obj_list, lsp);
+	message = pcep_msg_create_report(obj_list);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ lsp->header.encoded_object_length);
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_REPORT);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	pcep_msg_free_message(message);
+}
+
+void test_pcep_msg_create_update()
+{
+	double_linked_list *obj_list = dll_initialize();
+	double_linked_list *ero_subobj_list = dll_initialize();
+
+	struct pcep_message *message = pcep_msg_create_update(NULL);
+	CU_ASSERT_PTR_NULL(message);
+
+	/* Should return NULL if obj_list is empty */
+	message = pcep_msg_create_update(obj_list);
+	CU_ASSERT_PTR_NULL(message);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
+
+	struct pcep_object_srp *srp = pcep_obj_create_srp(false, 100, NULL);
+	struct pcep_object_lsp *lsp =
+		pcep_obj_create_lsp(100, PCEP_LSP_OPERATIONAL_UP, true, true,
+				    true, true, true, NULL);
+	dll_append(ero_subobj_list, pcep_obj_create_ro_subobj_asn(0x0102));
+	struct pcep_object_ro *ero = pcep_obj_create_ero(ero_subobj_list);
+
+	/* Should return NULL if obj_list does not have 3 entries */
+	dll_append(obj_list, srp);
+	dll_append(obj_list, lsp);
+	message = pcep_msg_create_update(obj_list);
+	CU_ASSERT_PTR_NULL(message);
+
+	dll_append(obj_list, ero);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
+	message = pcep_msg_create_update(obj_list);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 3);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ srp->header.encoded_object_length
+				+ lsp->header.encoded_object_length
+				+ ero->header.encoded_object_length);
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_UPDATE);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	pcep_msg_free_message(message);
+}
+
+void test_pcep_msg_create_initiate()
+{
+	double_linked_list *obj_list = dll_initialize();
+	double_linked_list *ero_subobj_list = dll_initialize();
+
+	/* Should return NULL if obj_list is empty */
+	struct pcep_message *message = pcep_msg_create_initiate(NULL);
+	CU_ASSERT_PTR_NULL(message);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
+
+	struct pcep_object_srp *srp = pcep_obj_create_srp(false, 100, NULL);
+	struct pcep_object_lsp *lsp =
+		pcep_obj_create_lsp(100, PCEP_LSP_OPERATIONAL_UP, true, true,
+				    true, true, true, NULL);
+	dll_append(ero_subobj_list, pcep_obj_create_ro_subobj_asn(0x0102));
+	struct pcep_object_ro *ero = pcep_obj_create_ero(ero_subobj_list);
+
+	/* Should return NULL if obj_list does not have 2 entries */
+	dll_append(obj_list, srp);
+	message = pcep_msg_create_initiate(obj_list);
+	CU_ASSERT_PTR_NULL(message);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
+
+	dll_append(obj_list, lsp);
+	dll_append(obj_list, ero);
+	message = pcep_msg_create_initiate(obj_list);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->msg_header);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 3);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ srp->header.encoded_object_length
+				+ lsp->header.encoded_object_length
+				+ ero->header.encoded_object_length);
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_INITIATE);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	pcep_msg_free_message(message);
+}
+
+void test_pcep_msg_create_notify(void)
+{
+	struct pcep_object_notify *notify_obj = pcep_obj_create_notify(
+		PCEP_NOTIFY_TYPE_PENDING_REQUEST_CANCELLED,
+		PCEP_NOTIFY_VALUE_PCC_CANCELLED_REQUEST);
+
+	/* Should return NULL if the notify obj is empty */
+	struct pcep_message *message = pcep_msg_create_notify(NULL, NULL);
+	CU_ASSERT_PTR_NULL(message);
+
+	message = pcep_msg_create_notify(notify_obj, NULL);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 1);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ notify_obj->header.encoded_object_length);
+	assert(message->msg_header != NULL);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCNOTF);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	pcep_msg_free_message(message);
+
+	struct pcep_object_rp *rp_obj =
+		pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
+	double_linked_list *obj_list = dll_initialize();
+	dll_append(obj_list, rp_obj);
+	notify_obj = pcep_obj_create_notify(
+		PCEP_NOTIFY_TYPE_PENDING_REQUEST_CANCELLED,
+		PCEP_NOTIFY_VALUE_PCC_CANCELLED_REQUEST);
+
+	message = pcep_msg_create_notify(notify_obj, obj_list);
+	CU_ASSERT_PTR_NOT_NULL(message);
+	pcep_encode_message(message, versioning);
+	assert(message != NULL);
+	CU_ASSERT_PTR_NOT_NULL(message->obj_list);
+	assert(message->obj_list != NULL);
+	CU_ASSERT_EQUAL(message->obj_list->num_entries, 2);
+	CU_ASSERT_EQUAL(message->encoded_message_length,
+			MESSAGE_HEADER_LENGTH
+				+ notify_obj->header.encoded_object_length
+				+ rp_obj->header.encoded_object_length);
+	CU_ASSERT_EQUAL(message->msg_header->type, PCEP_TYPE_PCNOTF);
+	CU_ASSERT_EQUAL(message->msg_header->pcep_version,
+			PCEP_MESSAGE_HEADER_VERSION);
+
+	pcep_msg_free_message(message);
+}