lumiera_/tests/basics/time/digxel-configurations-test.cpp
Ichthyostega a90b9e5f16 Library: uniform definition scheme for error-IDs
In the Lumiera code base, we use C-String constants as unique error-IDs.
Basically this allows to create new unique error IDs anywhere in the code.

However, definition of such IDs in arbitrary namespaces tends to create
slight confusion and ambiguities, while maintaining the proper use statements
requires some manual work.

Thus I introduce a new **standard scheme**
 * Error-IDs for widespread use shall be defined _exclusively_ into `namespace lumiera::error`
 * The shorthand-Macro `LERR_()` can now be used to simplify inclusion and referral
 * (for local or single-usage errors, a local or even hidden definition is OK)
2024-03-21 19:57:34 +01:00

128 lines
3.8 KiB
C++

/*
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.
* *****************************************************/
/** @file digxel-configurations-test.cpp
** unit test \ref DigxelConfigurations_test
*/
#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{
/*******************************************************************//**
* @test verify correctness of the predefined standard Digxels.
* Some widely used standard configurations, including
* - default Digxel for int and double values
* - sexagesimal Digxel
* - hex byte Digxel
* - ...more to come
* @todo cover any newly added Digxel configurations.
* @see Digxel_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 ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
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 ///////////////////////////////////////////////////////////////////////////////////////////////TICKET #537 : restore throwing ASSERT
cout <<"|"<< endl;
}
};
/** Register this test class... */
LAUNCHER (DigxelConfigurations_test, "unit common");
}}} // namespace lib::time::test