All About Test Part 1 - Choosing Your Tests

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using QgOne.Core;

namespace DateTimeTests
{
  [Settable, Serializable]
  public class MTimeSpan
  {
    #region Categories

    public enum DayCategory { Zero, One, Year, YearAndOneDay }
    public enum TimeCategory
    {
      /// <summary>
      /// A value that causes no wrap when added to DateTime.Millisecond, Second, Minute or Hour
      /// </summary>
      NoWrap,

      /// <summary>
      /// A value that causes a wrap when added to DateTime.Millisecond, Second, Minute or Hour are in category Max
      /// </summary>
      Wrap
    }

    #endregion Categories

    #region Factors

    public DayCategory Days { get; set; }
    public TimeCategory Hours { get; set; }
    public TimeCategory Minutes { get; set; }
    public TimeCategory Seconds { get; set; }
    public TimeCategory Milliseconds { get; set; }

    #endregion Factors

    #region Counts

    public int MonthDays
    {
      get
      {
        if (Days == DayCategory.Zero || Days == DayCategory.Year)
        {
          return 0;
        }
        else
        {
          return 1;
        }
      }
    }

    public int Months { get { return 0; } } // Hardcoded to 0 because no category yields a different value

    public int Years
    {
      get
      {
        return Days == DayCategory.Year || Days == DayCategory.YearAndOneDay ? 1 : 0;
      }
    }

    #endregion Counts

    #region Resolve

    public int ResolveDays(int daysInYear)
    {
      switch (Days)
      {
        case DayCategory.Zero:
          return 0;
        case DayCategory.One:
          return 1;
        case DayCategory.Year:
          return daysInYear;
        case DayCategory.YearAndOneDay:
          return daysInYear + 1;
      }

      throw new ArgumentException(string.Format("Cannot resolve days for {0}", Days));
    }

    public int ResolveTimeCategory(int target, bool carryFromPrevious, TimeCategory tc, int minValue, int maxValue)
    {
      if (carryFromPrevious)
      {
        ++target;
      }

      if (target > maxValue)
      {
        // Can happen e.g. if Minute is 59 and carryFromPreviosu is true
        return 0;
      }

      Random prng = new Random();
      if (tc == TimeCategory.NoWrap)
      {
        return prng.Next(target, maxValue) - target; // A random value that does not cause a wrap
      }
      else if (tc == TimeCategory.Wrap)
      {
        if (target == 0)
        {
          throw new ArgumentException("Not possible to derive time part that causes 0 to wrap");
        }
        return prng.Next(maxValue + 1, target + maxValue) - target; // A random value that causes a wrap
      }

      throw new ArgumentException("Unknown time category");
    }

    public void Resolve(MDateTime mdt, MValidate val)
    {
      DateTime target = mdt.Value;

      int days = ResolveDays(mdt.DaysInYear);
      int hours = ResolveTimeCategory(target.Hour, val.Overflow_min, Hours, 0, 23);
      int mins = ResolveTimeCategory(target.Minute, val.Overflow_sec, Minutes, 0, 59);
      int secs = ResolveTimeCategory(target.Second, val.Overflow_ms, Seconds, 0, 59);
      int msecs = ResolveTimeCategory(target.Millisecond, false, Milliseconds, 0, 999);

      Value = new TimeSpan(days, hours, mins, secs, msecs);
    }

    #endregion Resolve

    /// <summary>
    /// Resolve must be called before using this property.
    /// </summary>
    public TimeSpan Value { get; private set; }

  }
}