[JEDI.NET-commits] nunit/source Jedi.Timers.Schedules.BasicSchedules.pas,NONE,1.1 Jedi.Timers.Schedu

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/jedidotnet/nunit/source
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv943/nunit/source

Added Files:
	Jedi.Timers.Schedules.BasicSchedules.pas 
	Jedi.Timers.Schedules.Generic.pas 
Log Message:
Test sets for new scheduling framework

--- NEW FILE: Jedi.Timers.Schedules.Generic.pas ---
unit Jedi.Timers.Schedules.Generic;

interface

{$REGION 'Uses'}
uses
  Jedi.Timers.Schedules,
  NUnit.Framework,
  System.Collections;
{$ENDREGION}

{$REGION 'Common types'}
type
  GetNextDateCallback = procedure (var date: DateTime) of object;
{$ENDREGION}

{$REGION 'Common test class'}
type
  CommonTests = class abstract (&Object)
  public
    class procedure EnumerationTest(enum: IEnumerator; nextDateCallback: GetNextDateCallback); static;
  end;
{$ENDREGION}

{$REGION 'Generic test-set'}
type
  [TestFixture]
  Generic = class
  strict protected
    class procedure Every4DaysOfEachMonthIn2005(var date: DateTime); static;
    class procedure Every4DaysOfEachTwoOrThreeMonthsIn2005(var date: DateTime); static;
    class procedure FirstOfEachMonthIn2005(var date: DateTime); static;
    class procedure MixedOfEachMonthIn2005(var date: DateTime); static;
  public
    [Test]  procedure EnumerateNested;
    [Test]  procedure EnumerateNestedNonRecursive;
    [Test]  procedure EnumerateSimple;
    [Test]  procedure EnumerateTwoNested;
    [Test]  procedure EnumeratorWrapped;
  end;
{$ENDREGION}

implementation

{$REGION 'Helper types'}
type
  IntegerArray = array of Integer;
{$ENDREGION}

{$REGION 'DayList test schedule class'}
type
  DayListSchedule = class (Schedule)
  {$REGION 'Constructor'}
  public
    constructor Create(dayList: IntegerArray);
  {$ENDREGION}
  {$REGION 'Data'}
  strict private
    FDays: IntegerArray;
  {$ENDREGION}
  {$REGION 'Overrides'}
  strict protected
    procedure GetLimitsForImpl(date: DateTime; out start, stop: DateTime); override;
    function GetNextImpl(date, offset, maxDate: DateTime): DateTime; override;
    function ScheduleLimit: TimeSpan; override;
  {$ENDREGION}
  end;
{$ENDREGION}

{$REGION 'Test schedule class'}
type
  TestSchedule = class (Schedule)
  {$REGION 'DummySchedule'}
  strict protected
    type
      DummySchedule = class (Schedule)
      {$REGION 'Constructor'}
      public
        constructor Create(schedules: array of Schedule);
      strict protected
      {$ENDREGION}
      {$REGION 'Overrides'}
      strict protected
        procedure GetLimitsForImpl(date: DateTime; out start, stop: DateTime); override;
        function GetNextImpl(date, offset, maxDate: DateTime): DateTime; override;
        function ScheduleLimit: TimeSpan; override;
      {$ENDREGION}
      end;
  {$ENDREGION}
  {$REGION 'Constructors'}
  public
    constructor Create; overload;
    constructor Create(dayList: IntegerArray); overload;
    constructor Create(firstMonth, interval: Integer); overload;
    constructor Create(firstMonth, interval: Integer; dayList: IntegerArray); overload;
    class function Create(schedules: ScheduleArray): Schedule; overload; static;
    class function Create(dayList1, dayList2: IntegerArray): Schedule; overload; static;
  {$ENDREGION}
  {$REGION 'Data'}
  strict private
    FFirstMonth: Integer;
    FInterval: Integer;
  {$ENDREGION}
  {$REGION 'Overrides'}
  strict protected
    procedure GetLimitsForImpl(date: DateTime; out start, stop: DateTime); override;
    function GetNextImpl(date, offset, maxDate: DateTime): DateTime; override;
    function ScheduleLimit: TimeSpan; override;
  {$ENDREGION}
  end;
{$ENDREGION}

