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

/*
 * 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 <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);

	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);

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