iter-core-adapter-test.cpp

Go to the documentation of this file.

/*
  IterCoreAdapter(Test)  -  iterating over a »state core«

   Copyright (C)
     2024,            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/util.hpp"

#include "lib/iter-adapter.hpp"

#include <string>



namespace lib {
namespace test{
  
  using LERR_(ITER_EXHAUST);
  using util::isSameObject;
  using std::string;
  
  namespace { // Test fixture
    
    struct StepDown
      {
        uint n;
        
        StepDown(uint start =0)
          : n(start)
          { }
        
        bool
        checkPoint ()  const
          {
            return n != 0;
          }
        
        uint&
        yield ()  const
          {
            return util::unConst(n);
          }
        
        void
        iterNext ()
          {
            --n;
          }
        
        bool
        operator== (StepDown const& o)  const
          {
            return n == o.n;
          }
      };
  }// (END) test dummy
  
  
  
  
  
  
  
  /*****************************************************************/
  class IterCoreAdapter_test : public Test
    {
      virtual void
      run (Arg)
        {
          simpleUsage();
          stateManipulation();
          checked_and_protected();
          value_and_reference_yield();
          verify_TypeReconciliation();
        }
      
      
      
      
      void
      simpleUsage()
        {
          auto it = IterableDecorator<StepDown>{3};
          CHECK (it);
          CHECK (*it == 3);
          ++it;
          CHECK (it);
          CHECK (*it == 2);
          ++it;
          CHECK (it);
          CHECK (*it == 1);
          ++it;
          CHECK (not it);
        }
      
      
      void
      stateManipulation()
        {
          auto it = IterableDecorator<StepDown>{};
          CHECK (not it);
          CHECK (*it == 0);
          ++it;
          CHECK (*it == uint(-1));
          CHECK (it);
          *it = 5;
          CHECK (*it == 5);
          ++it;
          CHECK (*it == 4);
          it.n = 1;
          CHECK (*it == 1);
          CHECK (it);
          ++it;
          CHECK (not it);
          CHECK (it.n == 0);
          CHECK (isSameObject(*it, it.n));
        }
      
      
      void
      checked_and_protected()
        {
          auto cc = CheckedCore<StepDown>{2};
          CHECK (cc.checkPoint());
          CHECK (cc.yield() == 2u);
          cc.n = 1;
          CHECK (cc.yield() == 1u);
          cc.iterNext();
          CHECK (not cc.checkPoint());
          CHECK (cc.n == 0u);
          VERIFY_ERROR (ITER_EXHAUST, cc.yield() );
          VERIFY_ERROR (ITER_EXHAUST, cc.iterNext() );
          
          auto it = IterStateWrapper{StepDown{2}};
          CHECK (it);
          CHECK (*it == 2u);
          ++it;
          CHECK (*it == 1u);
          ++it;
          CHECK (not it);
          VERIFY_ERROR (ITER_EXHAUST, *it  );
          VERIFY_ERROR (ITER_EXHAUST, ++it );
        }
      
      
      
      void
      value_and_reference_yield ()
        {
          struct ValueStep
            : StepDown
            {
              using StepDown::StepDown;
              int yield()  const { return StepDown::yield(); }
            };
          
          auto it = IterableDecorator<CheckedCore<ValueStep>>{2};
          CHECK (it);
          CHECK (*it == 2);
          CHECK (it.n == 2);
          CHECK (not isSameObject(*it, it.n));
          CHECK (showType<decltype(*it)>() == "int"_expect);
          
          StepDown& ix{it};
          CHECK (ix.yield() == 2u);
          CHECK (    isSameObject(ix.yield(), ix.n));
          CHECK (    isSameObject(ix.yield(), it.n));
          CHECK (showType<decltype(ix.yield())>() == "uint&"_expect);
          
          ++it;
          CHECK (*it == 1);
          ++it;
          VERIFY_ERROR (ITER_EXHAUST, *it  );
          VERIFY_ERROR (ITER_EXHAUST, ++it );
        }
      
      
      void
      verify_TypeReconciliation()
        {
          using C1 = Common<int,string>;
          CHECK (not C1());
          CHECK (not C1::value);
          
          using C2 = Common<int,long*>;
          CHECK (not C2());                                              // can not be reconciled
          CHECK (not C2::value);
//        using X = C2::ResType;                                         // does not (and should not) compile
          
          using C3 = Common<string,string>;
          CHECK (C3());
          CHECK (showType<C3::ResType>() == "string"_expect );
          
          using C4 = Common<string&,string>;
          CHECK (showType<C4::ResType>() == "string"_expect );
          
          using C5 = Common<string&,string&>;
          CHECK (showType<C5::ResType>() == "string&"_expect );          // ref access to both is possible
          
          using C6 = Common<string&,string&&>;
          CHECK (showType<C6::ResType>() == "string"_expect );           // caution, RValue might be a temporary
          
          using C7 = Common<string&&,string&&>;
          CHECK (showType<C7::ResType>() == "string"_expect );
          
          using C8 = Common<string const&, string const&>;
          CHECK (showType<C8::ResType>() == "string const&"_expect );
          
          using C9 = Common<string const&, string&>;
          CHECK (showType<C9::ResType>() == "string const&"_expect );    // reconcile to const&
          
          using C10 = Common<string const&, string>;
          CHECK (showType<C10::ResType>() == "const string"_expect );
          
          using C11 = Common<string&&, string const&>;
          CHECK (showType<C11::ResType>() == "const string"_expect );    // reconciled to value type
          
          using C12 = Common<long const&, int>;
          CHECK (showType<C12::ResType>() == "const long"_expect );      // reconciled to the larger number type
          
          using C13 = Common<double&, long const&>;
          CHECK (showType<C13::ResType>() == "double const&"_expect );   // usual in C++ (loss of precision possible)
        }
      
      template<typename T1, typename T2>
      using Common = meta::CommonResultYield<T1,T2>;
    };
  
  LAUNCHER (IterCoreAdapter_test, "unit common");
  
  
}} // namespace lib::test