stats: Rewrite group-by discrete test to be more thorough

This will also help with expanding the test in later commits.

diff --git a/src/stats/test-stats-metrics.c b/src/stats/test-stats-metrics.c
index 7295231bf2fd069ac682af9be2f03164487cc3d7..e80ef64ebedad347f7a284d987f62b1ce18cecbb 100644 (file)
--- a/src/stats/test-stats-metrics.c
+++ b/src/stats/test-stats-metrics.c
@@ -90,97 +90,142 @@ static void test_stats_metrics_filter(void)
        test_end();
 }
 
-static const char *settings_blob_3 =
-"metric=test\n"
-"metric/test/name=test\n"
-"metric/test/event_name=test\n"
-"metric/test/group_by=test_name sub_name\n"
-"\n";
-
-static void test_stats_metrics_group_by(void)
+static void test_stats_metrics_group_by_check_one(const struct metric *metric,
+                                                 const char *sub_name,
+                                                 unsigned int total_count,
+                                                 unsigned int submetric_count,
+                                                 unsigned int group_by_count,
+                                                 enum stats_metric_group_by_func group_by_func,
+                                                 const char *group_by_field,
+                                                 enum metric_value_type value_type)
 {
-       test_begin("stats metrics (group by)");
+       test_assert_strcmp(metric->name, "test");
 
-       test_init(settings_blob_3);
+       if (sub_name != NULL)
+               test_assert_strcmp(metric->sub_name, sub_name);
+       else
+               test_assert(metric->sub_name == NULL);
 
-       struct event *event;
+       test_assert(stats_dist_get_count(metric->duration_stats) == total_count);
 
-       event = event_create(NULL);
-       event_add_category(event, &test_category);
-       event_set_name(event, "test");
-       event_add_str(event, "test_name", "alpha");
-       event_add_str(event, "sub_name", "eta");
-       test_event_send(event);
-       event_unref(&event);
+       if (submetric_count > 0) {
+               test_assert(array_is_created(&metric->sub_metrics));
+               test_assert(array_count(&metric->sub_metrics) == submetric_count);
+       } else {
+               test_assert(!array_is_created(&metric->sub_metrics));
+       }
 
-       event = event_create(NULL);
-       event_add_category(event, &test_category);
-       event_set_name(event, "test");
-       event_add_str(event, "test_name", "phi");
-       event_add_str(event, "sub_name", "beta");
-       test_event_send(event);
-       event_unref(&event);
+       if (group_by_count > 0) {
+               test_assert(metric->group_by_count == group_by_count);
+               test_assert(metric->group_by != NULL);
+               test_assert(metric->group_by[0].func == group_by_func);
+               test_assert_strcmp(metric->group_by[0].field, group_by_field);
+       } else {
+               test_assert(metric->group_by_count == 0);
+               test_assert(metric->group_by == NULL);
+       }
 
-       event = event_create(NULL);
-       event_add_category(event, &test_category);
-       event_set_name(event, "test");
-       event_add_str(event, "test_name", "omega");
-       event_add_str(event, "sub_name", "pi");
-       test_event_send(event);
-       event_unref(&event);
+       test_assert(metric->group_value.type == value_type);
+}
 
