projects / mirror_frr.git / blame
| Commit | Line | Data |
|---|---|---|
| acddc0ed | 1 | // SPDX-License-Identifier: LGPL-2.1-or-later |
| 74971473 JG |
2 | /* |
| 3 | * This file is part of the PCEPlib, a PCEP protocol library. | |
| 4 | * | |
| 5 | * Copyright (C) 2020 Volta Networks https://voltanet.io/ | |
| 6 | * | |
| 74971473 JG |
7 | * Author : Brady Johnson <brady@voltanet.io> |
| 8 | * | |
| 9 | */ | |
| 10 | ||
| 11 | ||
| 1f8031f7 DL |
12 | #ifdef HAVE_CONFIG_H |
| 13 | #include "config.h" | |
| 14 | #endif | |
| 15 | ||
| fadf00aa | 16 | #include <assert.h> |
| 74971473 JG |
17 | #include <CUnit/CUnit.h> |
| 18 | ||
| 19 | #include "pcep_utils_double_linked_list.h" | |
| 20 | #include "pcep_utils_double_linked_list_test.h" | |
| 21 | ||
| 22 | typedef struct dll_node_data_ { | |
| 23 | int int_data; | |
| 24 | ||
| 25 | } dll_node_data; | |
| 26 | ||
| 27 | void test_empty_dl_list() | |
| 28 | { | |
| 29 | double_linked_list *handle = dll_initialize(); | |
| 30 | ||
| 31 | CU_ASSERT_PTR_NULL(dll_delete_first_node(handle)); | |
| 32 | CU_ASSERT_PTR_NULL(dll_delete_last_node(handle)); | |
| 33 | CU_ASSERT_PTR_NULL(dll_delete_node(handle, NULL)); | |
| 34 | ||
| 35 | dll_destroy(handle); | |
| 36 | } | |
| 37 | ||
| 38 | void test_null_dl_list_handle() | |
| 39 | { | |
| 40 | dll_destroy(NULL); | |
| 41 | CU_ASSERT_PTR_NULL(dll_prepend(NULL, NULL)); | |
| 42 | CU_ASSERT_PTR_NULL(dll_append(NULL, NULL)); | |
| 43 | CU_ASSERT_PTR_NULL(dll_delete_first_node(NULL)); | |
| 44 | CU_ASSERT_PTR_NULL(dll_delete_last_node(NULL)); | |
| 45 | CU_ASSERT_PTR_NULL(dll_delete_node(NULL, NULL)); | |
| 46 | } | |
| 47 | ||
| 48 | void test_dll_prepend_data() | |
| 49 | { | |
| 50 | dll_node_data data1, data2, data3; | |
| 51 | data1.int_data = 1; | |
| 52 | data2.int_data = 2; | |
| 53 | data3.int_data = 3; | |
| 54 | ||
| 55 | double_linked_list *handle = dll_initialize(); | |
| 56 | ||
| 57 | CU_ASSERT_PTR_NOT_NULL(dll_prepend(handle, &data3)); | |
| 58 | CU_ASSERT_PTR_NOT_NULL(dll_prepend(handle, &data2)); | |
| 59 | CU_ASSERT_PTR_NOT_NULL(dll_prepend(handle, &data1)); | |
| 60 | ||
| 61 | CU_ASSERT_EQUAL(handle->num_entries, 3); | |
| 62 | ||
| 63 | double_linked_list_node *node = handle->head; | |
| fadf00aa JG |
64 | CU_ASSERT_PTR_NOT_NULL(node); |
| 65 | assert(node != NULL); | |
| 74971473 JG |
66 | CU_ASSERT_PTR_EQUAL(node->data, &data1); |
| 67 | CU_ASSERT_PTR_NULL(node->prev_node); | |
| 68 | CU_ASSERT_PTR_NOT_NULL(node->next_node); | |
| 69 | ||
| 70 | node = node->next_node; | |
| fadf00aa JG |
71 | CU_ASSERT_PTR_NOT_NULL(node); |
| 72 | assert(node != NULL); | |
| 74971473 JG |
73 | CU_ASSERT_PTR_EQUAL(node->data, &data2); |
| 74 | CU_ASSERT_PTR_NOT_NULL(node->prev_node); | |
| 75 | CU_ASSERT_PTR_NOT_NULL(node->next_node); | |
| 76 | ||
| 77 | node = node->next_node; | |
| fadf00aa JG |
78 | CU_ASSERT_PTR_NOT_NULL(node); |
| 79 | assert(node != NULL); | |
| 74971473 JG |
80 | CU_ASSERT_PTR_EQUAL(node->data, &data3); |
| 81 | CU_ASSERT_PTR_NOT_NULL(node->prev_node); | |
| 82 | CU_ASSERT_PTR_NULL(node->next_node); | |
| 83 | CU_ASSERT_PTR_EQUAL(handle->tail, node); | |
| 84 | ||
| 85 | dll_destroy(handle); | |
| 86 | } | |
| 87 | ||
| 88 | ||
| 89 | void test_dll_append_data() | |
| 90 | { | |
| 91 | dll_node_data data1, data2, data3; | |
| 92 | data1.int_data = 1; | |
| 93 | data2.int_data = 2; | |
| 94 | data3.int_data = 3; | |
| 95 | ||
| 96 | double_linked_list *handle = dll_initialize(); | |
| 97 | ||
| 98 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data1)); | |
| 99 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data2)); | |
| 100 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data3)); | |
| 101 | ||
| 102 | CU_ASSERT_EQUAL(handle->num_entries, 3); | |
| 103 | ||
| 104 | double_linked_list_node *node = handle->head; | |
| 105 | CU_ASSERT_PTR_EQUAL(node->data, &data1); | |
| 106 | CU_ASSERT_PTR_NULL(node->prev_node); | |
| 107 | CU_ASSERT_PTR_NOT_NULL(node->next_node); | |
| 108 | ||
| 109 | node = node->next_node; | |
| fadf00aa JG |
110 | CU_ASSERT_PTR_NOT_NULL(node); |
| 111 | assert(node != NULL); | |
| 74971473 JG |
112 | CU_ASSERT_PTR_EQUAL(node->data, &data2); |
| 113 | CU_ASSERT_PTR_NOT_NULL(node->prev_node); | |
| 114 | CU_ASSERT_PTR_NOT_NULL(node->next_node); | |
| 115 | ||
| 116 | node = node->next_node; | |
| fadf00aa JG |
117 | CU_ASSERT_PTR_NOT_NULL(node); |
| 118 | assert(node != NULL); | |
| 74971473 JG |
119 | CU_ASSERT_PTR_EQUAL(node->data, &data3); |
| 120 | CU_ASSERT_PTR_NOT_NULL(node->prev_node); | |
| 121 | CU_ASSERT_PTR_NULL(node->next_node); | |
| 122 | CU_ASSERT_PTR_EQUAL(handle->tail, node); | |
| 123 | ||
| 124 | dll_destroy(handle); | |
| 125 | } | |
| 126 | ||
| 127 | ||
| 128 | void test_dll_delete_first_node() | |
| 129 | { | |
| 130 | dll_node_data data1, data2; | |
| 131 | data1.int_data = 1; | |
| 132 | data2.int_data = 2; | |
| 133 | ||
| 134 | double_linked_list *handle = dll_initialize(); | |
| 135 | ||
| 136 | /* Test deleting with just 1 node in the list */ | |
| 137 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data1)); | |
| 138 | CU_ASSERT_EQUAL(handle->num_entries, 1); | |
| 139 | ||
| 140 | void *deleted_data = dll_delete_first_node(handle); | |
| 141 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 142 | CU_ASSERT_PTR_EQUAL(&data1, deleted_data); | |
| 143 | ||
| 144 | CU_ASSERT_EQUAL(handle->num_entries, 0); | |
| 145 | CU_ASSERT_PTR_NULL(handle->head); | |
| 146 | CU_ASSERT_PTR_NULL(handle->tail); | |
| 147 | ||
| 148 | /* Test deleting with 2 nodes in the list */ | |
| 149 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data1)); | |
| 150 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data2)); | |
| 151 | CU_ASSERT_EQUAL(handle->num_entries, 2); | |
| 152 | ||
| 153 | deleted_data = dll_delete_first_node(handle); | |
| 154 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 155 | CU_ASSERT_PTR_EQUAL(&data1, deleted_data); | |
| 156 | ||
| 157 | CU_ASSERT_EQUAL(handle->num_entries, 1); | |
| 158 | CU_ASSERT_PTR_EQUAL(handle->head->data, &data2); | |
| 159 | CU_ASSERT_PTR_EQUAL(handle->head, handle->tail); | |
| 160 | CU_ASSERT_PTR_NULL(handle->head->prev_node); | |
| 161 | CU_ASSERT_PTR_NULL(handle->head->next_node); | |
| 162 | ||
| 163 | dll_destroy(handle); | |
| 164 | } | |
| 165 | ||
| 166 | ||
| 167 | void test_dll_delete_last_node() | |
| 168 | { | |
| 169 | dll_node_data data1, data2; | |
| 170 | data1.int_data = 1; | |
| 171 | data2.int_data = 2; | |
| 172 | ||
| 173 | double_linked_list *handle = dll_initialize(); | |
| 174 | ||
| 175 | /* Test deleting with just 1 node in the list */ | |
| 176 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data1)); | |
| 177 | CU_ASSERT_EQUAL(handle->num_entries, 1); | |
| 178 | ||
| 179 | void *deleted_data = dll_delete_last_node(handle); | |
| 180 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 181 | CU_ASSERT_PTR_EQUAL(&data1, deleted_data); | |
| 182 | ||
| 183 | CU_ASSERT_EQUAL(handle->num_entries, 0); | |
| 184 | CU_ASSERT_PTR_NULL(handle->head); | |
| 185 | CU_ASSERT_PTR_NULL(handle->tail); | |
| 186 | ||
| 187 | /* Test deleting with 2 nodes in the list */ | |
| 188 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data1)); | |
| 189 | CU_ASSERT_PTR_NOT_NULL(dll_append(handle, &data2)); | |
| 190 | CU_ASSERT_EQUAL(handle->num_entries, 2); | |
| 191 | ||
| 192 | deleted_data = dll_delete_last_node(handle); | |
| 193 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 194 | CU_ASSERT_PTR_EQUAL(&data2, deleted_data); | |
| 195 | ||
| 196 | CU_ASSERT_EQUAL(handle->num_entries, 1); | |
| 197 | CU_ASSERT_PTR_EQUAL(handle->head->data, &data1); | |
| 198 | CU_ASSERT_PTR_EQUAL(handle->head, handle->tail); | |
| 199 | CU_ASSERT_PTR_NULL(handle->head->prev_node); | |
| 200 | CU_ASSERT_PTR_NULL(handle->head->next_node); | |
| 201 | ||
| 202 | dll_destroy(handle); | |
| 203 | } | |
| 204 | ||
| 205 | ||
| 206 | void test_dll_delete_node() | |
| 207 | { | |
| 208 | dll_node_data data1, data2, data3; | |
| 209 | data1.int_data = 1; | |
| 210 | data2.int_data = 2; | |
| 211 | data3.int_data = 3; | |
| 212 | double_linked_list_node *node1, *node2, *node3; | |
| 213 | double_linked_list *handle; | |
| 214 | ||
| 215 | /* Test deleting with just 1 node in the list */ | |
| 216 | handle = dll_initialize(); | |
| 217 | node1 = dll_append(handle, &data1); | |
| 218 | CU_ASSERT_PTR_NOT_NULL(node1); | |
| 219 | CU_ASSERT_EQUAL(handle->num_entries, 1); | |
| 220 | ||
| 221 | void *deleted_data = dll_delete_node(handle, node1); | |
| 222 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 223 | CU_ASSERT_PTR_EQUAL(&data1, deleted_data); | |
| 224 | ||
| 225 | CU_ASSERT_EQUAL(handle->num_entries, 0); | |
| 226 | CU_ASSERT_PTR_NULL(handle->head); | |
| 227 | CU_ASSERT_PTR_NULL(handle->tail); | |
| 228 | ||
| 229 | /* | |
| 230 | * Test deleting the head with 2 nodes in the list | |
| 231 | */ | |
| 232 | node1 = dll_append(handle, &data1); | |
| 233 | node2 = dll_append(handle, &data2); | |
| 234 | CU_ASSERT_PTR_NOT_NULL(node1); | |
| 235 | CU_ASSERT_PTR_NOT_NULL(node2); | |
| 236 | CU_ASSERT_EQUAL(handle->num_entries, 2); | |
| 237 | ||
| 238 | /* Delete the head entry */ | |
| 239 | deleted_data = dll_delete_node(handle, node1); | |
| 240 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 241 | CU_ASSERT_PTR_EQUAL(&data1, deleted_data); | |
| 242 | ||
| 243 | CU_ASSERT_EQUAL(handle->num_entries, 1); | |
| 244 | CU_ASSERT_PTR_EQUAL(handle->head->data, &data2); | |
| 245 | CU_ASSERT_PTR_EQUAL(handle->head, handle->tail); | |
| 246 | CU_ASSERT_PTR_NULL(handle->head->prev_node); | |
| 247 | CU_ASSERT_PTR_NULL(handle->head->next_node); | |
| 248 | dll_destroy(handle); | |
| 249 | ||
| 250 | /* | |
| 251 | * Test deleting the tail with 2 nodes in the list | |
| 252 | */ | |
| 253 | handle = dll_initialize(); | |
| 254 | node1 = dll_append(handle, &data1); | |
| 255 | node2 = dll_append(handle, &data2); | |
| 256 | CU_ASSERT_PTR_NOT_NULL(node1); | |
| 257 | CU_ASSERT_PTR_NOT_NULL(node2); | |
| 258 | CU_ASSERT_EQUAL(handle->num_entries, 2); | |
| 259 | ||
| 260 | /* Delete the tail entry */ | |
| 261 | deleted_data = dll_delete_node(handle, node2); | |
| 262 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 263 | CU_ASSERT_PTR_EQUAL(&data2, deleted_data); | |
| 264 | ||
| 265 | CU_ASSERT_EQUAL(handle->num_entries, 1); | |
| 266 | CU_ASSERT_PTR_EQUAL(handle->head->data, &data1); | |
| 267 | CU_ASSERT_PTR_EQUAL(handle->head, handle->tail); | |
| 268 | CU_ASSERT_PTR_NULL(handle->head->prev_node); | |
| 269 | CU_ASSERT_PTR_NULL(handle->head->next_node); | |
| 270 | dll_destroy(handle); | |
| 271 | ||
| 272 | /* | |
| 273 | * Test deleting in the middle with 3 nodes in the list | |
| 274 | */ | |
| 275 | handle = dll_initialize(); | |
| 276 | node1 = dll_append(handle, &data1); | |
| 277 | node2 = dll_append(handle, &data2); | |
| 278 | node3 = dll_append(handle, &data3); | |
| 279 | CU_ASSERT_PTR_NOT_NULL(node1); | |
| fadf00aa | 280 | assert(node1 != NULL); |
| 74971473 | 281 | CU_ASSERT_PTR_NOT_NULL(node2); |
| fadf00aa | 282 | assert(node2 != NULL); |
| 74971473 | 283 | CU_ASSERT_PTR_NOT_NULL(node3); |
| fadf00aa | 284 | assert(node3 != NULL); |
| 74971473 JG |
285 | CU_ASSERT_EQUAL(handle->num_entries, 3); |
| 286 | ||
| 287 | /* Delete the middle entry */ | |
| 288 | deleted_data = dll_delete_node(handle, node2); | |
| 289 | CU_ASSERT_PTR_NOT_NULL(deleted_data); | |
| 290 | CU_ASSERT_PTR_EQUAL(&data2, deleted_data); | |
| 291 | ||
| 292 | CU_ASSERT_EQUAL(handle->num_entries, 2); | |
| 293 | CU_ASSERT_PTR_EQUAL(handle->head, node1); | |
| 294 | CU_ASSERT_PTR_EQUAL(handle->tail, node3); | |
| 295 | CU_ASSERT_PTR_EQUAL(node1->data, &data1); | |
| 296 | CU_ASSERT_PTR_EQUAL(node3->data, &data3); | |
| 297 | CU_ASSERT_PTR_EQUAL(node1->next_node, node3); | |
| 298 | CU_ASSERT_PTR_EQUAL(node3->prev_node, node1); | |
| 299 | CU_ASSERT_PTR_NULL(node1->prev_node); | |
| 300 | CU_ASSERT_PTR_NULL(node3->next_node); | |
| 301 | ||
| 302 | dll_destroy(handle); | |
| 303 | } |