[mirror_frr.git] / pceplib / test / pcep_utils_counters_test.c

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * This file is part of the PCEPlib, a PCEP protocol library.
 *
 * Copyright (C) 2020 Volta Networks https://voltanet.io/
 *
 * Author : Brady Johnson <brady@voltanet.io>
 *
 */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <assert.h>
#include <stdlib.h>

#include <CUnit/CUnit.h>

#include "pcep_utils_counters.h"
#include "pcep_utils_counters_test.h"


void test_create_counters_group()
{
	const char group_name[] = "group";
	uint16_t num_subgroups = 10;

	struct counters_group *group =
		create_counters_group(NULL, num_subgroups);
	CU_ASSERT_PTR_NULL(group);

	group = create_counters_group(group_name, MAX_COUNTER_GROUPS + 1);
	CU_ASSERT_PTR_NULL(group);

	group = create_counters_group(group_name, num_subgroups);
	CU_ASSERT_PTR_NOT_NULL(group);
	assert(group != NULL);

	CU_ASSERT_EQUAL(group->num_subgroups, 0);
	CU_ASSERT_EQUAL(group->max_subgroups, num_subgroups);
	CU_ASSERT_EQUAL(strcmp(group->counters_group_name, group_name), 0);

	delete_counters_group(group);
}

void test_create_counters_subgroup()
{
	const char subgroup_name[] = "subgroup";
	uint16_t subgroup_id = 10;
	uint16_t num_counters = 20;

	struct counters_subgroup *subgroup =
		create_counters_subgroup(NULL, subgroup_id, num_counters);
	CU_ASSERT_PTR_NULL(subgroup);

	subgroup = create_counters_subgroup(
		subgroup_name, MAX_COUNTER_GROUPS + 1, num_counters);
	CU_ASSERT_PTR_NULL(subgroup);

	subgroup = create_counters_subgroup(subgroup_name, subgroup_id,
					    MAX_COUNTERS + 1);
	CU_ASSERT_PTR_NULL(subgroup);

	subgroup = create_counters_subgroup(subgroup_name, subgroup_id,
					    num_counters);
	CU_ASSERT_PTR_NOT_NULL(subgroup);
	assert(subgroup != NULL);

	CU_ASSERT_EQUAL(subgroup->subgroup_id, subgroup_id);
	CU_ASSERT_EQUAL(subgroup->num_counters, 0);
	CU_ASSERT_EQUAL(subgroup->max_counters, num_counters);
	CU_ASSERT_EQUAL(strcmp(subgroup->counters_subgroup_name, subgroup_name),
			0);

	delete_counters_subgroup(subgroup);
}

void test_add_counters_subgroup()
{
	struct counters_group *group = create_counters_group("group", 1);
	struct counters_subgroup *subgroup1 =
		create_counters_subgroup("subgroup", 0, 5);
	struct counters_subgroup *subgroup2 =
		create_counters_subgroup("subgroup", 1, 5);

	CU_ASSERT_FALSE(add_counters_subgroup(NULL, NULL));
	CU_ASSERT_FALSE(add_counters_subgroup(NULL, subgroup1));
	CU_ASSERT_FALSE(add_counters_subgroup(group, NULL));

	CU_ASSERT_EQUAL(group->num_subgroups, 0);
	CU_ASSERT_TRUE(add_counters_subgroup(group, subgroup1));
	CU_ASSERT_EQUAL(group->num_subgroups, 1);
	/* Cant add more than num_subgroups to the group */
	CU_ASSERT_FALSE(add_counters_subgroup(group, subgroup2));

	CU_ASSERT_PTR_NOT_NULL(find_subgroup(group, 0));
	CU_ASSERT_PTR_NULL(find_subgroup(group, 1));

	delete_counters_group(group);
	delete_counters_subgroup(subgroup2);
}

void test_create_subgroup_counter()
{
	uint16_t counter_id = 1;
	char counter_name[] = "my counter";
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", 1, 2);

	CU_ASSERT_FALSE(
		create_subgroup_counter(NULL, counter_id, counter_name));
	CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id + 1,
						counter_name));
	CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id, NULL));
	CU_ASSERT_EQUAL(subgroup->num_counters, 0);
	CU_ASSERT_TRUE(
		create_subgroup_counter(subgroup, counter_id, counter_name));
	CU_ASSERT_EQUAL(subgroup->num_counters, 1);

	delete_counters_subgroup(subgroup);
}

