digxel-configurations-test.cpp

Go to the documentation of this file.

/*
  DigxelConfigurations(Test)  -  verify predefined standard Digxel configurations

  Copyright (C)         Lumiera.org
    2011,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

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

#include "lib/test/run.hpp"
#include "lib/test/test-helper.hpp"
#include "lib/time/digxel.hpp"
#include "lib/format-cout.hpp"
#include "lib/error.hpp"
#include "lib/util.hpp"

#include <cstdlib>

using LERR_(ASSERTION);
using util::isSameObject;
using util::typeStr;
using std::rand;


namespace lib {
namespace time{
namespace test{
  
  
  
  
  
  
  /*******************************************************************/
  class DigxelConfigurations_test : public Test
    {
      virtual void
      run (Arg) 
        {
          verifyConfiguration<Digxel<int>   > (123);
          verifyConfiguration<Digxel<double>> (123.4567);
          verifyConfiguration<SexaDigit     > (42);
          verifyConfiguration<SexaDigit     > (-5);
          verifyConfiguration<HexaDigit     > (0xc);
          verifyConfiguration<HexaDigit     > (0x6f);
          verifyConfiguration<CountVal      > (-1234567890);
          
          verifySignum();
        }
      
      
      void
      verifySignum()
        {
          Signum sig;
          CHECK (1 == sig);
          
          sig = 123;
          CHECK (1 == sig);
          sig = -sig;
          CHECK (-1 == sig);
          sig += 98;
          CHECK (+1 == sig);
          CHECK (sig.show() == string(" "));
          sig *= -1;
          CHECK (sig.show() == string("-"));
        }
      
      
      template<class DIX, typename VAL>
      void
      verifyConfiguration (VAL testval)
        {
          DIX digxel;
          CHECK (0 == digxel);
          cout << typeStr(digxel) << "--empty--"<<digxel;
          
          digxel = testval;
          cout << "--(val="<<testval<<")--"<<digxel;
          
          // verify buffer overrun protection
          digxel = 123456789.12345;
          string formatted;
#if false 
          VERIFY_ERROR (ASSERTION, formatted = digxel.show() ); // should trigger assertion
          formatted = digxel.show();                           //  second time doesn't reformat
          CHECK (formatted.length() == digxel.maxlen());
          cout << "--(clipped)--"<< digxel;
#endif    
          
          cout <<"|"<< endl;
        }
    };
  
  
  LAUNCHER (DigxelConfigurations_test, "unit common");
  
  
  
}}} // namespace lib::time::test