{$REGION 'CommonTests'}
class procedure CommonTests.EnumerationTest(enum: IEnumerator; nextDateCallback: GetNextDateCallback);
var
  iteration: Integer;
  date: DateTime;
begin
  iteration := 1;
  date := DateTime.MinValue;
  nextDateCallback(date);
  while enum.MoveNext do
  begin
    Assert.IsFalse(date = DateTime.MaxValue, 'Iterated beyond limit. Iteration={0}, Date={1}', [iteration, enum.Current]);
    Assert.AreEqual(date, DateTime(enum.Current), 'Iteration={0}', [iteration]);
    nextDateCallback(date);
    Inc(iteration);
  end;
  Assert.IsTrue(date = DateTime.MaxValue, 'Enumeration end error. Iteration={0}', [iteration]);
end;
{$ENDREGION}

{$REGION 'DayListSchedule'}
constructor DayListSchedule.Create(dayList: IntegerArray);
begin
  inherited Create(nil);
  FDays := IntegerArray(&Array(&Array(dayList).Clone));
  &Array.Sort(FDays);
end;

procedure DayListSchedule.GetLimitsForImpl(date: DateTime; out start, stop: DateTime);
var
  idx: Integer;
  parentStart: DateTime;
  parentStop: DateTime;
begin
//  Console.WriteLine('{0}.GetLimitsForImpl({1})', GetType.FullName, date.ToString('dd-MM-yyyy HH:mm:ss.fffffff'));
  if Parent <> nil then
  begin
    Parent.GetLimitsFor(date, parentStart, parentStop);
    if date < parentStart then
      date := parentStart;
  end;
  idx := &Array.BinarySearch(&Array(FDays), &Object(date.Day));
  if idx < 0 then
    idx := not idx
  else
    Inc(idx);
  if (idx < &Array(FDays).Length - 1) and (FDays[idx] <= DateTime.DaysInMonth(date.Year, date.Month)) then
  begin
    start := DateTime.Create(date.Year, date.Month, FDays[idx]);
    stop := start.AddDays(1).AddTicks(-1);
  end
  else
  begin
    start := DateTime.MaxValue;
    stop := DateTime.MaxValue;
  end;
//  Console.WriteLine('{0}.GetLimitsForImpl({1}) => start={2}, stop={3}', GetType.FullName, date.ToString('dd-MM-yyyy HH:mm:ss.fffffff'), start.ToString('dd-MM-yyyy HH:mm:ss.fffffff'), stop.ToString('dd-MM-yyyy HH:mm:ss.fffffff'));
end;

function DayListSchedule.GetNextImpl(date, offset, maxDate: DateTime): DateTime;
var
  idx: Integer;
begin
  if date < offset then
    idx := &Array.BinarySearch(&Array(FDays), &Object(offset.Day))
  else
    idx := &Array.BinarySearch(&Array(FDays), &Object(date.Day));
  if idx < 0 then
    idx := not idx
  else
  if date >= offset then
    Inc(idx);
  if date < offset then
    date := offset;
  if (idx < &Array(FDays).Length) and (FDays[idx] <= DateTime.DaysInMonth(date.Year, date.Month)) then
    Result := DateTime.Create(date.Year, date.Month, FDays[idx])
  else
    Result := DateTime.MaxValue;
  if Result > maxDate then
    Result := DateTime.MaxValue;
end;

function DayListSchedule.ScheduleLimit: TimeSpan;
begin
  Result := TimeSpan.FromDays(1);
end;
{$ENDREGION}

{$REGION 'Generic'}
procedure Generic.EnumerateNested;
begin
  CommonTests.EnumerationTest(
    TestSchedule.Create(IntegerArray.Create(4, 8, 12, 16, 20, 24, 28)).GetEnumerator, Every4DaysOfEachMonthIn2005);
end;

