LUMIERA.clone/tests/core/steam/engine/diagnostic-buffer-provider-test.cpp

/*
  DiagnosticBufferProvider(Test)  -  verify a support facility for diagnostic/test purposes

   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.

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

/** @file tracking-heap-block-provider-test.cpp
 ** unit test \ref DiagnosticBufferProvider_test
 */


#include "lib/error.hpp"
#include "lib/test/run.hpp"
#include "steam/engine/diagnostic-buffer-provider.hpp"
#include "steam/engine/buffhandle-attach.hpp"     ///////////////////////////////////////////////////////////TICKET 1410 : remove unnecessary API
#include "steam/engine/testframe.hpp"
#include "lib/test/diagnostic-output.hpp"//////////////////TODO

#include <vector>


namespace steam  {
namespace engine{
namespace test  {
  
  
  
  namespace { // Test fixture
    
    const size_t TEST_ELM_SIZE = sizeof(uint);
    const uint   MAX_ELMS = 50;
    
    std::vector<uint> testNumbers(MAX_ELMS);
    
    
    bool 
    has_expectedContent (uint nr, diagn::Block& memoryBlock)
    {
#if false  //////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : disabled code to disentangle BufferProvider implementation
      void* mem = memoryBlock.accessMemory();
      uint data = *static_cast<uint*> (mem);
      
      return data == testNumbers[nr];
#endif  /////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : (end) disabled code
    }
    
    bool
    verifyUsedBlock (uint nr, diagn::Block& memoryBlock)
    {
#if false  //////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : disabled code to disentangle BufferProvider implementation
      return memoryBlock.was_used()
         and memoryBlock.was_closed()
         and has_expectedContent (nr, memoryBlock);
#endif  /////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1410 : (end) disabled code
    }
  }
  
  
  /******************************************************************//**
   * @test verify support to write mock components for buffer management.
   *     - HeapMemBufferStore is a „braindead“ implementation of the BufferProvider
   *       interface: it just claims new heap blocks and never de-allocates them.
   *     - adding a layer of instrumentation, the DiagnosticBufferProvider allows
   *       to count and verify allocated buffers and their content after the fact.
   */
  class DiagnosticBufferProvider_test : public Test
    {
      virtual void
      run (Arg)
        {
          seedRand();
          
          simpleExample();
          verifyStandardCase();
          verifyTestProtocol();
        }
      
      
      void
      simpleExample()
        {
          DiagnosticBufferProvider provider;
          
          BuffHandle testBuff = provider.lockBufferFor<TestFrame>();
          CHECK (testBuff);
          CHECK (testBuff.accessAs<TestFrame>().isSane());
          
          uint dataID = 1 + rani(29);
          testBuff.accessAs<TestFrame>() = testData(dataID);
          
          provider.emitBuffer   (testBuff);
          provider.releaseBuffer(testBuff);
          
SHOW_EXPR(watch(provider).created.cnt())
SHOW_EXPR(watch(provider).emitted.cnt())
SHOW_EXPR(watch(provider).released.cnt())
          CHECK (1 == watch(provider).created.cnt());
          CHECK (1 == watch(provider).emitted.cnt());
          CHECK (1 == watch(provider).released.cnt());
          diagn::Block block0 = watch(provider).emitted[0];
          CHECK (testData(dataID) == block0.accessMemory());
        }
      
      
      void
      verifyStandardCase()
        {
          DiagnosticBufferProvider provider;
          
          BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE);
          uint numElms = provider.announce(MAX_ELMS, buffType);
          CHECK (0 < numElms);
          CHECK (numElms <= MAX_ELMS);
          
          for (uint i=0; i<numElms; ++i)
            {
              BuffHandle buff = provider.lockBuffer(buffType);
              buff.accessAs<uint>() = testNumbers[i] = rani(100000);
              provider.emitBuffer   (buff);
              provider.releaseBuffer(buff);
            }
          
