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
            }
        }