rtems/testsuites/validation/tc-timecounter-install.c

/* SPDX-License-Identifier: BSD-2-Clause */

/**
 * @file
 *
 * @ingroup ScoreTimecounterValInstall
 */

/*
 * Copyright (C) 2021 embedded brains GmbH & Co. KG
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This file is part of the RTEMS quality process and was automatically
 * generated.  If you find something that needs to be fixed or
 * worded better please post a report or patch to an RTEMS mailing list
 * or raise a bug report:
 *
 * https://www.rtems.org/bugs.html
 *
 * For information on updating and regenerating please refer to the How-To
 * section in the Software Requirements Engineering chapter of the
 * RTEMS Software Engineering manual.  The manual is provided as a part of
 * a release.  For development sources please refer to the online
 * documentation at:
 *
 * https://docs.rtems.org
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <rtems.h>
#include <rtems/timecounter.h>
#include <rtems/score/atomic.h>
#include <rtems/score/threaddispatch.h>

#include "tx-support.h"

#include <rtems/test.h>

/**
 * @defgroup ScoreTimecounterValInstall spec:/score/timecounter/val/install
 *
 * @ingroup TestsuitesValidationTimecounter0
 *
 * @brief Tests timecounter installation related functions and directives of
 *   the Clock Manager.
 *
 * This test case performs the following actions:
 *
 * - Call the simple timecounter tick service with a zero delta and offset.
 *   This will lead to an overflow to zero of the timehand generation.  It
 *   shall not change the initial clock values.
 *
 * - Call the directives to get the initial value of CLOCK_REALTIME and the
 *   initial boot time.
 *
 *   - Check the initial CLOCK_REALTIME in seconds and nanoseconds format.
 *
 *   - Check that CLOCK_REALTIME is frozen in seconds and nanoseconds format.
 *
 *   - Check the initial CLOCK_REALTIME in coarse resolution in seconds and
 *     nanoseconds format.
 *
 *   - Check that CLOCK_REALTIME is frozen in coarse resolution in seconds and
 *     nanoseconds format.
 *
 *   - Check the initial CLOCK_REALTIME in binary time format.
 *
 *   - Check that CLOCK_REALTIME is frozen in binary time format.
 *
 *   - Check the initial CLOCK_REALTIME in coarse resolution in binary time
 *     format.
 *
 *   - Check that CLOCK_REALTIME is frozen in coarse resolution in binary time
 *     format.
 *
 *   - Check the initial CLOCK_REALTIME in seconds and microseconds format.
 *
 *   - Check that CLOCK_REALTIME is frozen in seconds and microseconds format.
 *
 *   - Check the initial CLOCK_REALTIME in coarse resolution in seconds and
 *     microseconds format.
 *
 *   - Check that CLOCK_REALTIME is frozen in coarse resolution in seconds and
 *     microseconds format.
 *
 *   - Check the initial boot time in seconds and nanoseconds format.
 *
 *   - Check the initial boot time in binary time format.
 *
 *   - Check the initial boot time in seconds and microseconds format.
 *
 * - Call the directives to get the initial value of CLOCK_MONOTONIC and the
 *   initial boot time.
 *
 *   - Check the initial CLOCK_MONOTONIC in seconds and nanoseconds format.
 *
 *   - Check that CLOCK_MONOTONIC is frozen in seconds and nanoseconds format.
 *
 *   - Check the initial CLOCK_MONOTONIC in coarse resolution in seconds and
 *     nanoseconds format.
 *
 *   - Check that CLOCK_MONOTONIC is frozen in coarse resolution in seconds and
 *     nanoseconds format.
 *
 *   - Check the initial CLOCK_MONOTONIC in binary time format.
 *
 *   - Check that CLOCK_MONOTONIC is frozen in binary time format.
 *
 *   - Check the initial CLOCK_MONOTONIC in coarse resolution in binary time
 *     format.
 *
 *   - Check that CLOCK_MONOTONIC is frozen in coarse resolution in binary time
 *     format.
 *
 *   - Check the initial CLOCK_MONOTONIC in signed binary time format.
 *
 *   - Check that CLOCK_MONOTONIC is frozen in signed binary time format.
 *
 *   - Check the initial CLOCK_MONOTONIC in seconds and microseconds format.
 *
 *   - Check that CLOCK_MONOTONIC is frozen in seconds and microseconds format.
 *
 *   - Check the initial CLOCK_MONOTONIC in coarse resolution in seconds and
 *     microseconds format.
 *
 *   - Check that CLOCK_MONOTONIC is frozen in coarse resolution in seconds and
 *     microseconds format.
 *
 * - Install timecounter of different quality levels and frequencies.
 *
 *   - Install a timecounter with a high quality level and normal frequency.
 *     Check that it was installed.
 *
 *   - Install a timecounter with a high quality level and low frequency. Check
 *     that it was not installed.
 *
 *   - Install a timecounter with a high quality level and high frequency.
 *     Check that it was installed.
 *
 *   - Install a timecounter with a low quality level.  Check that it was not
 *     installed.
 *
 * - Call the directives to get the time in the highest resolution available to
 *   the system.
 *
 *   - Check that the timecounter was used by rtems_clock_get_realtime().
 *
 *   - Check that the timecounter was used by
 *     rtems_clock_get_realtime_bintime().
 *
 *   - Check that the timecounter was used by
 *     rtems_clock_get_realtime_timeval().
 *
 *   - Check that the timecounter was used by rtems_clock_get_monotonic().
 *
 *   - Check that the timecounter was used by
 *     rtems_clock_get_monotonic_bintime().
 *
 *   - Check that the timecounter was used by
 *     rtems_clock_get_monotonic_sbintime().
 *
 *   - Check that the timecounter was used by
 *     rtems_clock_get_monotonic_timeval().
 *
 * - Call the directives to get the time in a coarse resolution.
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_realtime_coarse().
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_realtime_coarse_bintime().
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_realtime_coarse_timeval().
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_monotonic_coarse().
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_monotonic_coarse_bintime().
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_monotonic_coarse_timeval().
 *
 *   - Check that the timecounter was not used by rtems_clock_get_boot_time().
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_boot_time_bintime().
 *
 *   - Check that the timecounter was not used by
 *     rtems_clock_get_boot_time_timeval().
 *
 * - Call the directives to get the time in the highest resolution available to
 *   the system.
 *
 *   - Prepare the timecounter to get a large time difference.  Check that
 *     rtems_clock_get_realtime() returns the correct time.
 *
 *   - Prepare the timecounter to get a large time difference.  Check that
 *     rtems_clock_get_realtime_bintime() returns the correct time.
 *
 *   - Prepare the timecounter to get a large time difference.  Check that
 *     rtems_clock_get_realtime_timeval() returns the correct time.
 *
 *   - Prepare the timecounter to get a large time difference.  Check that
 *     rtems_clock_get_monotonic() returns the correct time.
 *
 *   - Prepare the timecounter to get a large time difference.  Check that
 *     rtems_clock_get_monotonic_bintime() returns the correct time.
 *
 *   - Prepare the timecounter to get a large time difference.  Check that
 *     rtems_clock_get_monotonic_sbintime() returns the correct time.
 *
 *   - Prepare the timecounter to get a large time difference.  Check that
 *     rtems_clock_get_monotonic_timeval() returns the correct time.
 *
 * - Update the oldest timehand after a large time interval.
 *
 * - Call the simple timecounter tick service with non-zero delta and offset
 *   parameter values so that exactly one second passed.
 *
 *   - Check that exactly one second passed due to the simple clock tick
 *     service.
 *
 * - Install a very high quality timecounter with a low frequency to test the
 *   NTP support.
 *
 *   - Let the seconds value of CLOCK_REALTIME not change. Check that the NTP
 *     update second handler is not called.
 *
 *   - Let the seconds value of CLOCK_REALTIME change by one. Check that the
 *     NTP update second handler is called exactly once.
 *
 *   - Let the seconds value of CLOCK_REALTIME change by 200. Check that the
 *     NTP update second handler is called exactly 200 times.
 *
 *   - Let the seconds value of CLOCK_REALTIME change by 201. Check that the
 *     NTP update second handler is called exactly twice.
 *
 *   - Let the seconds value of CLOCK_REALTIME change by one. Check that the
 *     NTP update second handler is incremented the CLOCK_REALTIME by one
 *     second.
 *
 *   - Let the seconds value of CLOCK_REALTIME change by one. Check that the
 *     NTP update second handler is decremented the CLOCK_REALTIME by one
 *     second.
 *
 *   - Let the seconds value of CLOCK_REALTIME change by one. Check that the
 *     NTP update second handler increased the timecounter frequency.
 *
 *   - Let the seconds value of CLOCK_REALTIME change by one. Check that the
 *     NTP update second handler decreased the timecounter frequency.
 *
 * @{
 */

typedef struct {
  struct timecounter base;
  Atomic_Ulong counter;
} Timecounter;

static Timecounter high_quality_low_frequency;

static Timecounter high_quality_normal_frequency;

static Timecounter high_quality_high_frequency;

static Timecounter low_quality;

static Timecounter very_high_quality;

static uint32_t ntp_counter;

static uint32_t GetTimecount( struct timecounter *base )
{
  Timecounter *tc;

  tc = (Timecounter *) base;

  return (uint32_t) _Atomic_Fetch_add_ulong(
    &tc->counter,
    1,
    ATOMIC_ORDER_RELAXED
  );
}

static uint32_t GetCounter( const Timecounter *tc )
{
  return (uint32_t) _Atomic_Load_ulong(
    &tc->counter,
    ATOMIC_ORDER_RELAXED
  );
}

static void SetCounter( Timecounter *tc, uint32_t counter )
{
  _Atomic_Store_ulong(
    &tc->counter,
    counter,
    ATOMIC_ORDER_RELAXED
  );
}

static void NtpUpdateCounter( int64_t *adjustment, time_t *newsec )
{
  (void) newsec;
  T_eq_i64( *adjustment, 0 );
  ++ntp_counter;
}

static void NtpUpdateSecondIncrement( int64_t *adjustment, time_t *newsec )
{
  (void) adjustment;
  ++(*newsec);
}

static void NtpUpdateSecondDecrement( int64_t *adjustment, time_t *newsec )
{
  (void) adjustment;
  --(*newsec);
}

static void NtpUpdateAdjustmentFaster( int64_t *adjustment, time_t *newsec )
{
  *adjustment = ( (int64_t) 5000 ) << 32;
  (void) newsec;
}

static void NtpUpdateAdjustmentSlower( int64_t *adjustment, time_t *newsec )
{
  *adjustment = -( (int64_t) 5000 ) << 32;
  (void) newsec;
}

static void CallTimecounterTick( void )
{
  Per_CPU_Control *cpu_self;

  cpu_self = _Thread_Dispatch_disable();
  rtems_timecounter_tick();
  _Thread_Dispatch_enable( cpu_self );
}

/**
 * @brief Call the simple timecounter tick service with a zero delta and
 *   offset. This will lead to an overflow to zero of the timehand generation.
 *   It shall not change the initial clock values.
 */
static void ScoreTimecounterValInstall_Action_0( void )
{
  ISR_lock_Context lock_context;

  _Timecounter_Acquire( &lock_context );
  _Timecounter_Tick_simple( 0, 0, &lock_context );
}

/**
 * @brief Call the directives to get the initial value of CLOCK_REALTIME and
 *   the initial boot time.
 */
static void ScoreTimecounterValInstall_Action_1( void )
{
  struct bintime  bt;
  struct timespec ts;
  struct timeval  tv;

  /*
   * Check the initial CLOCK_REALTIME in seconds and nanoseconds format.
   */
  rtems_clock_get_realtime( &ts );
  T_eq_i64( ts.tv_sec, 567993600 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check that CLOCK_REALTIME is frozen in seconds and nanoseconds format.
   */
  rtems_clock_get_realtime( &ts );
  T_eq_i64( ts.tv_sec, 567993600 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check the initial CLOCK_REALTIME in coarse resolution in seconds and
   * nanoseconds format.
   */
  rtems_clock_get_realtime_coarse( &ts );
  T_eq_i64( ts.tv_sec, 567993600 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check that CLOCK_REALTIME is frozen in coarse resolution in seconds and
   * nanoseconds format.
   */
  rtems_clock_get_realtime_coarse( &ts );
  T_eq_i64( ts.tv_sec, 567993600 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check the initial CLOCK_REALTIME in binary time format.
   */
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993600 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check that CLOCK_REALTIME is frozen in binary time format.
   */
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993600 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check the initial CLOCK_REALTIME in coarse resolution in binary time
   * format.
   */
  rtems_clock_get_realtime_coarse_bintime( &bt );
  T_eq_i64( bt.sec, 567993600 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check that CLOCK_REALTIME is frozen in coarse resolution in binary time
   * format.
   */
  rtems_clock_get_realtime_coarse_bintime( &bt );
  T_eq_i64( bt.sec, 567993600 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check the initial CLOCK_REALTIME in seconds and microseconds format.
   */
  rtems_clock_get_realtime_timeval( &tv );
  T_eq_i64( tv.tv_sec, 567993600 );
  T_eq_long( tv.tv_usec, 0 );

  /*
   * Check that CLOCK_REALTIME is frozen in seconds and microseconds format.
   */
  rtems_clock_get_realtime_timeval( &tv );
  T_eq_i64( tv.tv_sec, 567993600 );
  T_eq_long( tv.tv_usec, 0 );

  /*
   * Check the initial CLOCK_REALTIME in coarse resolution in seconds and
   * microseconds format.
   */
  rtems_clock_get_realtime_coarse_timeval( &tv );
  T_eq_i64( tv.tv_sec, 567993600 );
  T_eq_long( tv.tv_usec, 0 );

  /*
   * Check that CLOCK_REALTIME is frozen in coarse resolution in seconds and
   * microseconds format.
   */
  rtems_clock_get_realtime_coarse_timeval( &tv );
  T_eq_i64( tv.tv_sec, 567993600 );
  T_eq_long( tv.tv_usec, 0 );

  /*
   * Check the initial boot time in seconds and nanoseconds format.
   */
  rtems_clock_get_boot_time( &ts );
  T_eq_i64( ts.tv_sec, 567993599 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check the initial boot time in binary time format.
   */
  rtems_clock_get_boot_time_bintime( &bt );
  T_eq_i64( bt.sec, 567993599 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check the initial boot time in seconds and microseconds format.
   */
  rtems_clock_get_boot_time_timeval( &tv );
  T_eq_i64( tv.tv_sec, 567993599 );
  T_eq_long( tv.tv_usec, 0 );
}

/**
 * @brief Call the directives to get the initial value of CLOCK_MONOTONIC and
 *   the initial boot time.
 */
static void ScoreTimecounterValInstall_Action_2( void )
{
  struct bintime  bt;
  sbintime_t      sb;
  struct timespec ts;
  struct timeval  tv;

  /*
   * Check the initial CLOCK_MONOTONIC in seconds and nanoseconds format.
   */
  rtems_clock_get_monotonic( &ts );
  T_eq_i64( ts.tv_sec, 1 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check that CLOCK_MONOTONIC is frozen in seconds and nanoseconds format.
   */
  rtems_clock_get_monotonic( &ts );
  T_eq_i64( ts.tv_sec, 1 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check the initial CLOCK_MONOTONIC in coarse resolution in seconds and
   * nanoseconds format.
   */
  rtems_clock_get_monotonic_coarse( &ts );
  T_eq_i64( ts.tv_sec, 1 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check that CLOCK_MONOTONIC is frozen in coarse resolution in seconds and
   * nanoseconds format.
   */
  rtems_clock_get_monotonic_coarse( &ts );
  T_eq_i64( ts.tv_sec, 1 );
  T_eq_u64( ts.tv_nsec, 0 );

  /*
   * Check the initial CLOCK_MONOTONIC in binary time format.
   */
  rtems_clock_get_monotonic_bintime( &bt );
  T_eq_i64( bt.sec, 1 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check that CLOCK_MONOTONIC is frozen in binary time format.
   */
  rtems_clock_get_monotonic_bintime( &bt );
  T_eq_i64( bt.sec, 1 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check the initial CLOCK_MONOTONIC in coarse resolution in binary time
   * format.
   */
  rtems_clock_get_monotonic_coarse_bintime( &bt );
  T_eq_i64( bt.sec, 1 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check that CLOCK_MONOTONIC is frozen in coarse resolution in binary time
   * format.
   */
  rtems_clock_get_monotonic_coarse_bintime( &bt );
  T_eq_i64( bt.sec, 1 );
  T_eq_u64( bt.frac, 0 );

  /*
   * Check the initial CLOCK_MONOTONIC in signed binary time format.
   */
  sb = rtems_clock_get_monotonic_sbintime();
  T_eq_i64( sb, SBT_1S );

  /*
   * Check that CLOCK_MONOTONIC is frozen in signed binary time format.
   */
  sb = rtems_clock_get_monotonic_sbintime();
  T_eq_i64( sb, SBT_1S );

  /*
   * Check the initial CLOCK_MONOTONIC in seconds and microseconds format.
   */
  rtems_clock_get_monotonic_timeval( &tv );
  T_eq_i64( tv.tv_sec, 1 );
  T_eq_long( tv.tv_usec, 0 );

  /*
   * Check that CLOCK_MONOTONIC is frozen in seconds and microseconds format.
   */
  rtems_clock_get_monotonic_timeval( &tv );
  T_eq_i64( tv.tv_sec, 1 );
  T_eq_long( tv.tv_usec, 0 );

  /*
   * Check the initial CLOCK_MONOTONIC in coarse resolution in seconds and
   * microseconds format.
   */
  rtems_clock_get_monotonic_coarse_timeval( &tv );
  T_eq_i64( tv.tv_sec, 1 );
  T_eq_long( tv.tv_usec, 0 );

  /*
   * Check that CLOCK_MONOTONIC is frozen in coarse resolution in seconds and
   * microseconds format.
   */
  rtems_clock_get_monotonic_coarse_timeval( &tv );
  T_eq_i64( tv.tv_sec, 1 );
  T_eq_long( tv.tv_usec, 0 );
}

/**
 * @brief Install timecounter of different quality levels and frequencies.
 */
static void ScoreTimecounterValInstall_Action_3( void )
{
  Timecounter *hqlf;
  Timecounter *hqnf;
  Timecounter *hqhf;
  Timecounter *lq;
  sbintime_t   sb;

  hqlf = &high_quality_low_frequency;
  hqnf = &high_quality_normal_frequency;
  hqhf = &high_quality_high_frequency;
  lq = &low_quality;

  /*
   * Install a timecounter with a high quality level and normal frequency.
   * Check that it was installed.
   */
  hqnf->base.tc_get_timecount = GetTimecount;
  hqnf->base.tc_counter_mask = 0xffffffff;
  hqnf->base.tc_frequency = 0x20000000;
  hqnf->base.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER + 1;
  rtems_timecounter_install( &hqnf->base );

  T_eq_u32( GetCounter( hqnf ), 1 );

  sb = rtems_clock_get_monotonic_sbintime();
  T_eq_u32( GetCounter( hqnf ), 2 );
  T_eq_i64( sb, SBT_1S + 8 );

  /*
   * Install a timecounter with a high quality level and low frequency. Check
   * that it was not installed.
   */
  hqlf->base.tc_get_timecount = GetTimecount;
  hqlf->base.tc_counter_mask = 0xffffffff;
  hqlf->base.tc_frequency = 0x10000000;
  hqlf->base.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER + 1;
  rtems_timecounter_install( &hqlf->base );

  T_eq_u32( GetCounter( hqlf ), 0 );
  T_eq_u32( GetCounter( hqnf ), 2 );

  sb = rtems_clock_get_monotonic_sbintime();
  T_eq_u32( GetCounter( hqlf ), 0 );
  T_eq_u32( GetCounter( hqnf ), 3 );
  T_eq_i64( sb, SBT_1S + 16 );

  /*
   * Install a timecounter with a high quality level and high frequency. Check
   * that it was installed.
   */
  hqhf->base.tc_get_timecount = GetTimecount;
  hqhf->base.tc_counter_mask = 0xffffffff;
  hqhf->base.tc_frequency = 0x40000000;
  hqhf->base.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER + 1;
  rtems_timecounter_install( &hqhf->base );

  T_eq_u32( GetCounter( hqlf ), 0 );
  T_eq_u32( GetCounter( hqnf ), 4 );
  T_eq_u32( GetCounter( hqhf ), 1 );

  sb = rtems_clock_get_monotonic_sbintime();
  T_eq_u32( GetCounter( hqlf ), 0 );
  T_eq_u32( GetCounter( hqnf ), 4 );
  T_eq_u32( GetCounter( hqhf ), 2 );
  T_eq_i64( sb, SBT_1S + 28 );

  /*
   * Install a timecounter with a low quality level.  Check that it was not
   * installed.
   */
  lq->base.tc_get_timecount = GetTimecount;
  lq->base.tc_counter_mask = 0xffffffff;
  lq->base.tc_frequency = 0x80000000;
  lq->base.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
  rtems_timecounter_install( &lq->base );

  T_eq_u32( GetCounter( hqlf ), 0 );
  T_eq_u32( GetCounter( hqnf ), 4 );
  T_eq_u32( GetCounter( hqhf ), 2 );
  T_eq_u32( GetCounter( lq ), 0 );

  sb = rtems_clock_get_monotonic_sbintime();
  T_eq_u32( GetCounter( hqlf ), 0 );
  T_eq_u32( GetCounter( hqnf ), 4 );
  T_eq_u32( GetCounter( hqhf ), 3 );
  T_eq_u32( GetCounter( lq ), 0 );
  T_eq_i64( sb, SBT_1S + 32 );
}

/**
 * @brief Call the directives to get the time in the highest resolution
 *   available to the system.
 */
static void ScoreTimecounterValInstall_Action_4( void )
{
  Timecounter    *tc;
  uint32_t        counter;
  struct bintime  bt;
  struct timespec ts;
  struct timeval  tv;

  tc = &high_quality_high_frequency;
  counter = GetCounter( tc );

  /*
   * Check that the timecounter was used by rtems_clock_get_realtime().
   */
  rtems_clock_get_realtime( &ts );
  T_eq_u32( GetCounter( tc ), counter + 1 );

  /*
   * Check that the timecounter was used by rtems_clock_get_realtime_bintime().
   */
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_u32( GetCounter( tc ), counter + 2 );

  /*
   * Check that the timecounter was used by rtems_clock_get_realtime_timeval().
   */
  rtems_clock_get_realtime_timeval( &tv );
  T_eq_u32( GetCounter( tc ), counter + 3 );

  /*
   * Check that the timecounter was used by rtems_clock_get_monotonic().
   */
  rtems_clock_get_monotonic( &ts );
  T_eq_u32( GetCounter( tc ), counter + 4 );

  /*
   * Check that the timecounter was used by
   * rtems_clock_get_monotonic_bintime().
   */
  rtems_clock_get_monotonic_bintime( &bt );
  T_eq_u32( GetCounter( tc ), counter + 5 );

  /*
   * Check that the timecounter was used by
   * rtems_clock_get_monotonic_sbintime().
   */
  (void) rtems_clock_get_monotonic_sbintime();
  T_eq_u32( GetCounter( tc ), counter + 6 );

  /*
   * Check that the timecounter was used by
   * rtems_clock_get_monotonic_timeval().
   */
  rtems_clock_get_monotonic_timeval( &tv );
  T_eq_u32( GetCounter( tc ), counter + 7 );
}

/**
 * @brief Call the directives to get the time in a coarse resolution.
 */
static void ScoreTimecounterValInstall_Action_5( void )
{
  Timecounter    *tc;
  uint32_t        counter;
  struct bintime  bt;
  struct timespec ts;
  struct timeval  tv;

  tc = &high_quality_high_frequency;
  counter = GetCounter( tc );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_realtime_coarse().
   */
  rtems_clock_get_realtime_coarse( &ts );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_realtime_coarse_bintime().
   */
  rtems_clock_get_realtime_coarse_bintime( &bt );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_realtime_coarse_timeval().
   */
  rtems_clock_get_realtime_coarse_timeval( &tv );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_monotonic_coarse().
   */
  rtems_clock_get_monotonic_coarse( &ts );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_monotonic_coarse_bintime().
   */
  rtems_clock_get_monotonic_coarse_bintime( &bt );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_monotonic_coarse_timeval().
   */
  rtems_clock_get_monotonic_coarse_timeval( &tv );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by rtems_clock_get_boot_time().
   */
  rtems_clock_get_boot_time( &ts );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_boot_time_bintime().
   */
  rtems_clock_get_boot_time_bintime( &bt );
  T_eq_u32( GetCounter( tc ), counter );

  /*
   * Check that the timecounter was not used by
   * rtems_clock_get_boot_time_timeval().
   */
  rtems_clock_get_boot_time_timeval( &tv );
  T_eq_u32( GetCounter( tc ), counter );
}

/**
 * @brief Call the directives to get the time in the highest resolution
 *   available to the system.
 */
static void ScoreTimecounterValInstall_Action_6( void )
{
  Timecounter    *tc;
  uint32_t        counter;
  struct bintime  bt;
  sbintime_t      sb;
  struct timespec ts;
  struct timeval  tv;

  tc = &high_quality_high_frequency;
  counter = 3 * tc->base.tc_frequency + 123456789;

  /*
   * Prepare the timecounter to get a large time difference.  Check that
   * rtems_clock_get_realtime() returns the correct time.
   */
  SetCounter( tc, counter );
  rtems_clock_get_realtime( &ts );
  T_eq_i64( ts.tv_sec, 567993603 );
  T_eq_u64( ts.tv_nsec, 114978100 );

  /*
   * Prepare the timecounter to get a large time difference.  Check that
   * rtems_clock_get_realtime_bintime() returns the correct time.
   */
  SetCounter( tc, counter );
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993603 );
  T_eq_u64( bt.frac, 2120971587975905280 );

  /*
   * Prepare the timecounter to get a large time difference.  Check that
   * rtems_clock_get_realtime_timeval() returns the correct time.
   */
  SetCounter( tc, counter );
  rtems_clock_get_realtime_timeval( &tv );
  T_eq_i64( tv.tv_sec, 567993603 );
  T_eq_long( tv.tv_usec, 114978 );

  /*
   * Prepare the timecounter to get a large time difference.  Check that
   * rtems_clock_get_monotonic() returns the correct time.
   */
  SetCounter( tc, counter );
  rtems_clock_get_monotonic( &ts );
  T_eq_i64( ts.tv_sec, 4 );
  T_eq_u64( ts.tv_nsec, 114978100 );

  /*
   * Prepare the timecounter to get a large time difference.  Check that
   * rtems_clock_get_monotonic_bintime() returns the correct time.
   */
  SetCounter( tc, counter );
  rtems_clock_get_monotonic_bintime( &bt );
  T_eq_i64( bt.sec, 4 );
  T_eq_u64( bt.frac, 2120971587975905280 );

  /*
   * Prepare the timecounter to get a large time difference.  Check that
   * rtems_clock_get_monotonic_sbintime() returns the correct time.
   */
  SetCounter( tc, counter );
  sb = rtems_clock_get_monotonic_sbintime();
  T_eq_i64( sb, 17673696364 );

  /*
   * Prepare the timecounter to get a large time difference.  Check that
   * rtems_clock_get_monotonic_timeval() returns the correct time.
   */
  SetCounter( tc, counter );
  rtems_clock_get_monotonic_timeval( &tv );
  T_eq_i64( tv.tv_sec, 4 );
  T_eq_long( tv.tv_usec, 114978 );
}

/**
 * @brief Update the oldest timehand after a large time interval.
 */
static void ScoreTimecounterValInstall_Action_7( void )
{
  Timecounter    *tc;
  struct bintime  bt;

  tc = &high_quality_high_frequency;

  SetCounter( tc, 0 );
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993600 );
  T_eq_u64( bt.frac, 103079215104 );

  SetCounter( tc, 2 * tc->base.tc_frequency );
  CallTimecounterTick();

  SetCounter( tc, 2 * tc->base.tc_frequency );
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993602 );
  T_eq_u64( bt.frac, 103079215104 );
}

/**
 * @brief Call the simple timecounter tick service with non-zero delta and
 *   offset parameter values so that exactly one second passed.
 */
static void ScoreTimecounterValInstall_Action_8( void )
{
  ISR_lock_Context lock_context;
  Timecounter     *tc;
  struct bintime   bt;

  tc = &high_quality_high_frequency;

  _Timecounter_Acquire( &lock_context );
  _Timecounter_Tick_simple(
    tc->base.tc_frequency / 2,
    GetCounter( tc ) - tc->base.tc_frequency / 2,
    &lock_context
  );

  /*
   * Check that exactly one second passed due to the simple clock tick service.
   */
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993603 );
  T_eq_u64( bt.frac, 103079215104 );
}

/**
 * @brief Install a very high quality timecounter with a low frequency to test
 *   the NTP support.
 */
static void ScoreTimecounterValInstall_Action_9( void )
{
  Timecounter   *tc;
  struct bintime bt;

  tc = &very_high_quality;
  tc->base.tc_get_timecount = GetTimecount;
  tc->base.tc_counter_mask = 0xffffffff;
  tc->base.tc_frequency = 0x01000000;
  tc->base.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER + 2;
  rtems_timecounter_install( &tc->base );

  T_eq_u32( GetCounter( tc ), 1 );

  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993603 );
  T_eq_u64( bt.frac, 1219770712064 );

  /*
   * Let the seconds value of CLOCK_REALTIME not change. Check that the NTP
   * update second handler is not called.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateCounter );
  SetCounter( tc, tc->base.tc_frequency / 2 );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  T_eq_u32( ntp_counter, 0 );

  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993603 );
  T_eq_u64( bt.frac, UINT64_C( 9223373256625487872 ) );

  /*
   * Let the seconds value of CLOCK_REALTIME change by one. Check that the NTP
   * update second handler is called exactly once.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateCounter );
  SetCounter( tc, tc->base.tc_frequency );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  T_eq_u32( ntp_counter, 1 );

  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993604 );
  T_eq_u64( bt.frac, 1219770712064 );

  /*
   * Let the seconds value of CLOCK_REALTIME change by 200. Check that the NTP
   * update second handler is called exactly 200 times.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateCounter );
  SetCounter( tc, 201 * tc->base.tc_frequency );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  T_eq_u32( ntp_counter, 201 );

  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567993804 );
  T_eq_u64( bt.frac, 1219770712064 );

  /*
   * Let the seconds value of CLOCK_REALTIME change by 201. Check that the NTP
   * update second handler is called exactly twice.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateCounter );
  SetCounter( tc, 402 * tc->base.tc_frequency );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  T_eq_u32( ntp_counter, 203 );

  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567994005 );
  T_eq_u64( bt.frac, 1219770712064 );

  /*
   * Let the seconds value of CLOCK_REALTIME change by one. Check that the NTP
   * update second handler is incremented the CLOCK_REALTIME by one second.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateSecondIncrement );
  SetCounter( tc, 403 * tc->base.tc_frequency );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567994007 );
  T_eq_u64( bt.frac, 1219770712064 );

  /*
   * Let the seconds value of CLOCK_REALTIME change by one. Check that the NTP
   * update second handler is decremented the CLOCK_REALTIME by one second.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateSecondDecrement );
  SetCounter( tc, 404 * tc->base.tc_frequency );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567994007 );
  T_eq_u64( bt.frac, 1219770712064 );

  /*
   * Let the seconds value of CLOCK_REALTIME change by one. Check that the NTP
   * update second handler increased the timecounter frequency.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateAdjustmentFaster );
  SetCounter( tc, 405 * tc->base.tc_frequency );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  SetCounter( tc, 406 * tc->base.tc_frequency );
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567994009 );
  T_eq_u64( bt.frac, 92353004044288 );

  /*
   * Let the seconds value of CLOCK_REALTIME change by one. Check that the NTP
   * update second handler decreased the timecounter frequency.
   */
  _Timecounter_Set_NTP_update_second( NtpUpdateAdjustmentSlower );
  SetCounter( tc, 407 * tc->base.tc_frequency );
  CallTimecounterTick();
  _Timecounter_Set_NTP_update_second( NULL );

  SetCounter( tc, 408 * tc->base.tc_frequency );
  rtems_clock_get_realtime_bintime( &bt );
  T_eq_i64( bt.sec, 567994011 );
  T_eq_u64( bt.frac, 92353004044288 );
}

/**
 * @fn void T_case_body_ScoreTimecounterValInstall( void )
 */
T_TEST_CASE( ScoreTimecounterValInstall )
{
  ScoreTimecounterValInstall_Action_0();
  ScoreTimecounterValInstall_Action_1();
  ScoreTimecounterValInstall_Action_2();
  ScoreTimecounterValInstall_Action_3();
  ScoreTimecounterValInstall_Action_4();
  ScoreTimecounterValInstall_Action_5();
  ScoreTimecounterValInstall_Action_6();
  ScoreTimecounterValInstall_Action_7();
  ScoreTimecounterValInstall_Action_8();
  ScoreTimecounterValInstall_Action_9();
}

/** @} */