senf/Utils/Statistics.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief Statistics unit tests */
  25
  26 //#include "Statistics.test.hh"
  27 //#include "Statistics.test.ih"
  28
  29 // Custom includes
  30 #include "Statistics.hh"
  31 #include "StatisticsTargets.hh"
  32 #include <boost/tokenizer.hpp>
  33 #include <boost/iterator/transform_iterator.hpp>
  34 #include <boost/iterator/filter_iterator.hpp>
  35
  36 #include "auto_unit_test.hh"
  37 #include <boost/test/test_tools.hpp>
  38 #include <boost/test/floating_point_comparison.hpp>
  39
  40 #define prefix_
  41 ///////////////////////////////cc.p////////////////////////////////////////
  42
  43 namespace {
  44
  45     struct GetRange
  46     {
  47         typedef senf::Collector const & first_argument_type;
  48         typedef unsigned result_type;
  49         result_type operator()(first_argument_type arg) const
  50             { return arg.rank(); }
  51     };
  52
  53
  54     struct splitFloats
  55     {
  56         typedef boost::char_separator<char> Separator;
  57         typedef boost::tokenizer<Separator> Tokenizer;
  58         struct Pred {
  59             bool operator()(std::string const & s) const
  60                 { try { boost::lexical_cast<double>(s); return true; }
  61                     catch (std::bad_cast &) { return false; } }
  62         };
  63         typedef boost::filter_iterator<Pred,Tokenizer::iterator> FilterIterator;
  64         struct Trafo {
  65             typedef double result_type;
  66             result_type operator()(std::string const & s) const
  67                 { return boost::lexical_cast<double>(s); }
  68         };
  69         typedef boost::transform_iterator<Trafo,FilterIterator> TransformIterator;
  70
  71         typedef TransformIterator iterator;
  72         typedef TransformIterator const_iterator;
  73
  74         splitFloats(std::string const & s) : s_ (s), sep_ (" \n"), tok_ (s_, sep_) {}
  75         TransformIterator begin() const { return TransformIterator(FilterIterator(tok_.begin())); }
  76         TransformIterator end() const { return TransformIterator(FilterIterator(tok_.end())); }
  77
  78         std::string s_;
  79         Separator sep_;
  80         Tokenizer tok_;
  81     };
  82
  83     template <class R1, class R2>
  84     void CHECK_CLOSE_RANGES(R1 const & r1, R2 const & r2, double delta)
  85     {
  86         typedef typename boost::range_const_iterator<R1>::type I1;
  87         typedef typename boost::range_const_iterator<R2>::type I2;
  88
  89         I1 i1 (boost::begin(r1));
  90         I1 i1_end (boost::end(r1));
  91         I2 i2 (boost::begin(r2));
  92         I2 i2_end (boost::end(r2));
  93
  94         for (; i1 != i1_end && i2 != i2_end; ++i1, ++i2) {
  95             BOOST_CHECK_CLOSE(*i1, *i2, delta);
  96         }
  97
  98         BOOST_CHECK( i1 == i1_end );
  99         BOOST_CHECK( i2 == i2_end );
 100     }
 101 }
 102
 103 BOOST_AUTO_UNIT_TEST(statistics)
 104 {
 105     senf::Statistics stats;
 106     senf::log::StringTarget statslog;
 107
 108     statslog.tag("");
 109     statslog.showTime(false);
 110     statslog.showArea(false);
 111     statslog.showLevel(false);
 112     statslog.route<senf::StatisticsStream>();
 113
 114     stats
 115             .output(2u).connect(
 116                 senf::StatisticsLogger("level0"))
 117         .collect(4u)
 118             .output().connect(
 119                 senf::StatisticsLogger("level1"))
 120             .output(3u).connect(
 121                 senf::StatisticsLogger("averaged1"))
 122         .collect(3u)
 123         .collect(2u)
 124             .output().connect(
 125                 senf::StatisticsLogger("level3"));
 126
 127     unsigned children1[] = { 4u };
 128     BOOST_CHECK_EQUAL_COLLECTIONS(
 129         boost::make_transform_iterator(stats.collectors().begin(), GetRange()),
 130         boost::make_transform_iterator(stats.collectors().end(), GetRange()),
 131         children1, children1 + sizeof(children1)/sizeof(children1[0]) );
 132
 133     unsigned children2[] = { 3u };
 134     BOOST_CHECK_EQUAL_COLLECTIONS(
 135         boost::make_transform_iterator(stats[4].collectors().begin(), GetRange()),
 136         boost::make_transform_iterator(stats[4].collectors().end(), GetRange()),
 137         children2, children2 + sizeof(children2)/sizeof(children2[0]) );
 138
 139     unsigned children3[] = { 2u };
 140     BOOST_CHECK_EQUAL_COLLECTIONS(
 141         boost::make_transform_iterator(stats[4][3].collectors().begin(), GetRange()),
 142         boost::make_transform_iterator(stats[4][3].collectors().end(), GetRange()),
 143         children3, children3 + sizeof(children3)/sizeof(children3[0]) );
 144
 145     float values[][3] = {
 146         { -1.0f,  2.3f,  2.5f }, {  0.3f,  2.4f,  3.8f }, { -1.1f, -0.3f,  0.0f },
 147         { -0.3f,  3.2f,  3.3f }, {  1.0f,  1.1f,  1.1f }, {  0.5f,  0.5f,  0.5f },
 148         {  0.0f,  0.0f,  0.0f }, { -2.0f, -1.8f, -1.0f }, {  0.0f,  2.3f,  2.4f },
 149         {  0.4f,  1.2f,  2.0f }, { -1.0f,  2.3f,  2.5f }, {  0.3f,  2.4f,  3.8f },
 150         { -1.1f, -0.3f,  0.0f }, { -0.3f,  3.2f,  3.3f }, {  1.0f,  1.1f,  1.1f },
 151         {  0.5f,  0.5f,  0.5f }, {  0.0f,  0.0f,  0.0f }, { -2.0f, -1.8f, -1.0f },
 152         {  0.0f,  2.3f,  2.4f }, {  0.4f,  1.2f,  2.0f }, { -1.0f,  2.3f,  2.5f },
 153         {  0.3f,  2.4f,  3.8f }, { -1.1f, -0.3f,  0.0f }, { -0.3f,  3.2f,  3.3f },
 154         {  1.0f,  1.1f,  1.1f }, {  0.5f,  0.5f,  0.5f }, {  0.0f,  0.0f,  0.0f },
 155         { -2.0f, -1.8f, -1.0f }, {  0.0f,  2.3f,  2.4f }, {  0.4f,  1.2f,  4.0f } };
 156
 157     for (unsigned i (0); i < sizeof(values)/sizeof(values[0]); ++i)
 158         stats(values[i][0], values[i][1], values[i][2]);
 159
 160     BOOST_CHECK_CLOSE( stats.min(), 0.4f, .001f );
 161     BOOST_CHECK_CLOSE( stats.avg(), 1.2f, .001f );
 162     BOOST_CHECK_CLOSE( stats.max(), 4.0f, .001f );
 163     BOOST_CHECK_CLOSE( stats.dev(), 0.0f, .001f );
 164
 165     BOOST_CHECK_CLOSE( stats[4].min(), -2.0f, .001f );
 166     BOOST_CHECK_CLOSE( stats[4].avg(), -0.05f, .001f );
 167     BOOST_CHECK_CLOSE( stats[4].max(), 1.1f, .001f );
 168     BOOST_CHECK_CLOSE( stats[4].dev(), 1.08282f, .001f );
 169
 170     BOOST_CHECK_CLOSE( stats[4][3].min(), -2.0f, .001f );
 171     BOOST_CHECK_CLOSE( stats[4][3].avg(), 1.15f, .001f );
 172     BOOST_CHECK_CLOSE( stats[4][3].max(),  3.8f, .001f );
 173
 174     CHECK_CLOSE_RANGES( splitFloats(statslog.str()),
 175                         splitFloats("level0 -1 2.3 2.5 0\n"
 176                                     "level0 -0.35 2.35 3.15 0\n"
 177                                     "level0 -0.4 1.05 1.9 0\n"
 178                                     "level0 -0.7 1.45 1.65 0\n"
 179                                     "level1 -1.1 1.9 3.8 1.31719\n"
 180                                     "averaged1 -1.1 1.9 3.8 1.31719\n"
 181                                     "level0 0.35 2.15 2.2 0\n"
 182                                     "level0 0.75 0.8 0.8 0\n"
 183                                     "level0 0.25 0.25 0.25 0\n"
 184                                     "level0 -1 -0.9 -0.5 0\n"
 185                                     "level1 -2 -0.05 1.1 1.08282\n"
 186                                     "averaged1 -1.55 0.925 2.45 1.20001\n"
 187                                     "level0 -1 0.25 0.7 0\n"
 188                                     "level0 0.2 1.75 2.2 0\n"
 189                                     "level0 -0.3 1.75 2.25 0\n"
 190                                     "level0 -0.35 2.35 3.15 0\n"
 191                                     "level1 -1 2.05 3.8 0.492442\n"
 192                                     "averaged1 -1.36667 1.3 2.9 0.964152\n"
 193                                     "level0 -0.4 1.05 1.9 0\n"
 194                                     "level0 -0.7 1.45 1.65 0\n"
 195                                     "level0 0.35 2.15 2.2 0\n"
 196                                     "level0 0.75 0.8 0.8 0\n"
 197                                     "level1 -1.1 1.125 3.3 1.29687\n"
 198                                     "averaged1 -1.36667 1.04167 2.73333 0.957378\n"
 199                                     "level0 0.25 0.25 0.25 0\n"
 200                                     "level0 -1 -0.9 -0.5 0\n"
 201                                     "level0 -1 0.25 0.7 0\n"
 202                                     "level0 0.2 1.75 2.2 0\n"
 203                                     "level1 -2 0.425 2.4 1.52049\n"
 204                                     "averaged1 -1.36667 1.2 3.16667 1.10327\n"
 205                                     "level0 -0.3 1.75 2.25 0\n"
 206                                     "level0 -0.35 2.35 3.15 0\n"
 207                                     "level0 -0.4 1.05 1.9 0\n"
 208                                     "level0 -0.7 1.45 1.65 0\n"
 209                                     "level1 -1.1 1.9 3.8 1.31719\n"
 210                                     "averaged1 -1.4 1.15 3.16667 1.37818\n"
 211                                     "level3 -2 1.225 3.8 1.45752\n"
 212                                     "level0 0.35 2.15 2.2 0\n"
 213                                     "level0 0.75 0.8 0.8 0\n"
 214                                     "level0 0.25 0.25 0.25 0\n"
 215                                     "level0 -1 -0.9 -0.5 0\n"
 216                                     "level1 -2 -0.05 1.1 1.08282\n"
 217                                     "averaged1 -1.7 0.758333 2.43333 1.30683\n"
 218                                     "level0 -1 0.25 0.7 0\n"
 219                                     "level0 0.2 1.75 3.2 0\n"),
 220                         0.001f );
 221 }
 222
 223 ///////////////////////////////cc.e////////////////////////////////////////
 224 #undef prefix_
 225
 226 \f
 227 // Local Variables:
 228 // mode: c++
 229 // fill-column: 100
 230 // comment-column: 40
 231 // c-file-style: "senf"
 232 // indent-tabs-mode: nil
 233 // ispell-local-dictionary: "american"
 234 // compile-command: "scons -u test"
 235 // End: