typed-counter-test.cpp

Go to the documentation of this file.

/*
  TypedCounter(Test)  -  managing a set of type based contexts

   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

* *****************************************************************/


#include "lib/test/run.hpp"
#include "lib/typed-counter.hpp"
#include "lib/test/microbenchmark.hpp"
#include "lib/random.hpp"
#include "lib/util.hpp"

#include <cstdlib>
#include <utility>
#include <array>


namespace lib {
namespace test{
  
  using util::isnil;
  using lib::rani;
  
  
  namespace { // test parametrisation...
    const uint MAX_INDEX      =    10;  
    const uint NUM_THREADS    =   100;  
    const uint NUM_ITERATIONS = 10000;  
  }
  
  
  
  /***********************************************************************************/
  class TypedCounter_test : public Test
    {
      
      void
      run (Arg)
        {
          simpleUsageTest();
          tortureTest();
        }
      
      
      void
      simpleUsageTest()
        {
          TypedCounter myCounter;
          CHECK (isnil (myCounter));
          CHECK (0==myCounter.size());
          
          CHECK (0 == myCounter.get<short>());
          CHECK (0 <  myCounter.size());
          // probably greater than 1;
          // other parts of the application allocate type-IDs as well
          
          // now allocate a counter for a type not seen yet
          struct X { };
          struct U { };
          
          CHECK (0 == myCounter.get<X>());
          size_t sX = myCounter.size();
          
          CHECK (0 == myCounter.get<U>());
          CHECK (sX + 1 == myCounter.size());
          CHECK (0 == myCounter.get<X>());
          CHECK (sX + 1 == myCounter.size());
          
          CHECK (-1 == myCounter.dec<X>());
          CHECK (-2 == myCounter.dec<X>());
          CHECK (+1 == myCounter.inc<U>());
          
          CHECK (-2 == myCounter.get<X>());
          CHECK (+1 == myCounter.get<U>());
          
          // each new type has gotten a new "slot" (i.e. a distinct type-ID)
          IxID typeID_short = TypedContext<TypedCounter>::ID<short>::get();
          IxID typeID_X     = TypedContext<TypedCounter>::ID<X>::get();
          IxID typeID_U     = TypedContext<TypedCounter>::ID<U>::get();
          
          CHECK (0 < typeID_short);
          CHECK (0 < typeID_X);
          CHECK (0 < typeID_U);
          CHECK (typeID_short < typeID_X);
          CHECK (typeID_X < typeID_U);
          // type-IDs are allocated in the order of first usage
          
          CHECK (sX + 1 == myCounter.size());
        }
      
      
      
      template<size_t i>
      struct Dummy { };
      
      template<size_t i>
      static void
      increment (TypedCounter& counter)
      {
        counter.inc<Dummy<i>>();
      }

      template<size_t...I>
      static auto
      buildOperatorsTable(std::index_sequence<I...>)
      {
        using Operator = void(*)(TypedCounter&);
        return std::array<Operator, MAX_INDEX>{increment<I>...};
      }
      
      template<size_t...I>
      static size_t
      sumAllCounters(TypedCounter& counter, std::index_sequence<I...>)
      {
        return (counter.get<Dummy<I>>() + ... );
      }
      
      
      
      void
      tortureTest()
        {
          seedRand();
          
          using IDX = std::make_index_sequence<MAX_INDEX>;
          auto operators = buildOperatorsTable(IDX{});
          
          TypedCounter testCounter;
          
          auto testSubject = [&
                             ,gen = makeRandGen()]
                             (size_t) mutable -> size_t
                                {
                                  uint i = gen.i(MAX_INDEX);
                                  operators[i](testCounter);
                                  return 1;
                                };
          
          threadBenchmark<NUM_THREADS> (testSubject, NUM_ITERATIONS);
          
          size_t expectedIncrements = NUM_THREADS * NUM_ITERATIONS;
          CHECK (sumAllCounters(testCounter, IDX{}) == expectedIncrements);
        }
    };
  
  
  LAUNCHER (TypedCounter_test, "unit common");
  
  
}} // namespace lib::test