diagnostic-context-test.cpp

Go to the documentation of this file.

/*
  DiagnosticContext(Test)  -  verify thread local stack for collecting diagnostics
 
   Copyright (C)
     2011,            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/test/test-helper.hpp"
 
#include "lib/diagnostic-context.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/thread.hpp"
 
#include <vector>
#include <chrono>
#include <array>
 
using std::this_thread::sleep_for;
using std::chrono_literals::operator ""us;
 
 
 
 
namespace lib {
namespace test{
  
  namespace error = lumiera::error;
  
  namespace { // private test setup...
    
                             /* WARNING: memory hungry */
    const uint NUM_THREADS = 75;
    const uint MAX_RAND    = 100*1000;
    
    auto isOdd = [](auto val) { return bool (val % 2); };
    
  } // (End) test setup....
  
  using lib::ThreadJoinable;
  using LERR_(LOGIC);
  using std::rand;
  
  
  typedef DiagnosticContext<uint> Marker;
  
  typedef std::vector<uint> VecI;
  
  
  
  
  
  /******************************************************************************/
  class DiagnosticContext_test : public Test
    {
      
      virtual void
      run (Arg)
        {
          verify_simpleAccess();
          verify_heavilyParallelUsage();
        }
      
      
      
      void
      verify_simpleAccess()
        {
          VERIFY_ERROR (LOGIC, Marker::access());
          
          VecI loggedValues;
          
          Marker zero(0);
          CHECK (0 == zero);
          CHECK (0 == Marker::access());
          
          { // nested scope
            CHECK (0 == Marker::access());
            
            Marker one(1);
            CHECK (1 == Marker::access());
            CHECK (1 == one);
            CHECK (0 == zero);
            
            { // nested scope
              CHECK (1 == Marker::access());
              
              Marker two(2);
              CHECK (2 == Marker::access());
              CHECK (2 == two);
              CHECK (1 == one);
              CHECK (0 == zero);
              
              loggedValues = Marker::extractStack();
            }
            CHECK (1 == Marker::access());
          }
          CHECK (0 == Marker::access());
          
          CHECK (3 == loggedValues.size());
          CHECK (2 == loggedValues[0]);
          CHECK (1 == loggedValues[1]);
          CHECK (0 == loggedValues[2]);
        }
      
      
      
      
      void
      verify_heavilyParallelUsage()
        {
          seedRand();
          auto verifyResult = [](VecI sequence)
                               {
                                  uint prev = 0;
                                  for (uint val : sequence)
                                    {
                                      CHECK (isOdd(val) and val > prev);
                                      prev = val;
                                    }
                               };
          
          std::array<TestThread, NUM_THREADS> testcases;
          
          auto results = lib::explore(testcases)
                             .transform([](TestThread& t){ return t.join(); })
                             .effuse();
          
          for (auto& res : results)
            verifyResult (res);
        }
      
      
      struct TestThread
        : ThreadJoinable<VecI>
        {
          TestThread()
            : ThreadJoinable{"test context stack"
                            ,[seed = 1+rani(MAX_RAND)]
                             { return descend (seed); }}
            { }
        };
      
      static VecI
      descend (uint current)
        {
          if (current < 2)
            return Marker::extractStack();
          
          sleep_for (500us);
          
          if (isOdd (current))
            {
              Marker remember(current);
              return descend (current+1);
            }
          else
            return descend (current/2);
        }
    };
  
  
  
  LAUNCHER (DiagnosticContext_test, "function common");
  
  
  
}} // namespace vault::test