src/utils_latency_test.c

   1 /**
   2  * collectd - src/utils_latency_test.c
   3  * Copyright (C) 2015       Florian octo Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian octo Forster <octo at collectd.org>
  25  */
  26
  27 #define DBL_PRECISION 1e-6
  28
  29 #include "common.h" /* for STATIC_ARRAY_SIZE */
  30 #include "collectd.h"
  31
  32 #include "testing.h"
  33 #include "utils_time.h"
  34 #include "utils_latency.h"
  35
  36 DEF_TEST(simple)
  37 {
  38   struct {
  39     double val;
  40     double min;
  41     double max;
  42     double sum;
  43     double avg;
  44   } cases[] = {
  45   /* val  min  max  sum   avg */
  46     {0.5, 0.5, 0.5, 0.5,  0.5},
  47     {0.3, 0.3, 0.5, 0.8,  0.4},
  48     {0.7, 0.3, 0.7, 1.5,  0.5},
  49     {2.5, 0.3, 2.5, 4.0,  1.0},
  50     { 99, 0.3,  99, 103, 20.6},
  51     /* { -1, 0.3,  99, 103, 20.6}, see issue #1139 */
  52   };
  53   latency_counter_t *l;
  54
  55   CHECK_NOT_NULL (l = latency_counter_create ());
  56
  57   for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
  58     printf ("# case %zu: DOUBLE_TO_CDTIME_T(%g) = %"PRIu64"\n",
  59         i, cases[i].val, DOUBLE_TO_CDTIME_T (cases[i].val));
  60     latency_counter_add (l, DOUBLE_TO_CDTIME_T (cases[i].val));
  61
  62     EXPECT_EQ_DOUBLE (cases[i].min, CDTIME_T_TO_DOUBLE (latency_counter_get_min (l)));
  63     EXPECT_EQ_DOUBLE (cases[i].max, CDTIME_T_TO_DOUBLE (latency_counter_get_max (l)));
  64     EXPECT_EQ_DOUBLE (cases[i].sum, CDTIME_T_TO_DOUBLE (latency_counter_get_sum (l)));
  65     EXPECT_EQ_DOUBLE (cases[i].avg, CDTIME_T_TO_DOUBLE (latency_counter_get_average (l)));
  66   }
  67
  68   latency_counter_destroy (l);
  69   return 0;
  70 }
  71
  72 DEF_TEST(percentile)
  73 {
  74   latency_counter_t *l;
  75
  76   CHECK_NOT_NULL (l = latency_counter_create ());
  77
  78   for (size_t i = 0; i < 100; i++) {
  79     latency_counter_add (l, TIME_T_TO_CDTIME_T (((time_t) i) + 1));
  80   }
  81
  82   EXPECT_EQ_DOUBLE (  1.0, CDTIME_T_TO_DOUBLE (latency_counter_get_min (l)));
  83   EXPECT_EQ_DOUBLE (100.0, CDTIME_T_TO_DOUBLE (latency_counter_get_max (l)));
  84   EXPECT_EQ_DOUBLE (100.0 * 101.0 / 2.0, CDTIME_T_TO_DOUBLE (latency_counter_get_sum (l)));
  85   EXPECT_EQ_DOUBLE ( 50.5, CDTIME_T_TO_DOUBLE (latency_counter_get_average (l)));
  86
  87   EXPECT_EQ_DOUBLE (50.0, CDTIME_T_TO_DOUBLE (latency_counter_get_percentile (l, 50.0)));
  88   EXPECT_EQ_DOUBLE (80.0, CDTIME_T_TO_DOUBLE (latency_counter_get_percentile (l, 80.0)));
  89   EXPECT_EQ_DOUBLE (95.0, CDTIME_T_TO_DOUBLE (latency_counter_get_percentile (l, 95.0)));
  90   EXPECT_EQ_DOUBLE (99.0, CDTIME_T_TO_DOUBLE (latency_counter_get_percentile (l, 99.0)));
  91
  92   CHECK_ZERO (latency_counter_get_percentile (l, -1.0));
  93   CHECK_ZERO (latency_counter_get_percentile (l, 101.0));
  94
  95   latency_counter_destroy (l);
  96   return 0;
  97 }
  98
  99 DEF_TEST (rate) {
 100   size_t i;
 101   latency_counter_t *l;
 102
 103   CHECK_NOT_NULL (l = latency_counter_create ());
 104
 105   for (i = 0; i < 125; i++) {
 106     latency_counter_add (l, TIME_T_TO_CDTIME_T (((time_t) i) + 1));
 107   }
 108   //Test expects bin width will be equal to 0.125s
 109
 110   EXPECT_EQ_DOUBLE (1/125, latency_counter_get_rate (l,
 111       DOUBLE_TO_CDTIME_T(10),
 112       DOUBLE_TO_CDTIME_T(10),
 113       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 114     )
 115   );
 116   EXPECT_EQ_DOUBLE (0, latency_counter_get_rate (l,
 117       DOUBLE_TO_CDTIME_T(10.001),
 118       DOUBLE_TO_CDTIME_T(10.125),
 119       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 120     )
 121   );
 122   EXPECT_EQ_DOUBLE (1/125, latency_counter_get_rate (l,
 123       DOUBLE_TO_CDTIME_T(10.001),
 124       DOUBLE_TO_CDTIME_T(10.876),
 125       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 126     )
 127   );
 128   EXPECT_EQ_DOUBLE (2/125, latency_counter_get_rate (l,
 129       DOUBLE_TO_CDTIME_T(10.000),
 130       DOUBLE_TO_CDTIME_T(10.876),
 131       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 132     )
 133   );
 134   //Range
 135   EXPECT_EQ_DOUBLE (10.000 + 1.000/125, latency_counter_get_rate (l,
 136       DOUBLE_TO_CDTIME_T(10),
 137       DOUBLE_TO_CDTIME_T(20),
 138       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 139     )
 140   );
 141   //Range w/o interpolations
 142   EXPECT_EQ_DOUBLE (100, latency_counter_get_rate (l,
 143       DOUBLE_TO_CDTIME_T(0.001),
 144       DOUBLE_TO_CDTIME_T(100.0),
 145       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 146     )
 147   );
 148   //Full range
 149   EXPECT_EQ_DOUBLE (125.0, latency_counter_get_rate (l,
 150       DOUBLE_TO_CDTIME_T(0.001),
 151       0,
 152       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 153     )
 154   );
 155   //Overflow test
 156   EXPECT_EQ_DOUBLE (125.0, latency_counter_get_rate (l,
 157       DOUBLE_TO_CDTIME_T(0.001),
 158       DOUBLE_TO_CDTIME_T(100000),
 159       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 160     )
 161   );
 162
 163   //Split range to two parts
 164   EXPECT_EQ_DOUBLE (92.0, latency_counter_get_rate (l,
 165       DOUBLE_TO_CDTIME_T(0.001),
 166       DOUBLE_TO_CDTIME_T(92.00),
 167       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 168     )
 169   );
 170   EXPECT_EQ_DOUBLE (8, latency_counter_get_rate (l,
 171       DOUBLE_TO_CDTIME_T(92.001),
 172       DOUBLE_TO_CDTIME_T(100.00),
 173       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 174     )
 175   );
 176
 177   //Sum of rates for latencies [0.876, 1.000]
 178   EXPECT_EQ_DOUBLE (1, latency_counter_get_rate (l,
 179       DOUBLE_TO_CDTIME_T(0.876),
 180       DOUBLE_TO_CDTIME_T(1.000),
 181       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 182     )
 183   );
 184   double sum = 0;
 185   for (i = 875 ; i < 1000 ; i += 5) {
 186     sum += latency_counter_get_rate (l,
 187       DOUBLE_TO_CDTIME_T((double)(i+1)/1000),
 188       DOUBLE_TO_CDTIME_T((double)(i+5)/1000),
 189       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 190     );
 191     printf("b: %.15g\n",sum);
 192   };
 193   EXPECT_EQ_DOUBLE (1.000, sum);
 194
 195   EXPECT_EQ_DOUBLE (100/125, latency_counter_get_rate (l,
 196       DOUBLE_TO_CDTIME_T(99.875),
 197       DOUBLE_TO_CDTIME_T(99.975),
 198       latency_counter_get_start_time(l) + TIME_T_TO_CDTIME_T(1)
 199     )
 200   );
 201
 202   latency_counter_destroy (l);
 203   return 0;
 204 }
 205
 206 int main (void)
 207 {
 208   RUN_TEST(simple);
 209   RUN_TEST(percentile);
 210   RUN_TEST(rate);
 211
 212   END_TEST;
 213 }
 214
 215 /* vim: set sw=2 sts=2 et : */