pceplib/test/pcep_utils_counters_test.c

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