procedure Generic.EnumerateNestedNonRecursive;
begin
  CommonTests.EnumerationTest(
    TestSchedule.Create(IntegerArray.Create(4, 8, 12, 16, 20, 24, 28)).GetEnumerator(False), FirstOfEachMonthIn2005);
end;

procedure Generic.EnumerateSimple;
begin
  CommonTests.EnumerationTest(TestSchedule.Create.GetEnumerator, FirstOfEachMonthIn2005);
end;

procedure Generic.EnumerateTwoNested;
begin
  CommonTests.EnumerationTest(
    TestSchedule.Create(
      IntegerArray.Create(4, 8, 12, 16, 20, 24, 28),                     // odd months
      IntegerArray.Create(2, 6, 10, 14, 18, 22, 26, 30)).GetEnumerator,  // even months
    MixedOfEachMonthIn2005);
end;

procedure Generic.EnumeratorWrapped;
begin
  CommonTests.EnumerationTest(
    Schedule.Wrap(                    // Jan, Mar, Apr, May, Jul, Sep, Oct, Nov
      TestSchedule.Create(
        ScheduleArray.Create(
          TestSchedule.Create(1, 3),  // Jan, Apr, Jul, Oct
          TestSchedule.Create(1, 2)   // Jan, Mar, May, Jul, Sep, Nov
        )),
      [DayListSchedule.Create(IntegerArray.Create(4, 8, 12, 16, 20, 24, 28))]
    ).GetEnumerator, Every4DaysOfEachTwoOrThreeMonthsIn2005);
end;

class procedure Generic.Every4DaysOfEachMonthIn2005(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2005, 1, 4)
  else
  begin
    if (date.Day + 4) > DateTime.DaysInMonth(date.Year, date.Month) then
      date := DateTime.Create(date.Year, date.Month, 4).AddMonths(1)
    else
      date := date.AddDays(4);
    if date.Year = 2006 then
      date := DateTime.MaxValue;
  end;
end;

class procedure Generic.Every4DaysOfEachTwoOrThreeMonthsIn2005(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2005, 1, 4)
  else
  begin
    if (date.Day + 4) > DateTime.DaysInMonth(date.Year, date.Month) then
    begin
      date := DateTime.Create(date.Year, date.Month, 4).AddMonths(1);
      if date.Month in [2, 6, 8, 12] then
        date := date.AddMonths(1);
    end
    else
      date := date.AddDays(4);
    if date.Year = 2006 then
      date := DateTime.MaxValue;
  end;
end;

class procedure Generic.FirstOfEachMonthIn2005(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2005, 1, 1)
  else
  begin
    date := date.AddMonths(1);
    if date.Year = 2006 then
      date := DateTime.MaxValue;
  end;
end;

class procedure Generic.MixedOfEachMonthIn2005(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2005, 1, 4)
  else
  begin
    if (date.Day + 4) > DateTime.DaysInMonth(date.Year, date.Month) then
      date := DateTime.Create(date.Year, date.Month, 4 - 2 * (date.Month mod 2)).AddMonths(1)
    else
      date := date.AddDays(4);
    if date.Year = 2006 then
      date := DateTime.MaxValue;
  end;
end;
{$ENDREGION}

{$REGION 'TestSchedule'}
constructor TestSchedule.Create;
begin
  inherited Create(nil);
  FFirstMonth := 1;
  FInterval := 1;
end;

constructor TestSchedule.Create(dayList: IntegerArray);
begin
  inherited Create(ScheduleArray.Create(DayListSchedule.Create(dayList)));
  FFirstMonth := 1;
  FInterval := 1;
end;

constructor TestSchedule.Create(firstMonth, interval: Integer);
begin
  inherited Create(nil);
  FFirstMonth := firstMonth;
  FInterval := interval;
end;

constructor TestSchedule.Create(firstMonth, interval: Integer; dayList: IntegerArray);
begin
  inherited Create(ScheduleArray.Create(DayListSchedule.Create(dayList)));
  FFirstMonth := firstMonth;
  FInterval := interval;
end;

