public void TestAcquireNextTrigger()
        {
            DateTimeOffset d = DateBuilder.EvenMinuteDateAfterNow();
            IOperableTrigger trigger1 = new SimpleTriggerImpl("trigger1", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddSeconds(200), d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger2 = new SimpleTriggerImpl("trigger2", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddSeconds(50), d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger3 = new SimpleTriggerImpl("trigger1", "triggerGroup2", fJobDetail.Name, fJobDetail.Group, d.AddSeconds(100), d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));

            trigger1.ComputeFirstFireTimeUtc(null);
            trigger2.ComputeFirstFireTimeUtc(null);
            trigger3.ComputeFirstFireTimeUtc(null);
            fJobStore.StoreTrigger(trigger1, false);
            fJobStore.StoreTrigger(trigger2, false);
            fJobStore.StoreTrigger(trigger3, false);

            DateTimeOffset firstFireTime = trigger1.GetNextFireTimeUtc().Value;

            Assert.AreEqual(0, fJobStore.AcquireNextTriggers(d.AddMilliseconds(10), 1, TimeSpan.Zero).Count);
            Assert.AreEqual(trigger2, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero)[0]);
            Assert.AreEqual(trigger3, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero)[0]);
            Assert.AreEqual(trigger1, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero)[0]);
            Assert.AreEqual(0, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero).Count);


            // release trigger3
            fJobStore.ReleaseAcquiredTrigger(trigger3);
            Assert.AreEqual(trigger3, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1))[0]);
        }
