public void Basics()
{
UT_INIT();
Log.SetVerbosity( new ConsoleLogger(), Verbosity.Verbose, "/" );
Log.MapThreadName( "UnitTest" );
Log.SetDomain( "TickWatch", Scope.Method );
Log.Info( "\n### TicksBasics ###" );
// check times
{
Ticks t= new Ticks();
t.FromNanos( 42 ); // beyond resolution in C#: UT_EQ( t.InNanos(), 42L);
UT_EQ( t.InMicros(), 0L );
UT_EQ( t.InMillis(), 0L );
UT_EQ( t.InSeconds(), 0L );
t.FromMicros( 42 ); UT_EQ( t.InNanos(), 42000L );
UT_EQ( t.InMicros(), 42L );
UT_EQ( t.InMillis(), 0L );
UT_EQ( t.InSeconds(), 0L );
t.FromMillis( 42 ); UT_EQ( t.InNanos(), 42000000L );
UT_EQ( t.InMicros(), 42000L );
UT_EQ( t.InMillis(), 42L );
UT_EQ( t.InSeconds(), 0L );
t.FromSeconds( 42 ); UT_EQ( t.InNanos(), 42000000000L );
UT_EQ( t.InMicros(), 42000000L );
UT_EQ( t.InMillis(), 42000L );
UT_EQ( t.InSeconds(), 42L );
Ticks diff= new Ticks();
diff.FromMillis( 100 );
t.Add( diff ); UT_EQ( t.InNanos(), 42100000000L );
UT_EQ( t.InMicros(), 42100000L );
UT_EQ( t.InMillis(), 42100L );
UT_EQ( t.InSeconds(), 42L );
t.Sub( diff ); UT_EQ( t.InNanos(), 42000000000L );
UT_EQ( t.InMicros(), 42000000L );
UT_EQ( t.InMillis(), 42000L );
UT_EQ( t.InSeconds(), 42L );
t.FromMillis( 100 ); UT_EQ( t.InHertz() , 10.0 );
t.FromMillis( 300 ); UT_EQ( t.InHertz(0) , 3.0 );
UT_EQ( t.InHertz(1) , 3.3 );
UT_EQ( t.InHertz(2) , 3.33 );
UT_EQ( t.InHertz(5) , 3.33333 );
}
// check internal frequency
{
double freq= Ticks.InternalFrequency;
Log.Info( "TickWatch InternalFrequency: " + freq );
UT_TRUE ( freq >= 1000000.0 );
}
// check TickWatch creation time
{
Ticks creationTimeDiff= new Ticks();
creationTimeDiff.Sub( Ticks.CreationTime );
Log.Info( "TickWatch library creation was: " + creationTimeDiff.InNanos () + "ns ago" );
Log.Info( "TickWatch library creation was: " + creationTimeDiff.InMicros () + "µs ago" );
Log.Info( "TickWatch library creation was: " + creationTimeDiff.InMillis () + "ms ago" );
Log.Info( "TickWatch library creation was: " + creationTimeDiff.InSeconds() + "s ago" );
UT_TRUE ( creationTimeDiff.InNanos () > 100 ); // It should really take 100 nanoseconds to get here!
UT_TRUE ( creationTimeDiff.InSeconds() < 3600 ); // these test will probably not last an hour
}
// check if we could sleep for 100ms
{
Ticks start= new Ticks();
ALIB.SleepMillis( 30 );
Ticks sleepTime= new Ticks();
sleepTime.Sub( start );
Log.Info( "TickWatch diff after 100ms sleep: " + sleepTime.InMillis() +" ms" );
UT_TRUE ( sleepTime.InMillis() > 28 );
UT_TRUE ( sleepTime.InMillis() < 150 ); // should work even on heavily loaded machines
}
}
public void Ages()
{
UT_INIT();
Log.SetVerbosity( new ConsoleLogger(), Verbosity.Verbose, "/" );
Log.MapThreadName( "UnitTest" );
Log.SetDomain( "TickWatch", Scope.Method );
TickWatch tt=new TickWatch();
// minimum time measuring
{
tt.Start();
tt.Sample();
tt.Reset(); // we need to do this once before, otherwise C# might be
// very slow. Obviously the optimizer...
tt.Start();
tt.Sample();
long ttAverageInNanos=tt.GetAverage().InNanos();
long ttAverageInMicros=tt.GetAverage().InMicros();
long ttAverageInMillis=tt.GetAverage().InMillis();
Log.Info( "TickWatch minimum measurement nanos: " + ttAverageInNanos );
Log.Info( "TickWatch minimum measurement micros: " + ttAverageInMicros );
Log.Info( "TickWatch minimum measurement millis: " + ttAverageInMillis );
UT_TRUE( ttAverageInNanos < 5000 );
UT_TRUE( ttAverageInMicros <= 5 );
UT_TRUE( ttAverageInMillis == 0 );
}
// minimum sleep time measuring
{
tt.Reset();
for (int i= 0 ; i< 100 ; i++)
{
ALIB.SleepNanos( 1 );
tt.Sample();
}
Ticks avg= tt.GetAverage();
Log.Info( "100 probes of 1 ns of sleep leads to average sleep time of " + avg.InNanos() + " ns");
}
// sleep two times 20 ms and probe it to an average
{
tt.Reset();
tt.Start();
ALIB.SleepMillis( 20 );
tt.Sample();
ALIB.SleepMillis( 80 );
tt.Start();
ALIB.SleepMillis( 20 );
tt.Sample();
long cnt=tt.GetSampleCnt();
long avg=tt.GetAverage().InMillis();
double hertz=tt.GetAverage().InHertz( 1 );
Log.Info( "TickWatch sum is " + tt.GetCumulated().InMillis() + " after " + cnt + " times 20 ms sleep" );
Log.Info( " average is: " + avg + " ms" );
Log.Info( " in Hertz: " + hertz );
UT_TRUE( hertz < 53 );
UT_TRUE( hertz > 30 ); // should work even on heavily loaded machines
UT_EQ( 2, cnt );
UT_TRUE( avg >= 18 );
UT_TRUE( avg < 45 ); // should work even on heavily loaded machines
}
// Ticks Since
{
Ticks tt1= new Ticks(); tt1.FromSeconds( 1000 );
Ticks tt2= new Ticks(); tt2.FromSeconds( 1001 );
UT_TRUE ( tt2.Since( tt1 ).InMillis() == 1000L );
UT_TRUE ( tt2.Since( tt1 ).InMicros() == 1000L * 1000L );
UT_TRUE ( tt2.Since( tt1 ).InNanos () == 1000L * 1000L * 1000L );
}
}