class function TestSchedule.Create(schedules: ScheduleArray): Schedule;
begin
  Result := DummySchedule.Create(schedules);
end;

class function TestSchedule.Create(dayList1, dayList2: IntegerArray): Schedule;
begin
  Result := DummySchedule.Create([
    TestSchedule.Create(1, 2, dayList1),  // January,  March, May,  July,   September, November with dayList1
    TestSchedule.Create(2, 2, dayList2)   // Februari, April, June, August, October,   December with dayList2
  ])
end;

procedure TestSchedule.GetLimitsForImpl(date: DateTime; out start, stop: DateTime);
var
  month: Integer;
begin
  if date.Year < 2005 then
    start := DateTime.Create(2005, FFirstMonth, 1)
  else
  if date.Year > 2005 then
    start := DateTime.MaxValue
  else
  begin
    month := FFirstMonth + FInterval * ((date.Month - FFirstMonth) div FInterval);
    if month < date.Month then
      Inc(month, FInterval);
    if month <= 12 then
      start := DateTime.Create(2005, month, 1)
    else
      start := DateTime.MaxValue;
  end;
  if start < DateTime.MaxValue.AddMonths(-1) then
    stop := start.AddMonths(1).AddTicks(-1)
  else
    stop := DateTime.MaxValue;
end;

function TestSchedule.GetNextImpl(date, offset, maxDate: DateTime): DateTime;
var
  month: Integer;
begin
//  Console.WriteLine('{0}.GetNextImpl({1},{2},{3})', GetType.FullName, date.ToString('dd-MM-yyyy HH:mm:ss.fffffff'),
//    offset.ToString('dd-MM-yyyy HH:mm:ss.fffffff'), maxDate.ToString('dd-MM-yyyy HH:mm:ss.fffffff'));
  if date < DateTime.Create(2005, 1, 1) then
    date := DateTime.Create(2005, 1, 1);
//  else
  begin
    month := FFirstMonth + FInterval * ((date.Month - FFirstMonth) div FInterval);
    if month < FFirstMonth then
      month := FFirstMonth;
    if (month < date.Month) or (date.Day > 1) or (date.TimeOfDay.Ticks > 0) then
      Inc(month, FInterval);
  end;
  if month <= 12 then
    Result := DateTime.Create(2005, month, 1)
  else
    Result := DateTime.MaxValue;
  if Result >= DateTime.Create(2006, 1, 1) then
    Result := DateTime.MaxValue;
//  Console.WriteLine('  Result={0}', Result.ToString('dd-MM-yyyy HH:mm:ss.fffffff'));
end;

function TestSchedule.ScheduleLimit: TimeSpan;
begin
  Result := TimeSpan.FromDays(365);
end;
{$ENDREGION}

{$REGION 'TestSchedule.DummySchedule'}
constructor TestSchedule.DummySchedule.Create(schedules: array of Schedule);
begin
  inherited Create(schedules);
end;

procedure TestSchedule.DummySchedule.GetLimitsForImpl(date: DateTime; out start, stop: DateTime);
begin
  if date < DateTime.MaxValue then
    start := DateTime.MinValue
  else
    start := DateTime.MaxValue;
  stop := DateTime.MaxValue;
end;

function TestSchedule.DummySchedule.GetNextImpl(date, offset, maxDate: DateTime): DateTime;
begin
  Result := DateTime.MaxValue;
end;

function TestSchedule.DummySchedule.ScheduleLimit: TimeSpan;
begin
  Result := TimeSpan.MaxValue;
end;
{$ENDREGION}

end.

--- NEW FILE: Jedi.Timers.Schedules.BasicSchedules.pas ---
unit Jedi.Timers.Schedules.BasicSchedules;

interface

{$REGION 'Uses'}
uses
  Jedi.Timers.Schedules,
  Jedi.Timers.Schedules.Generic,
  NUnit.Framework,
  System.Collections;
{$ENDREGION}