-       /* we should have now three events */
-       test_assert(get_stats_dist_field("test", STATS_DIST_COUNT) == 3);
+#define DISCRETE_TEST_VAL_COUNT        3
+struct discrete_test {
+       const char *settings_blob;
+       unsigned int num_values;
+       const char *values_first[DISCRETE_TEST_VAL_COUNT];
+       const char *values_second[DISCRETE_TEST_VAL_COUNT];
+};
+
+static const struct discrete_test discrete_tests[] = {
+       {
+               "test_name sub_name",
+               3,
+               { "eta", "kappa", "nu", },
+               { "upsilon", "pi", "epsilon", },
+       },
+};
+
+static void test_stats_metrics_group_by_discrete_real(const struct discrete_test *test)
+{
+       struct event *event;
+       unsigned int i, j;
+
+       test_begin(t_strdup_printf("stats metrics (discrete group by) - %s",
+                                  test->settings_blob));
+
+       test_init(t_strdup_printf("metric=test\n"
+                                 "metric/test/name=test\n"
+                                 "metric/test/event_name=test\n"
+                                 "metric/test/group_by=%s\n"
+                                 "\n", test->settings_blob));
+
+       for (i = 0; i < test->num_values; i++) {
+               for (j = 0; j < test->num_values; j++) {
+                       event = event_create(NULL);
+                       event_add_category(event, &test_category);
+                       event_set_name(event, "test");
+                       event_add_str(event, "test_name", test->values_first[i]);
+                       event_add_str(event, "sub_name", test->values_second[j]);
+                       test_event_send(event);
+                       event_unref(&event);
+               }
+       }
+
+       /* check total number of events */
+       test_assert(get_stats_dist_field("test", STATS_DIST_COUNT) == test->num_values * test->num_values);
 
        /* analyze the structure */
-       const struct metric *root_metric, *leaf ATTR_UNUSED;
-       struct metric *const *children;
        struct stats_metrics_iter *iter = stats_metrics_iterate_init(metrics);
-       root_metric = stats_metrics_iterate(iter);
+       const struct metric *root_metric = stats_metrics_iterate(iter);
        stats_metrics_iterate_deinit(&iter);
 
-       test_assert(array_is_created(&root_metric->sub_metrics));
-       test_assert(array_count(&root_metric->sub_metrics) == 3);
-
-       /* then look at each level */
-       children = array_idx(&root_metric->sub_metrics, 0);
-       test_assert_strcmp(children[0]->sub_name, "alpha");
-       test_assert(stats_dist_get_count(children[0]->duration_stats) == 1);
-
-       test_assert(array_is_created(&children[0]->sub_metrics));
-       test_assert(array_count(&children[0]->sub_metrics) == 1);
-
-       leaf = *array_idx(&children[0]->sub_metrics, 0);
-       test_assert_strcmp(leaf->sub_name, "eta");
-       test_assert(stats_dist_get_count(leaf->duration_stats) == 1);
-
-       test_assert_strcmp(children[1]->sub_name, "phi");
-
-       test_assert(array_is_created(&children[1]->sub_metrics));
-       test_assert(array_count(&children[1]->sub_metrics) == 1);
-
-       leaf = *array_idx(&children[1]->sub_metrics, 0);
-       test_assert_strcmp(leaf->sub_name, "beta");
-       test_assert(stats_dist_get_count(leaf->duration_stats) == 1);
-
-       test_assert_strcmp(children[2]->sub_name, "omega");
-
-       test_assert(array_is_created(&children[2]->sub_metrics));
-       test_assert(array_count(&children[2]->sub_metrics) == 1);
-
-       leaf = *array_idx(&children[2]->sub_metrics, 0);
-       test_assert_strcmp(leaf->sub_name, "pi");
-       test_assert(stats_dist_get_count(leaf->duration_stats) == 1);
+       test_stats_metrics_group_by_check_one(root_metric,
+                                             NULL,
+                                             test->num_values * test->num_values,
+                                             test->num_values,
+                                             2, STATS_METRIC_GROUPBY_DISCRETE,
+                                             "test_name", 0);
+
+       struct metric *const *first = array_idx(&root_metric->sub_metrics, 0);
+
+       /* examime each sub-metric */
+       for (i = 0; i < test->num_values; i++) {
+               test_stats_metrics_group_by_check_one(first[i],
+                                                     test->values_first[i],
+                                                     test->num_values,
+                                                     test->num_values,
+                                                     1, STATS_METRIC_GROUPBY_DISCRETE,
+                                                     "sub_name",
+                                                     METRIC_VALUE_TYPE_STR);
+
+               struct metric *const *second = array_idx(&first[i]->sub_metrics, 0);
+
+               /* examine each sub-sub-metric */
+               for (j = 0; j < test->num_values; j++) {
+                       test_stats_metrics_group_by_check_one(second[j],
+                                                             test->values_second[j],
+                                                             1, 0, 0, 0, NULL,
+                                                             METRIC_VALUE_TYPE_STR);
+               }
+       }
 
        test_deinit();
        test_end();
 }
 
+static void test_stats_metrics_group_by_discrete(void)
+{
+       unsigned int i;
+
+       for (i = 0; i < N_ELEMENTS(discrete_tests); i++)
+               test_stats_metrics_group_by_discrete_real(&discrete_tests[i]);
+}
+
 int main(void) {
        void (*const test_functions[])(void) = {
                test_stats_metrics,
                test_stats_metrics_filter,
-               test_stats_metrics_group_by,
+               test_stats_metrics_group_by_discrete,
                NULL
        };