Exemple #2
0
        /// <summary>
        /// Trigger the identified <see cref="IJob" /> (Execute it now) - with a non-volatile trigger.
        /// </summary>
        public virtual void TriggerJob(JobKey jobKey, JobDataMap data)
        {
            ValidateState();

            // TODO: use builder
            IOperableTrigger trig = new SimpleTriggerImpl(
                NewTriggerId(), SchedulerConstants.DefaultGroup, jobKey.Name, jobKey.Group, SystemTime.UtcNow(), null, 0, TimeSpan.Zero);

            trig.ComputeFirstFireTimeUtc(null);
            if (data != null)
            {
                trig.JobDataMap = data;
            }

            bool collision = true;
            while (collision)
            {
                try
                {
                    resources.JobStore.StoreTrigger(trig, false);
                    collision = false;
                }
                catch (ObjectAlreadyExistsException)
                {
                    trig.Key = new TriggerKey(NewTriggerId(), SchedulerConstants.DefaultGroup);
                }
            }

            NotifySchedulerThread(trig.GetNextFireTimeUtc());
            NotifySchedulerListenersScheduled(trig);
        }
        public void TestSchedulingWhenUpdatingScheduleBasedOnExistingTrigger()
        {
            DateTimeOffset startTime = new DateTimeOffset(2012, 12, 30, 1, 0, 0, TimeSpan.Zero);
            DateTimeOffset previousFireTime = new DateTimeOffset(2013, 2, 15, 15, 0, 0, TimeSpan.Zero);
            SimpleTriggerImpl existing = new SimpleTriggerImpl("triggerToReplace", "groupToReplace", startTime, null, SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromHours(1));
            existing.JobKey = new JobKey("jobName1", "jobGroup1");
            existing.SetPreviousFireTimeUtc(previousFireTime);
            existing.GetNextFireTimeUtc();

            mockScheduler.Stub(x => x.GetTrigger(existing.Key)).Return(existing);

            Stream s = ReadJobXmlFromEmbeddedResource("ScheduleRelativeToOldTrigger.xml");
            processor.ProcessStream(s, null);
            processor.ScheduleJobs(mockScheduler);

            // check that last fire time was taken from existing trigger
            mockScheduler.Stub(x => x.RescheduleJob(null, null)).IgnoreArguments();
            var args = mockScheduler.GetArgumentsForCallsMadeOn(x => x.RescheduleJob(null, null));
            ITrigger argumentTrigger = (ITrigger) args[0][1];

            // replacement trigger should have same start time and next fire relative to old trigger's last fire time 
            Assert.That(argumentTrigger, Is.Not.Null);
            Assert.That(argumentTrigger.StartTimeUtc, Is.EqualTo(startTime));
            Assert.That(argumentTrigger.GetNextFireTimeUtc(), Is.EqualTo(previousFireTime.AddSeconds(10)));
        }
        public void TestUpdateAfterMisfire()
        {
            DateTimeOffset startTime = new DateTimeOffset(2005, 7, 5, 9, 0, 0, TimeSpan.Zero);

            DateTimeOffset endTime = new DateTimeOffset(2005, 7, 5, 10, 0, 0, TimeSpan.Zero);

            SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
            simpleTrigger.MisfireInstruction = MisfireInstruction.SimpleTrigger.RescheduleNowWithExistingRepeatCount;
            simpleTrigger.RepeatCount = 5;
            simpleTrigger.StartTimeUtc = startTime;
            simpleTrigger.EndTimeUtc = endTime;

            simpleTrigger.UpdateAfterMisfire(null);
            Assert.AreEqual(startTime, simpleTrigger.StartTimeUtc);
            Assert.AreEqual(endTime, simpleTrigger.EndTimeUtc.Value);
            Assert.IsTrue(!simpleTrigger.GetNextFireTimeUtc().HasValue);
        }
        public void TestGetFireTimeAfter_WithCalendar()
        {
            DailyCalendar dailyCalendar = new DailyCalendar("1:20", "14:50");
            SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
            simpleTrigger.RepeatInterval = TimeSpan.FromMilliseconds(10);
            simpleTrigger.RepeatCount = 1;
            DateTimeOffset neverFireTime = DateBuilder.EvenMinuteDateBefore(dailyCalendar.GetTimeRangeStartingTimeUtc(DateTime.Now));
            simpleTrigger.StartTimeUtc = neverFireTime;

            simpleTrigger.ComputeFirstFireTimeUtc(dailyCalendar);
            DateTimeOffset? fireTimeAfter = simpleTrigger.GetNextFireTimeUtc();

            Assert.IsNull(fireTimeAfter);
        }
        public void TestTriggerStates()
        {
            IOperableTrigger trigger = new SimpleTriggerImpl("trigger1", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, DateTimeOffset.Now.AddSeconds(100), DateTimeOffset.Now.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
            trigger.ComputeFirstFireTimeUtc(null);
            Assert.AreEqual(TriggerState.None, fJobStore.GetTriggerState(trigger.Key));
            fJobStore.StoreTrigger(trigger, false);
            Assert.AreEqual(TriggerState.Normal, fJobStore.GetTriggerState(trigger.Key));

            fJobStore.PauseTrigger(trigger.Key);
            Assert.AreEqual(TriggerState.Paused, fJobStore.GetTriggerState(trigger.Key));

            fJobStore.ResumeTrigger(trigger.Key);
            Assert.AreEqual(TriggerState.Normal, fJobStore.GetTriggerState(trigger.Key));

            trigger = fJobStore.AcquireNextTriggers(trigger.GetNextFireTimeUtc().Value.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1))[0];
            Assert.IsNotNull(trigger);
            fJobStore.ReleaseAcquiredTrigger(trigger);
            trigger = fJobStore.AcquireNextTriggers(trigger.GetNextFireTimeUtc().Value.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1))[0];
            Assert.IsNotNull(trigger);
            Assert.AreEqual(0, fJobStore.AcquireNextTriggers(trigger.GetNextFireTimeUtc().Value.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1)).Count);
        }
        public void TestAcquireNextTriggerBatch()
        {
            DateTimeOffset d = DateBuilder.EvenMinuteDateAfterNow();

            IOperableTrigger early = new SimpleTriggerImpl("early", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d, d.AddMilliseconds(5), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger1 = new SimpleTriggerImpl("trigger1", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(200000), d.AddMilliseconds(200005), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger2 = new SimpleTriggerImpl("trigger2", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(200100), d.AddMilliseconds(200105), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger3 = new SimpleTriggerImpl("trigger3", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(200200), d.AddMilliseconds(200205), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger4 = new SimpleTriggerImpl("trigger4", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(200300), d.AddMilliseconds(200305), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger10 = new SimpleTriggerImpl("trigger10", "triggerGroup2", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(500000), d.AddMilliseconds(700000), 2, TimeSpan.FromSeconds(2));

            early.ComputeFirstFireTimeUtc(null);
            trigger1.ComputeFirstFireTimeUtc(null);
            trigger2.ComputeFirstFireTimeUtc(null);
            trigger3.ComputeFirstFireTimeUtc(null);
            trigger4.ComputeFirstFireTimeUtc(null);
            trigger10.ComputeFirstFireTimeUtc(null);
            fJobStore.StoreTrigger(early, false);
            fJobStore.StoreTrigger(trigger1, false);
            fJobStore.StoreTrigger(trigger2, false);
            fJobStore.StoreTrigger(trigger3, false);
            fJobStore.StoreTrigger(trigger4, false);
            fJobStore.StoreTrigger(trigger10, false);

            DateTimeOffset firstFireTime = trigger1.GetNextFireTimeUtc().Value;

            IList<IOperableTrigger> acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 4, TimeSpan.FromSeconds(1));
            Assert.AreEqual(4, acquiredTriggers.Count);
            Assert.AreEqual(early.Key, acquiredTriggers[0].Key);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[1].Key);
            Assert.AreEqual(trigger2.Key, acquiredTriggers[2].Key);
            Assert.AreEqual(trigger3.Key, acquiredTriggers[3].Key);
            fJobStore.ReleaseAcquiredTrigger(early);
              		fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);

            acquiredTriggers = this.fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 5, TimeSpan.FromMilliseconds(1000));
            Assert.AreEqual(5, acquiredTriggers.Count);
            Assert.AreEqual(early.Key, acquiredTriggers[0].Key);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[1].Key);
            Assert.AreEqual(trigger2.Key, acquiredTriggers[2].Key);
            Assert.AreEqual(trigger3.Key, acquiredTriggers[3].Key);
            Assert.AreEqual(trigger4.Key, acquiredTriggers[4].Key);
            fJobStore.ReleaseAcquiredTrigger(early);
            fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);
            fJobStore.ReleaseAcquiredTrigger(trigger4);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 6, TimeSpan.FromSeconds(1));
            Assert.AreEqual(5, acquiredTriggers.Count);
            Assert.AreEqual(early.Key, acquiredTriggers[0].Key);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[1].Key);
            Assert.AreEqual(trigger2.Key, acquiredTriggers[2].Key);
            Assert.AreEqual(trigger3.Key, acquiredTriggers[3].Key);
            Assert.AreEqual(trigger4.Key, acquiredTriggers[4].Key);
            fJobStore.ReleaseAcquiredTrigger(early);
            fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);
            fJobStore.ReleaseAcquiredTrigger(trigger4);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddMilliseconds(1), 5, TimeSpan.Zero);
            Assert.AreEqual(2, acquiredTriggers.Count);
            fJobStore.ReleaseAcquiredTrigger(early);
            fJobStore.ReleaseAcquiredTrigger(trigger1);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddMilliseconds(250), 5, TimeSpan.FromMilliseconds(199));
            Assert.AreEqual(5, acquiredTriggers.Count);
            fJobStore.ReleaseAcquiredTrigger(early);
            fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);
            fJobStore.ReleaseAcquiredTrigger(trigger4);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddMilliseconds(150), 5, TimeSpan.FromMilliseconds(50L));
            Assert.AreEqual(4, acquiredTriggers.Count);
            fJobStore.ReleaseAcquiredTrigger(early);
            fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);
        }