{$REGION 'DaySchedule test set'}
type
  [TestFixture]
  DaySchedule = class
  strict protected
    class procedure Every3DaysFromMonth12ToMonth47(var date: DateTime); static;
    class procedure EveryDayEvery9MonthsEveryYearFrom2005To2010(var date: DateTime); static;
    class procedure EveryDayFromMonth12ToMonth47(var date: DateTime); static;
  public
    [Test]  procedure Enumerate_Every3DaysFromJanOf0002ToDecOf0002;
    [Test]  procedure Enumerate_EveryDayFromJanOf0002ToDecOf0002;
    [Test]  procedure Enumerate_EveryDayInEvery9MonthsOfEveryYearFrom2005To2010;
//    [Test]  procedure Enumerate_Every11DaysInEvery3MonthsFromFebToSepInEvery4YearsFrom2005To2050;
  end;
{$ENDREGION}

{$REGION 'MonthSchedule test set'}
type
  [TestFixture]
  MonthSchedule = class
  strict protected
    class procedure EveryMonthFrom12To47(var date: DateTime); static;
    class procedure EveryMonthFrom0To11Every2YearsFrom2005To2010(var date: DateTime); static;
    class procedure Every3MonthsFrom1To8Every4YearsFrom2005To2050(var date: DateTime); static;
    class procedure Every3MonthsFrom12To47(var date: DateTime); static;
  public
    [Test]  procedure JanOf0001ToMonthNumber;
    [Test]  procedure JanOf0002ToMonthNumber;
    [Test]  procedure Month000000ToDateTime;
    [Test]  procedure Month000011ToDateTime;
    [Test]  procedure Month000012ToDateTime;
    [Test]  procedure Month119987ToDateTime;
    [Test]  procedure DecOf0002ToMonthNumber;
    [Test]  procedure DecOf9999ToMonthNumber;
    [Test]  procedure Enumerate_EveryMonthFromJanOf0002ToDecOf0004;
    [Test]  procedure Enumerate_EveryThreeMonthsFromJanOf0002ToDecOf0004;
    [Test]  procedure Enumerate_EveryMonthFromJanToDecInEvery2YearsFrom2005To2010;
    [Test]  procedure Enumerate_Every3MonthsFromFebToSepInEvery4YearsFrom2005To2050;
  end;
{$ENDREGION}

{$REGION 'YearSchedule test set'}
type
  [TestFixture]
  YearSchedule = class
  strict protected
    class procedure NextDateJanFirstOf2004To2008(var date: DateTime); static;
    class procedure NextDateJanFirstOfEveryFiveYearsFrom2000To3000(var date: DateTime); static;
  public
    [Test]  procedure Enumerate_2004To2008;
    [Test]  procedure Enumerate_EveryFiveYearsFrom2000To3000;
  end;
{$ENDREGION}

implementation

{$REGION 'DaySchedule'}
class procedure DaySchedule.Every3DaysFromMonth12ToMonth47(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2, 1, 1)
  else
  begin
    date := date.AddDays(3);
    if date > DateTime.Create(2, 12, 31) then
      date := DateTime.MaxValue;
  end;
end;

class procedure DaySchedule.EveryDayEvery9MonthsEveryYearFrom2005To2010(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2005, 1, 1)
  else
  begin
    date := date.AddDays(1);
    if date.Day = 1 then
    begin
      if date.Month = 2 then       // We've just ended Januari, so skip to
        date := date.AddMonths(8)  // October of the same year
      else                         // we must have ended October, so we skip to
        date := date.AddMonths(2); // Januari of next year
    end;
    if date > DateTime.Create(2010, 12, 31) then
      date := DateTime.MaxValue;
  end;
end;

class procedure DaySchedule.EveryDayFromMonth12ToMonth47(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2, 1, 1)
  else
  begin
    date := date.AddDays(1);
    if date > DateTime.Create(2, 12, 31) then
      date := DateTime.MaxValue;
  end;
end;

