public void TestConfigurationChangeGap()
        {
            SchedulerConfiguration current = SchedulerConfiguration.Active;

            try
            {
                ISchedule oneOff    = Scheduler.GetSchedule("OneOff");
                ISchedule gap       = Scheduler.GetSchedule("Gap");
                ISchedule etm       = Scheduler.GetSchedule("EveryTwoMonths");
                ISchedule aggregate = Scheduler.GetSchedule("Aggregate");

                SchedulerConfiguration newConfig = CloneConfig(current);
                newConfig.Schedules["Gap"].Parameters["timeSpan"].Value = "4.00:00:00";

                SchedulerConfiguration.Active = newConfig;

                Thread.Sleep(ConfigurationExtensions.EventBufferMs * 2);

                Assert.AreSame(oneOff, Scheduler.GetSchedule("OneOff"));
                Assert.AreNotSame(gap, Scheduler.GetSchedule("Gap"));
                Assert.AreSame(etm, Scheduler.GetSchedule("EveryTwoMonths"));
                Assert.AreNotSame(aggregate, Scheduler.GetSchedule("Aggregate"));

                ISchedule newGap = Scheduler.GetSchedule("Gap");
                Assert.IsNotNull(newGap);
                Assert.IsInstanceOfType(newGap, typeof(GapSchedule));

                Instant  i = Instant.FromDateTimeOffset(DateTimeOffset.Parse("13/01/2100 09:10:11 +00:00"));
                Duration d = Duration.FromTimeSpan(TimeSpan.Parse("4.00:00:00"));
                Assert.AreEqual(i + d, newGap.Next(i));

                AggregateSchedule newAggregate = Scheduler.GetSchedule("Aggregate") as AggregateSchedule;
                Assert.IsNotNull(newAggregate);

                ISchedule[] array = newAggregate.ToArray();
                Assert.AreEqual(3, array.Length);
                Assert.AreSame(oneOff, array[0]);
                Assert.AreSame(newGap, array[1]);
                Assert.AreSame(etm, array[2]);
            }
            finally
            {
                SchedulerConfiguration.Active = current;
            }
        }
        public void TestMethod1()
        {
            ISchedule oneOff = Scheduler.GetSchedule("OneOff");

            Assert.IsNotNull(oneOff);
            Assert.IsInstanceOfType(oneOff, typeof(OneOffSchedule));

            Instant i = Instant.FromDateTimeOffset(DateTimeOffset.Parse("13/01/2100 09:10:11 +00:00"));

            Assert.AreEqual(i, oneOff.Next(Instant.MinValue));
            Assert.AreEqual(Instant.MaxValue, oneOff.Next(i + Duration.FromTicks(1)));


            ISchedule gap = Scheduler.GetSchedule("Gap");

            Assert.IsNotNull(gap);
            Assert.IsInstanceOfType(gap, typeof(GapSchedule));

            Duration d = Duration.FromTimeSpan(TimeSpan.Parse("3.12:00:00"));

            Assert.AreEqual(i + d, gap.Next(i));

            ISchedule etm = Scheduler.GetSchedule("EveryTwoMonths");

            Assert.IsNotNull(etm);
            Assert.IsInstanceOfType(etm, typeof(PeriodicSchedule));

            ISchedule aggregate = Scheduler.GetSchedule("Aggregate");

            Assert.IsNotNull(aggregate);
            Assert.IsInstanceOfType(aggregate, typeof(AggregateSchedule));

            AggregateSchedule ags = aggregate as AggregateSchedule;

            Assert.IsNotNull(ags);

            ISchedule[] array = ags.ToArray();
            Assert.AreEqual(3, array.Length);
            Assert.AreSame(oneOff, array[0]);
            Assert.AreSame(gap, array[1]);
            Assert.AreSame(etm, array[2]);
        }