void test_delete_counters_group()
{
	struct counters_group *group = create_counters_group("group", 1);

	CU_ASSERT_FALSE(delete_counters_group(NULL));
	CU_ASSERT_TRUE(delete_counters_group(group));
}

void test_delete_counters_subgroup()
{
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", 1, 1);

	CU_ASSERT_FALSE(delete_counters_subgroup(NULL));
	CU_ASSERT_TRUE(delete_counters_subgroup(subgroup));
}

void test_reset_group_counters()
{
	uint16_t subgroup_id = 1;
	uint16_t counter_id = 1;
	struct counters_group *group = create_counters_group("group", 10);
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", subgroup_id, 10);
	create_subgroup_counter(subgroup, counter_id, "counter");
	add_counters_subgroup(group, subgroup);

	struct counter *counter = subgroup->counters[counter_id];
	counter->counter_value = 100;

	CU_ASSERT_FALSE(reset_group_counters(NULL));
	CU_ASSERT_TRUE(reset_group_counters(group));
	CU_ASSERT_EQUAL(counter->counter_value, 0);

	delete_counters_group(group);
}

void test_reset_subgroup_counters()
{
	uint16_t counter_id = 1;
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", 1, 10);
	create_subgroup_counter(subgroup, counter_id, "counter");

	struct counter *counter = subgroup->counters[counter_id];
	counter->counter_value = 100;

	CU_ASSERT_FALSE(reset_subgroup_counters(NULL));
	CU_ASSERT_TRUE(reset_subgroup_counters(subgroup));
	CU_ASSERT_EQUAL(counter->counter_value, 0);

	delete_counters_subgroup(subgroup);
}

void test_increment_counter()
{
	uint16_t subgroup_id = 1;
	uint16_t counter_id = 1;
	struct counters_group *group = create_counters_group("group", 10);
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", subgroup_id, 10);
	create_subgroup_counter(subgroup, counter_id, "counter");
	add_counters_subgroup(group, subgroup);

	struct counter *counter = subgroup->counters[counter_id];
	counter->counter_value = 100;

	CU_ASSERT_FALSE(increment_counter(NULL, subgroup_id, counter_id));
	CU_ASSERT_FALSE(increment_counter(group, 100, counter_id));
	CU_ASSERT_FALSE(increment_counter(group, subgroup_id, 123));
	CU_ASSERT_TRUE(increment_counter(group, subgroup_id, counter_id));
	CU_ASSERT_EQUAL(counter->counter_value, 101);
	CU_ASSERT_EQUAL(subgroup_counters_total(subgroup), 101);

	delete_counters_group(group);
}

void test_increment_subgroup_counter()
{
	int counter_id = 1;
	uint32_t counter_value = 100;
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", 1, 10);
	create_subgroup_counter(subgroup, counter_id, "counter");

	struct counter *counter = subgroup->counters[counter_id];
	counter->counter_value = counter_value;

	CU_ASSERT_FALSE(increment_subgroup_counter(NULL, counter_id));
	CU_ASSERT_FALSE(increment_subgroup_counter(subgroup, counter_id + 1));
	CU_ASSERT_TRUE(increment_subgroup_counter(subgroup, counter_id));
	CU_ASSERT_EQUAL(counter->counter_value, counter_value + 1);

	delete_counters_subgroup(subgroup);
}

void test_dump_counters_group_to_log()
{
	uint16_t subgroup_id = 1;
	uint16_t counter_id = 1;
	struct counters_group *group = create_counters_group("group", 10);
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", subgroup_id, 10);
	create_subgroup_counter(subgroup, counter_id, "counter");
	add_counters_subgroup(group, subgroup);

	CU_ASSERT_FALSE(dump_counters_group_to_log(NULL));
	CU_ASSERT_TRUE(dump_counters_group_to_log(group));

	delete_counters_group(group);
}

void test_dump_counters_subgroup_to_log()
{
	uint16_t subgroup_id = 1;
	uint16_t counter_id = 1;
	struct counters_subgroup *subgroup =
		create_counters_subgroup("subgroup", subgroup_id, 10);
	create_subgroup_counter(subgroup, counter_id, "counter");

	CU_ASSERT_FALSE(dump_counters_subgroup_to_log(NULL));
	CU_ASSERT_TRUE(dump_counters_subgroup_to_log(subgroup));

	delete_counters_subgroup(subgroup);
}
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 <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);
fadf00aa	39	assert(group != NULL);
74971473 JG	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);
fadf00aa	69	assert(subgroup != NULL);
74971473 JG	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	}