          for (uint nr=0; nr<numElms; ++nr)
            {
//            CHECK (verifyUsedBlock (nr, provider.access_emitted(nr)));      ///////////////////////////////OOO provide suitable diagnostic API!
            }
        }
      
      
      void
      verifyTestProtocol()
        {
          DiagnosticBufferProvider provider;
          
          BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE);
          
          BuffHandle bu1 = provider.lockBuffer (buffType);
          BuffHandle bu2 = provider.lockBuffer (buffType);
          BuffHandle bu3 = provider.lockBuffer (buffType);
          BuffHandle bu4 = provider.lockBuffer (buffType);
          BuffHandle bu5 = provider.lockBuffer (buffType);
          
          // buffers are locked, 
          // but still within the per-type allocation pool
          // while the output sequence is still empty
//        CHECK (!provider.access_emitted(0).was_used());      ///////////////////////////////OOO provide suitable diagnostic API!
//        CHECK (!provider.access_emitted(1).was_used());
//        CHECK (!provider.access_emitted(2).was_used());
//        CHECK (!provider.access_emitted(3).was_used());
//        CHECK (!provider.access_emitted(4).was_used());
          
          // can use the buffers for real
          bu1.accessAs<uint>() = 1;
          bu2.accessAs<uint>() = 2;
          bu3.accessAs<uint>() = 3;
          bu4.accessAs<uint>() = 4;
          bu5.accessAs<uint>() = 5;
          
//        CHECK (0 == provider.emittedCnt());      ///////////////////////////////OOO provide suitable diagnostic API!
          
          // now emit buffers in shuffled order
          provider.emitBuffer (bu3);
          provider.emitBuffer (bu1);
          provider.emitBuffer (bu5);
          provider.emitBuffer (bu4);
          provider.emitBuffer (bu2);
          
//        CHECK (5 == provider.emittedCnt());      ///////////////////////////////OOO provide suitable diagnostic API!
          
//        CHECK (3 == provider.accessAs<uint>(0));      ///////////////////////////////OOO provide suitable diagnostic API!
//        CHECK (1 == provider.accessAs<uint>(1));
//        CHECK (5 == provider.accessAs<uint>(2));
//        CHECK (4 == provider.accessAs<uint>(3));
//        CHECK (2 == provider.accessAs<uint>(4));
          
//        CHECK ( provider.access_emitted(0).was_used());      ///////////////////////////////OOO provide suitable diagnostic API!
//        CHECK ( provider.access_emitted(1).was_used());
//        CHECK ( provider.access_emitted(2).was_used());
//        CHECK ( provider.access_emitted(3).was_used());
//        CHECK ( provider.access_emitted(4).was_used());
          
//        CHECK (!provider.access_emitted(0).was_closed());
//        CHECK (!provider.access_emitted(1).was_closed());
//        CHECK (!provider.access_emitted(2).was_closed());
//        CHECK (!provider.access_emitted(3).was_closed());
//        CHECK (!provider.access_emitted(4).was_closed());
          
          bu5.release();
//        CHECK (!provider.access_emitted(0).was_closed());
//        CHECK (!provider.access_emitted(1).was_closed());
//        CHECK ( provider.access_emitted(2).was_closed());
//        CHECK (!provider.access_emitted(3).was_closed());
//        CHECK (!provider.access_emitted(4).was_closed());
          
          bu2.release();
          bu2.release();
          bu5.release();
//        CHECK (!provider.access_emitted(0).was_closed());
//        CHECK (!provider.access_emitted(1).was_closed());
//        CHECK ( provider.access_emitted(2).was_closed());
//        CHECK (!provider.access_emitted(3).was_closed());
//        CHECK ( provider.access_emitted(4).was_closed());
          
          CHECK (!bu2);
          CHECK (bu3);
          
          bu1.release();
          bu3.release();
          bu4.release();
          
//        CHECK (5 == provider.emittedCnt());      ///////////////////////////////OOO provide suitable diagnostic API!
        }
    };
  
  
  /** Register this test class... */
  LAUNCHER (DiagnosticBufferProvider_test, "unit player");
  
  
  
}}} // namespace steam::engine::test