pceplib/test/pcep_utils_counters_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 <assert.h>
  17 #include <stdlib.h>
  18
  19 #include <CUnit/CUnit.h>
  20
  21 #include "pcep_utils_counters.h"
  22 #include "pcep_utils_counters_test.h"
  23
  24
  25 void test_create_counters_group()
  26 {
  27         const char group_name[] = "group";
  28         uint16_t num_subgroups = 10;
  29
  30         struct counters_group *group =
  31                 create_counters_group(NULL, num_subgroups);
  32         CU_ASSERT_PTR_NULL(group);
  33
  34         group = create_counters_group(group_name, MAX_COUNTER_GROUPS + 1);
  35         CU_ASSERT_PTR_NULL(group);
  36
  37         group = create_counters_group(group_name, num_subgroups);
  38         CU_ASSERT_PTR_NOT_NULL(group);
  39         assert(group != NULL);
  40
  41         CU_ASSERT_EQUAL(group->num_subgroups, 0);
  42         CU_ASSERT_EQUAL(group->max_subgroups, num_subgroups);
  43         CU_ASSERT_EQUAL(strcmp(group->counters_group_name, group_name), 0);
  44
  45         delete_counters_group(group);
  46 }
  47
  48 void test_create_counters_subgroup()
  49 {
  50         const char subgroup_name[] = "subgroup";
  51         uint16_t subgroup_id = 10;
  52         uint16_t num_counters = 20;
  53
  54         struct counters_subgroup *subgroup =
  55                 create_counters_subgroup(NULL, subgroup_id, num_counters);
  56         CU_ASSERT_PTR_NULL(subgroup);
  57
  58         subgroup = create_counters_subgroup(
  59                 subgroup_name, MAX_COUNTER_GROUPS + 1, num_counters);
  60         CU_ASSERT_PTR_NULL(subgroup);
  61
  62         subgroup = create_counters_subgroup(subgroup_name, subgroup_id,
  63                                             MAX_COUNTERS + 1);
  64         CU_ASSERT_PTR_NULL(subgroup);
  65
  66         subgroup = create_counters_subgroup(subgroup_name, subgroup_id,
  67                                             num_counters);
  68         CU_ASSERT_PTR_NOT_NULL(subgroup);
  69         assert(subgroup != NULL);
  70
  71         CU_ASSERT_EQUAL(subgroup->subgroup_id, subgroup_id);
  72         CU_ASSERT_EQUAL(subgroup->num_counters, 0);
  73         CU_ASSERT_EQUAL(subgroup->max_counters, num_counters);
  74         CU_ASSERT_EQUAL(strcmp(subgroup->counters_subgroup_name, subgroup_name),
  75                         0);
  76
  77         delete_counters_subgroup(subgroup);
  78 }
  79
  80 void test_add_counters_subgroup()
  81 {
  82         struct counters_group *group = create_counters_group("group", 1);
  83         struct counters_subgroup *subgroup1 =
  84                 create_counters_subgroup("subgroup", 0, 5);
  85         struct counters_subgroup *subgroup2 =
  86                 create_counters_subgroup("subgroup", 1, 5);
  87
  88         CU_ASSERT_FALSE(add_counters_subgroup(NULL, NULL));
  89         CU_ASSERT_FALSE(add_counters_subgroup(NULL, subgroup1));
  90         CU_ASSERT_FALSE(add_counters_subgroup(group, NULL));
  91
  92         CU_ASSERT_EQUAL(group->num_subgroups, 0);
  93         CU_ASSERT_TRUE(add_counters_subgroup(group, subgroup1));
  94         CU_ASSERT_EQUAL(group->num_subgroups, 1);
  95         /* Cant add more than num_subgroups to the group */
  96         CU_ASSERT_FALSE(add_counters_subgroup(group, subgroup2));
  97
  98         CU_ASSERT_PTR_NOT_NULL(find_subgroup(group, 0));
  99         CU_ASSERT_PTR_NULL(find_subgroup(group, 1));
 100
 101         delete_counters_group(group);
 102         delete_counters_subgroup(subgroup2);
 103 }
 104
 105 void test_create_subgroup_counter()
 106 {
 107         uint16_t counter_id = 1;
 108         char counter_name[] = "my counter";
 109         struct counters_subgroup *subgroup =
 110                 create_counters_subgroup("subgroup", 1, 2);
 111
 112         CU_ASSERT_FALSE(
 113                 create_subgroup_counter(NULL, counter_id, counter_name));
 114         CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id + 1,
 115                                                 counter_name));
 116         CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id, NULL));
 117         CU_ASSERT_EQUAL(subgroup->num_counters, 0);
 118         CU_ASSERT_TRUE(
 119                 create_subgroup_counter(subgroup, counter_id, counter_name));
 120         CU_ASSERT_EQUAL(subgroup->num_counters, 1);
 121
 122         delete_counters_subgroup(subgroup);
 123 }
 124
 125 void test_delete_counters_group()
 126 {
 127         struct counters_group *group = create_counters_group("group", 1);
 128
 129         CU_ASSERT_FALSE(delete_counters_group(NULL));
 130         CU_ASSERT_TRUE(delete_counters_group(group));
 131 }
 132
 133 void test_delete_counters_subgroup()
 134 {
 135         struct counters_subgroup *subgroup =
 136                 create_counters_subgroup("subgroup", 1, 1);
 137
 138         CU_ASSERT_FALSE(delete_counters_subgroup(NULL));
 139         CU_ASSERT_TRUE(delete_counters_subgroup(subgroup));
 140 }
 141
 142 void test_reset_group_counters()
 143 {
 144         uint16_t subgroup_id = 1;
 145         uint16_t counter_id = 1;
 146         struct counters_group *group = create_counters_group("group", 10);
 147         struct counters_subgroup *subgroup =
 148                 create_counters_subgroup("subgroup", subgroup_id, 10);
 149         create_subgroup_counter(subgroup, counter_id, "counter");
 150         add_counters_subgroup(group, subgroup);
 151
 152         struct counter *counter = subgroup->counters[counter_id];
 153         counter->counter_value = 100;
 154
 155         CU_ASSERT_FALSE(reset_group_counters(NULL));
 156         CU_ASSERT_TRUE(reset_group_counters(group));
 157         CU_ASSERT_EQUAL(counter->counter_value, 0);
 158
 159         delete_counters_group(group);
 160 }
 161
 162 void test_reset_subgroup_counters()
 163 {
 164         uint16_t counter_id = 1;
 165         struct counters_subgroup *subgroup =
 166                 create_counters_subgroup("subgroup", 1, 10);
 167         create_subgroup_counter(subgroup, counter_id, "counter");
 168
 169         struct counter *counter = subgroup->counters[counter_id];
 170         counter->counter_value = 100;
 171
 172         CU_ASSERT_FALSE(reset_subgroup_counters(NULL));
 173         CU_ASSERT_TRUE(reset_subgroup_counters(subgroup));
 174         CU_ASSERT_EQUAL(counter->counter_value, 0);
 175
 176         delete_counters_subgroup(subgroup);
 177 }
 178
 179 void test_increment_counter()
 180 {
 181         uint16_t subgroup_id = 1;
 182         uint16_t counter_id = 1;
 183         struct counters_group *group = create_counters_group("group", 10);
 184         struct counters_subgroup *subgroup =
 185                 create_counters_subgroup("subgroup", subgroup_id, 10);
 186         create_subgroup_counter(subgroup, counter_id, "counter");
 187         add_counters_subgroup(group, subgroup);
 188
 189         struct counter *counter = subgroup->counters[counter_id];
 190         counter->counter_value = 100;
 191
 192         CU_ASSERT_FALSE(increment_counter(NULL, subgroup_id, counter_id));
 193         CU_ASSERT_FALSE(increment_counter(group, 100, counter_id));
 194         CU_ASSERT_FALSE(increment_counter(group, subgroup_id, 123));
 195         CU_ASSERT_TRUE(increment_counter(group, subgroup_id, counter_id));
 196         CU_ASSERT_EQUAL(counter->counter_value, 101);
 197         CU_ASSERT_EQUAL(subgroup_counters_total(subgroup), 101);
 198
 199         delete_counters_group(group);
 200 }
 201
 202 void test_increment_subgroup_counter()
 203 {
 204         int counter_id = 1;
 205         uint32_t counter_value = 100;
 206         struct counters_subgroup *subgroup =
 207                 create_counters_subgroup("subgroup", 1, 10);
 208         create_subgroup_counter(subgroup, counter_id, "counter");
 209
 210         struct counter *counter = subgroup->counters[counter_id];
 211         counter->counter_value = counter_value;
 212
 213         CU_ASSERT_FALSE(increment_subgroup_counter(NULL, counter_id));
 214         CU_ASSERT_FALSE(increment_subgroup_counter(subgroup, counter_id + 1));
 215         CU_ASSERT_TRUE(increment_subgroup_counter(subgroup, counter_id));
 216         CU_ASSERT_EQUAL(counter->counter_value, counter_value + 1);
 217
 218         delete_counters_subgroup(subgroup);
 219 }
 220
 221 void test_dump_counters_group_to_log()
 222 {
 223         uint16_t subgroup_id = 1;
 224         uint16_t counter_id = 1;
 225         struct counters_group *group = create_counters_group("group", 10);
 226         struct counters_subgroup *subgroup =
 227                 create_counters_subgroup("subgroup", subgroup_id, 10);
 228         create_subgroup_counter(subgroup, counter_id, "counter");
 229         add_counters_subgroup(group, subgroup);
 230
 231         CU_ASSERT_FALSE(dump_counters_group_to_log(NULL));
 232         CU_ASSERT_TRUE(dump_counters_group_to_log(group));
 233
 234         delete_counters_group(group);
 235 }
 236
 237 void test_dump_counters_subgroup_to_log()
 238 {
 239         uint16_t subgroup_id = 1;
 240         uint16_t counter_id = 1;
 241         struct counters_subgroup *subgroup =
 242                 create_counters_subgroup("subgroup", subgroup_id, 10);
 243         create_subgroup_counter(subgroup, counter_id, "counter");
 244
 245         CU_ASSERT_FALSE(dump_counters_subgroup_to_log(NULL));
 246         CU_ASSERT_TRUE(dump_counters_subgroup_to_log(subgroup));
 247
 248         delete_counters_subgroup(subgroup);
 249 }