ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

dry-run: switch the lumitime-test.cpp to use the new Time framework

Browse source
This commit is contained in:
Fischlurch 2011-05-15 22:10:26 +02:00
parent 99bf3c6d81
commit ee5c9910e1
2 changed files with 158 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

96
src/lib/time/diagnostics.hpp Normal file
View file

@ -0,0 +1,96 @@
/*
DIAGNOSTICS.hpp - diagnostics and output helpers for time(code) values
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 diagnostics.hpp
** Extension to the lib::time::Time wrapper, adding output and further
** diagnostic aids. This shouldn't be confused with formatting into
** distinctive \em Timecode formats. There is an elaborate framework
** for the latter: basically you'd need first to create a frame quantised
** time value (QuTime) -- from there you can build various timecode
** representations.
**
** To the contrary, the purpose of this header is to help with debugging,
** writing unit tests and similar diagnostic activities.
**
** @see timevalue.hpp
** @see lumitime-test.cpp
**
*/
#ifndef LIB_TIME_DIAGNOSTICS_H
#define LIB_TIME_DIAGNOSTICS_H
#include "lib/time/timevalue.hpp"
#include "lib/time.h"
#include <iostream>
#include <string>
namespace lib {
namespace time {
/** writes time value, formatted as HH:MM:SS:mmm
* @see lumiera_tmpbuf_print_time */
inline std::ostream&
operator<< (std::ostream& os, TimeValue const& t)
{
return os << std::string(Time(t));
}
/* === H:M:S:mm component diagnostics === */
inline int
getHours (TimeValue const& t)
{
return lumiera_time_hours (_raw(t));
}
inline int
getMins (TimeValue const& t)
{
return lumiera_time_minutes (_raw(t));
}
inline int
getSecs (TimeValue const& t)
{
return lumiera_time_seconds (_raw(t));
}
inline int
getMillis (TimeValue t)
{
return lumiera_time_millis (_raw(t));
}
}} // lib::time
#endif

120
tests/lib/lumitime-test.cpp
View file

@ -35,30 +35,34 @@ using std::cout;
using std::endl;
#include "lib/lumitime.hpp"
#include "lib/lumitime-fmt.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/time/diagnostics.hpp"
namespace lumiera{
namespace test {
namespace lib {
namespace test{
using time::Time;
using time::TimeVar;
using time::FSecs;
/********************************************
* @test sanity of the C++ time wrapper.
* @test sanity check of basic Time handling.
*/
class LumiTime_test : public Test
{
virtual void
run (Arg arg)
{
long refval= isnil(arg)? 1 : lexical_cast<long> (arg[1]);
FSecs refval = isnil(arg)? 1 : lexical_cast<long> (arg[1]);
Time ref (refval);
Time org(refval);
checkBasics (ref);
checkComparisons (ref);
checkComponentAccess();
checkBasics (org);
checkComparisons (org);
checkComponentDiagnostics();
}
@ -66,18 +70,18 @@ namespace test {
checkBasics (Time const& ref)
{
Time zero;
Time one (1);
Time two (FSecs(2));
Time max (Time::MAX);
Time min (Time::MIN);
Time val (ref);
TimeVar var (ref);
val += Time(2);
val *= 2;
CHECK (zero == (val - 2*(ref + Time(2))) );
var += two;
var *= 2;
CHECK (zero == (var - 2*(ref + two)) );
val = ref;
CHECK (zero == (val - ref));
var = ref;
CHECK (zero == (var - ref));
}
@ -88,27 +92,27 @@ namespace test {
Time max (Time::MAX);
Time min (Time::MIN);
CHECK (zero == Time(0));
CHECK (zero == Time());
CHECK (min < zero);
CHECK (max > zero);
Time val (ref);
CHECK ( (val == ref) );
CHECK (!(val != ref) );
CHECK ( (val >= ref) );
CHECK ( (val <= ref) );
CHECK (!(val < ref) );
CHECK (!(val > ref) );
TimeVar var (ref);
CHECK ( (var == ref) );
CHECK (!(var != ref) );
CHECK ( (var >= ref) );
CHECK ( (var <= ref) );
CHECK (!(var < ref) );
CHECK (!(var > ref) );
val += Time(2);
CHECK (!(val == ref) );
CHECK ( (val != ref) );
CHECK ( (val >= ref) );
CHECK (!(val <= ref) );
CHECK (!(val < ref) );
CHECK ( (val > ref) );
var += Time(FSecs(2));
CHECK (!(var == ref) );
CHECK ( (var != ref) );
CHECK ( (var >= ref) );
CHECK (!(var <= ref) );
CHECK (!(var < ref) );
CHECK ( (var > ref) );
gavl_time_t gat(val);
gavl_time_t gat(var);
CHECK (!(gat == ref) );
CHECK ( (gat != ref) );
CHECK ( (gat >= ref) );
@ -116,17 +120,17 @@ namespace test {
CHECK (!(gat < ref) );
CHECK ( (gat > ref) );
CHECK ( (val == gat) );
CHECK (!(val != gat) );
CHECK ( (val >= gat) );
CHECK ( (val <= gat) );
CHECK (!(val < gat) );
CHECK (!(val > gat) );
CHECK ( (var == gat) );
CHECK (!(var != gat) );
CHECK ( (var >= gat) );
CHECK ( (var <= gat) );
CHECK (!(var < gat) );
CHECK (!(var > gat) );
}
void
checkComponentAccess()
checkComponentDiagnostics()
{
int millis = rand() % 1000;
int secs = rand() % 60;
@ -134,34 +138,34 @@ namespace test {
int hours = rand() % 100;
Time time(millis,secs,mins,hours);
CHECK (millis == time.getMillis());
CHECK (secs == time.getSecs());
CHECK (mins == time.getMins());
CHECK (hours == time.getHours());
CHECK (Time() < time);
CHECK (millis == getMillis(time));
CHECK (secs == getSecs (time));
CHECK (mins == getMins (time));
CHECK (hours == getHours (time));
cout << time << endl;
Time t2(2008,0);
cout << t2 << endl;
CHECK ( 8 == t2.getMillis());
CHECK ( 2 == t2.getSecs());
CHECK ( 0 == t2.getMins());
CHECK ( 0 == t2.getHours());
CHECK ( 8 == getMillis(t2));
CHECK ( 2 == getSecs (t2));
CHECK ( 0 == getMins (t2));
CHECK ( 0 == getHours (t2));
Time t3(2008,88);
cout << t3 << endl;
CHECK ( 8 == t3.getMillis());
CHECK (30 == t3.getSecs());
CHECK ( 1 == t3.getMins());
CHECK ( 0 == t3.getHours());
CHECK ( 8 == getMillis(t3));
CHECK (30 == getSecs (t3));
CHECK ( 1 == getMins (t3));
CHECK ( 0 == getHours (t3));
Time t4(2008,118,58);
cout << t4 << endl;
CHECK ( 8 == t4.getMillis());
CHECK ( 0 == t4.getSecs());
CHECK ( 0 == t4.getMins());
CHECK ( 1 == t4.getHours());
CHECK ( 8 == getMillis(t4));
CHECK ( 0 == getSecs (t4));
CHECK ( 0 == getMins (t4));
CHECK ( 1 == getHours (t4));
}
};
@ -170,4 +174,4 @@ namespace test {
}} // namespace lumiera::test
}} // namespace lib::test