Exemple #8
0
        public void TestAcquireNextTrigger()
        {
            DateTimeOffset d = DateTimeOffset.UtcNow;
            IOperableTrigger trigger1 =
                new SimpleTriggerImpl("trigger1", "triggerGroup1", fJobDetail.Name,
                                  fJobDetail.Group, d.AddSeconds(200),
                                  d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger2 =
                new SimpleTriggerImpl("trigger2", "triggerGroup1", fJobDetail.Name,
                                  fJobDetail.Group, d.AddSeconds(-100),
                                  d.AddSeconds(20), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger3 =
                new SimpleTriggerImpl("trigger1", "triggerGroup2", fJobDetail.Name,
                                  fJobDetail.Group, d.AddSeconds(100),
                                  d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));

            trigger1.ComputeFirstFireTimeUtc(null);
            trigger2.ComputeFirstFireTimeUtc(null);
            trigger3.ComputeFirstFireTimeUtc(null);
            fJobStore.StoreTrigger(trigger1, false);
            fJobStore.StoreTrigger(trigger2, false);
            fJobStore.StoreTrigger(trigger3, false);

            Assert.AreEqual(0, fJobStore.AcquireNextTriggers(d.AddMilliseconds(10), 1, TimeSpan.FromMilliseconds(1)).Count);
            Assert.AreEqual(
                trigger2,
                fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10), 1,
                                              TimeSpan.FromMilliseconds(1))[0]);
            Assert.AreEqual(
                trigger3,
                fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10), 1,
                                              TimeSpan.FromMilliseconds(1))[0]);
            Assert.AreEqual(
                trigger1,
                fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10), 1,
                                              TimeSpan.FromMilliseconds(1))[0]);
            Assert.AreEqual(0,
                            fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10), 1,
                                                          TimeSpan.FromMilliseconds(1)).Count);

            // because of trigger2
            Assert.AreEqual(1, fSignaler.fMisfireCount);

            // release trigger3
            fJobStore.ReleaseAcquiredTrigger(trigger3);
            Assert.AreEqual(
                trigger3,
                fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10), 1,
                                              TimeSpan.FromMilliseconds(1))[0]);
        }