procedure DaySchedule.Enumerate_Every3DaysFromJanOf0002ToDecOf0002;
begin
  CommonTests.EnumerationTest(
    Jedi.Timers.Schedules.DaySchedule.Create(
      3,
      DateTime.Create(2, 1, 1).Ticks div TimeSpan.TicksPerDay,
      DateTime.Create(2, 12, 31).Ticks div TimeSpan.TicksPerDay).GetEnumerator,
    Every3DaysFromMonth12ToMonth47);
end;

procedure DaySchedule.Enumerate_EveryDayFromJanOf0002ToDecOf0002;
begin
  CommonTests.EnumerationTest(
    Jedi.Timers.Schedules.DaySchedule.Create(
      DateTime.Create(2, 1, 1).Ticks div TimeSpan.TicksPerDay,
      DateTime.Create(2, 12, 31).Ticks div TimeSpan.TicksPerDay).GetEnumerator,
    EveryDayFromMonth12ToMonth47);
end;

procedure DaySchedule.Enumerate_EveryDayInEvery9MonthsOfEveryYearFrom2005To2010;
begin
  CommonTests.EnumerationTest(
    Jedi.Timers.Schedules.YearSchedule.Create(
      2005,                                             // Start with year 2005
      2010, [                                           // End with year 2010
        Jedi.Timers.Schedules.MonthSchedule.Create(     // for each year:
          9,                                            //   each 9 month interval
          0,                                            //   from the first month of the year
          11, [                                         //   to the last month of the year
            Jedi.Timers.Schedules.DaySchedule.Create(   //   for each available month:
              0,                                        //     from the first day of the month
              100)                                      //     to the last day of the month (must be > 31 for this)
          ])
        ]).GetEnumerator,
    EveryDayEvery9MonthsEveryYearFrom2005To2010);
end;
{$ENDREGION}

{$REGION 'MonthSchedule'}
class procedure MonthSchedule.EveryMonthFrom12To47(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2, 1, 1)
  else
  begin
    date := date.AddMonths(1);
    if date > DateTime.Create(4, 12, 1) then
      date := DateTime.MaxValue;
  end;
end;

class procedure MonthSchedule.EveryMonthFrom0To11Every2YearsFrom2005To2010(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2005, 1, 1)
  else
  begin
    date := date.AddMonths(1);
    if date.Month = 1 then
      date := date.AddYears(1); // skip a year
    if date.Year > 2010 then
      date := DateTime.MaxValue;
  end;
end;

class procedure MonthSchedule.Every3MonthsFrom1To8Every4YearsFrom2005To2050(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2005, 2, 1)
  else
  begin
    date := date.AddMonths(3);
    if date.Month > 9 then
      date := DateTime.Create(date.Year + 4, 2, 1); // start of the next year (four years from the current year)
    if date.Year > 2050 then
      date := DateTime.MaxValue;
  end;
end;

class procedure MonthSchedule.Every3MonthsFrom12To47(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2, 1, 1)
  else
  begin
    date := date.AddMonths(3);
    if date > DateTime.Create(4, 12, 1) then
      date := DateTime.MaxValue;
  end;
end;

procedure MonthSchedule.JanOf0001ToMonthNumber;
begin
  Assert.AreEqual(0, Jedi.Timers.Schedules.MonthSchedule.ToMonths(DateTime.Create(1, 1, 1)));
end;

procedure MonthSchedule.JanOf0002ToMonthNumber;
begin
  Assert.AreEqual(12, Jedi.Timers.Schedules.MonthSchedule.ToMonths(DateTime.Create(2, 1, 1)));
end;

procedure MonthSchedule.Month000000ToDateTime;
begin
  Assert.AreEqual(DateTime.Create(1, 1, 1), Jedi.Timers.Schedules.MonthSchedule.FromMonths(0));
end;

procedure MonthSchedule.Month000011ToDateTime;
begin
  Assert.AreEqual(DateTime.Create(1, 12, 1), Jedi.Timers.Schedules.MonthSchedule.FromMonths(11));
end;

procedure MonthSchedule.Month000012ToDateTime;
begin
  Assert.AreEqual(DateTime.Create(2, 1, 1), Jedi.Timers.Schedules.MonthSchedule.FromMonths(12));
end;

procedure MonthSchedule.Month119987ToDateTime;
begin
  Assert.AreEqual(DateTime.Create(9999, 12, 1), Jedi.Timers.Schedules.MonthSchedule.FromMonths(119987));
end;

procedure MonthSchedule.DecOf0002ToMonthNumber;
begin
  Assert.AreEqual(23, Jedi.Timers.Schedules.MonthSchedule.ToMonths(DateTime.Create(2, 12, 1)));
end;

procedure MonthSchedule.DecOf9999ToMonthNumber;
begin
  Assert.AreEqual(119987, Jedi.Timers.Schedules.MonthSchedule.ToMonths(DateTime.Create(9999, 12, 1)));
end;

procedure MonthSchedule.Enumerate_EveryMonthFromJanOf0002ToDecOf0004;
begin
  CommonTests.EnumerationTest(Jedi.Timers.Schedules.MonthSchedule.Create(12, 47).GetEnumerator, EveryMonthFrom12To47);
end;

procedure MonthSchedule.Enumerate_EveryThreeMonthsFromJanOf0002ToDecOf0004;
begin
  CommonTests.EnumerationTest(Jedi.Timers.Schedules.MonthSchedule.Create(3, 12, 47).GetEnumerator, Every3MonthsFrom12To47);
end;

procedure MonthSchedule.Enumerate_EveryMonthFromJanToDecInEvery2YearsFrom2005To2010;
begin
  CommonTests.EnumerationTest(
    Jedi.Timers.Schedules.YearSchedule.Create(2, 2005, 2010, [  // Every two years from 2005 to 2010
      Jedi.Timers.Schedules.MonthSchedule.Create(0, 100)        // Every month from Januari to December; note that
                                                                // end value is unimportant, as long as it is >= 11
    ]).GetEnumerator, EveryMonthFrom0To11Every2YearsFrom2005To2010);
end;

procedure MonthSchedule.Enumerate_Every3MonthsFromFebToSepInEvery4YearsFrom2005To2050;
begin
  CommonTests.EnumerationTest(
    Jedi.Timers.Schedules.YearSchedule.Create(4, 2005, 2050, [  // Every four years from 2005 to 2050
      Jedi.Timers.Schedules.MonthSchedule.Create(3, 1, 8)       // Every three months from Februari to September
    ]).GetEnumerator, Every3MonthsFrom1To8Every4YearsFrom2005To2050);
end;
{$ENDREGION}

{$REGION 'YearSchedule'}
procedure YearSchedule.Enumerate_2004To2008;
begin
  CommonTests.EnumerationTest(Jedi.Timers.Schedules.YearSchedule.Create(2004, 2008).GetEnumerator, NextDateJanFirstOf2004To2008);
end;

procedure YearSchedule.Enumerate_EveryFiveYearsFrom2000To3000;
begin
  CommonTests.EnumerationTest(Jedi.Timers.Schedules.YearSchedule.Create(5, 2000, 3000).GetEnumerator, NextDateJanFirstOfEveryFiveYearsFrom2000To3000);
end;

class procedure YearSchedule.NextDateJanFirstOf2004To2008(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2004, 1, 1)
  else
    date := DateTime.Create(date.Year + 1, 1, 1);
  if date.Year > 2008 then
    date := DateTime.MaxValue;
end;

class procedure YearSchedule.NextDateJanFirstOfEveryFiveYearsFrom2000To3000(var date: DateTime);
begin
  if date = DateTime.MinValue then
    date := DateTime.Create(2000, 1, 1)
  else
    date := DateTime.Create(date.Year + 5, 1, 1);
  if date.Year > 3000 then
    date := DateTime.MaxValue;
end;
{$ENDREGION}

end.

[JEDI.NET-commits] nunit/source Jedi.Timers.Schedules.BasicSchedules.pas,NONE,1.1 Jedi.Timers.Schedu

[JEDI.NET-commits] nunit/source Jedi.Timers.Schedules.BasicSchedules.pas,NONE,1.1 Jedi.Timers.Schedules.Generic.pas,NONE,1.1