Exemple #9
0
        public void TestAcquireNextTriggerBatch()
        {
            IOperableTrigger trigger1 =
                new SimpleTriggerImpl("trigger1", "triggerGroup1", this.fJobDetail.Name,
                                  this.fJobDetail.Group, DateTimeOffset.UtcNow.AddSeconds(200),
                                  DateTimeOffset.UtcNow.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger2 =
                new SimpleTriggerImpl("trigger2", "triggerGroup1", this.fJobDetail.Name,
                                  this.fJobDetail.Group, DateTimeOffset.UtcNow.AddMilliseconds(200100),
                                  DateTimeOffset.UtcNow.AddMilliseconds(200100), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger3 =
                new SimpleTriggerImpl("trigger3", "triggerGroup1", this.fJobDetail.Name,
                                  this.fJobDetail.Group, DateTimeOffset.UtcNow.AddMilliseconds(200200),
                                  DateTimeOffset.UtcNow.AddMilliseconds(200200), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger4 =
                new SimpleTriggerImpl("trigger4", "triggerGroup1", this.fJobDetail.Name,
                                  this.fJobDetail.Group, DateTimeOffset.UtcNow.AddMilliseconds(200300),
                                  DateTimeOffset.UtcNow.AddMilliseconds(200300), 2, TimeSpan.FromSeconds(2));

            IOperableTrigger trigger10 =
                new SimpleTriggerImpl("trigger10", "triggerGroup2", this.fJobDetail.Name,
                                  this.fJobDetail.Group, DateTimeOffset.UtcNow.AddSeconds(500),
                                  DateTimeOffset.UtcNow.AddSeconds(700), 2, TimeSpan.FromSeconds(2));

            trigger1.ComputeFirstFireTimeUtc(null);
            trigger2.ComputeFirstFireTimeUtc(null);
            trigger3.ComputeFirstFireTimeUtc(null);
            trigger4.ComputeFirstFireTimeUtc(null);
            trigger10.ComputeFirstFireTimeUtc(null);
            this.fJobStore.StoreTrigger(trigger1, false);
            this.fJobStore.StoreTrigger(trigger2, false);
            this.fJobStore.StoreTrigger(trigger3, false);
            this.fJobStore.StoreTrigger(trigger4, false);
            this.fJobStore.StoreTrigger(trigger10, false);

            Assert.AreEqual(3,
                            this.fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10),
                                                               3, TimeSpan.FromSeconds(1)).Count);
            this.fJobStore.ReleaseAcquiredTrigger(trigger1);
            this.fJobStore.ReleaseAcquiredTrigger(trigger2);
            this.fJobStore.ReleaseAcquiredTrigger(trigger3);

            Assert.AreEqual(4,
                            this.fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10),
                                                               4, TimeSpan.FromSeconds(1)).Count);
            this.fJobStore.ReleaseAcquiredTrigger(trigger1);
            this.fJobStore.ReleaseAcquiredTrigger(trigger2);
            this.fJobStore.ReleaseAcquiredTrigger(trigger3);
            this.fJobStore.ReleaseAcquiredTrigger(trigger4);

            Assert.AreEqual(4,
                            this.fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(10),
                                                               5, TimeSpan.FromSeconds(1)).Count);
            this.fJobStore.ReleaseAcquiredTrigger(trigger1);
            this.fJobStore.ReleaseAcquiredTrigger(trigger2);
            this.fJobStore.ReleaseAcquiredTrigger(trigger3);
            this.fJobStore.ReleaseAcquiredTrigger(trigger4);

            Assert.AreEqual(1,
                            this.fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddSeconds(0),
                                                               5, TimeSpan.Zero).Count);
            this.fJobStore.ReleaseAcquiredTrigger(trigger1);

            Assert.AreEqual(2,
                            this.fJobStore.AcquireNextTriggers(trigger1.GetNextFireTimeUtc().Value.AddMilliseconds(150),
                                                               5, TimeSpan.Zero).Count);
            this.fJobStore.ReleaseAcquiredTrigger(trigger1);
            this.fJobStore.ReleaseAcquiredTrigger(trigger2);
        }
        public void TestAcquireNextTriggerBatch()
        {
            DateTimeOffset d = DateTimeOffset.UtcNow.Subtract(TimeSpan.FromSeconds(1));

            IOperableTrigger early = new SimpleTriggerImpl("early", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d, d.AddMilliseconds(5), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger1 = new SimpleTriggerImpl("trigger1", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(200000), d.AddMilliseconds(200005), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger2 = new SimpleTriggerImpl("trigger2", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(210000), d.AddMilliseconds(210005), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger3 = new SimpleTriggerImpl("trigger3", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(220000), d.AddMilliseconds(220005), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger4 = new SimpleTriggerImpl("trigger4", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(230000), d.AddMilliseconds(230005), 2, TimeSpan.FromSeconds(2));
            IOperableTrigger trigger10 = new SimpleTriggerImpl("trigger10", "triggerGroup2", fJobDetail.Name, fJobDetail.Group, d.AddMilliseconds(500000), d.AddMilliseconds(700000), 2, TimeSpan.FromSeconds(2));

            early.ComputeFirstFireTimeUtc(null);
            early.MisfireInstruction = MisfireInstruction.IgnoreMisfirePolicy;

            trigger1.ComputeFirstFireTimeUtc(null);
            trigger2.ComputeFirstFireTimeUtc(null);
            trigger3.ComputeFirstFireTimeUtc(null);
            trigger4.ComputeFirstFireTimeUtc(null);
            trigger10.ComputeFirstFireTimeUtc(null);
            fJobStore.StoreTrigger(early, false);
            fJobStore.StoreTrigger(trigger1, false);
            fJobStore.StoreTrigger(trigger2, false);
            fJobStore.StoreTrigger(trigger3, false);
            fJobStore.StoreTrigger(trigger4, false);
            fJobStore.StoreTrigger(trigger10, false);

            DateTimeOffset firstFireTime = trigger1.GetNextFireTimeUtc().Value;

            IList<IOperableTrigger> acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 4, TimeSpan.FromSeconds(1));
            Assert.AreEqual(1, acquiredTriggers.Count);
            Assert.AreEqual(early.Key, acquiredTriggers[0].Key);
            fJobStore.ReleaseAcquiredTrigger(early);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 4, TimeSpan.FromMilliseconds(205000));
            Assert.AreEqual(2, acquiredTriggers.Count);
            Assert.AreEqual(early.Key, acquiredTriggers[0].Key);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[1].Key);
            fJobStore.ReleaseAcquiredTrigger(early);
            fJobStore.ReleaseAcquiredTrigger(trigger1);

            fJobStore.RemoveTrigger(early.Key);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 5, TimeSpan.FromMilliseconds(100000));
            Assert.AreEqual(4, acquiredTriggers.Count);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[0].Key);
            Assert.AreEqual(trigger2.Key, acquiredTriggers[1].Key);
            Assert.AreEqual(trigger3.Key, acquiredTriggers[2].Key);
            Assert.AreEqual(trigger4.Key, acquiredTriggers[3].Key);
            fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);
            fJobStore.ReleaseAcquiredTrigger(trigger4);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 6, TimeSpan.FromMilliseconds(100000));

            Assert.AreEqual(4, acquiredTriggers.Count);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[0].Key);
            Assert.AreEqual(trigger2.Key, acquiredTriggers[1].Key);
            Assert.AreEqual(trigger3.Key, acquiredTriggers[2].Key);
            Assert.AreEqual(trigger4.Key, acquiredTriggers[3].Key);

            fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);
            fJobStore.ReleaseAcquiredTrigger(trigger4);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddMilliseconds(1), 5, TimeSpan.Zero);
            Assert.AreEqual(1, acquiredTriggers.Count);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[0].Key);

            fJobStore.ReleaseAcquiredTrigger(trigger1);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddMilliseconds(250), 5, TimeSpan.FromMilliseconds(19999L));
            Assert.AreEqual(2, acquiredTriggers.Count);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[0].Key);
            Assert.AreEqual(trigger2.Key, acquiredTriggers[1].Key);

            fJobStore.ReleaseAcquiredTrigger(early);
            fJobStore.ReleaseAcquiredTrigger(trigger1);
            fJobStore.ReleaseAcquiredTrigger(trigger2);
            fJobStore.ReleaseAcquiredTrigger(trigger3);

            acquiredTriggers = fJobStore.AcquireNextTriggers(firstFireTime.AddMilliseconds(150), 5, TimeSpan.FromMilliseconds(5000L));
            Assert.AreEqual(1, acquiredTriggers.Count);
            Assert.AreEqual(trigger1.Key, acquiredTriggers[0].Key);
            fJobStore.ReleaseAcquiredTrigger(trigger1);
        }