public void Test_CompareToPositive() { Job job1 = new Job(new User("Test", ""), 100, 1, s => 0); Job job2 = new Job(new User("Test", ""), 100, 2, s => 0); job1.Process(new String[] { " not empty" }); Assert.AreEqual(1, job1.CompareTo(job2)); }
/// <summary> /// Add a log to the database /// </summary> /// <param name="job">The job affecting the log</param> /// <param name="time">The timestamp for the log</param> public void AddLog(Job job, DateTime time) { if (job == null) throw new ArgumentNullException("job was null"); if (job.User == null) throw new ArgumentNullException("job.User was null"); if (job.JobId == 0) throw new ArgumentNullException("job.JobId was 0"); if (time == null) throw new ArgumentNullException("time was null"); lock (_objectLock) { var dbContext = new TaskManagerModelContainer(); Debug.WriteLine("1 - Inside Log.AddJob(); Event: " + job.StateString + "; jobId: " + job.JobId ); Log log = new Log(); log.Event = job.StateString; log.Time = time; log.JobId = job.JobId; dbContext.Logs.AddObject(log); Debug.WriteLine("2 - Inside Log.AddJob(); State: " + job.StateString + "; jobId: " + job.JobId + "; logId: " + log.LogId); dbContext.SaveChanges(); } }
/// <summary> /// Add a job to the database /// </summary> /// <param name="job">The job to add</param> public void AddJob(Job job) { if (job == null) throw new ArgumentNullException("job was null"); if(job.User == null) throw new ArgumentNullException("job.User was null"); Debug.WriteLine("1 - Inside AddJob(); jobId: " + job.JobId); if (job.UserId == 0) { AddUser(job.User); } else if (job.JobId == 0) { lock (_objectLock) { _dbContext.Jobs.AddObject(job); Debug.WriteLine("2 - Inside AddJob(); jobId: " + job.JobId); _dbContext.SaveChanges(); } } }
public void Test_AddJob() { User user = new User("Test User", "Test Password"); _tmDAO.AddUser(user); Job job = new Job(user, 100, 5, s => 50); _tmDAO.AddJob(job); }
/// <summary> /// Processes the job. /// </summary> /// <param name="job">The job.</param> public void ProcessJob(Job job) { Thread t = new Thread(new ThreadStart(() => { IncrementActiveCpu(job.CPUs); Thread.Sleep(job.TimeExpected + _runningTimeDiscrepency.Next(-200, 200)); DecrementActiveCpu(job.CPUs); })); t.Start(); }
public void EventHandlerRunningTest() { Job job = new Job(new User("test", ""), 1000, 1, s => 0); _b.JobCancelled += delegate { throw new Exception(); }; _b.SubmitJob(job); try { _b.ExecuteAll(); Assert.Fail(); } catch (Exception) { } }
public void CancelJobTest() { User user = new User("test", ""); Job job = new Job(user, 100, 1, s => 0); _b.SubmitJob(job); //If job does anything else than runs or cancels... job.JobDone += delegate { Assert.Fail();}; job.JobFailed += delegate { Assert.Fail(); }; job.JobTerminated += delegate { Assert.Fail(); }; _b.CancelJob(job); Assert.AreEqual(job.State, JobState.Cancelled); }
public void Test_PopJobSequence() { Scheduler s = new Scheduler(3, 10); Func<string[], int> funk = st => 10; // Check the sequence og jobs returned Job shortJob = new Job(new User("test", ""), 100, 5, funk); Job longJob = new Job(new User("test", ""), 1000, 5, funk); Job veryLongJob = new Job(new User("test", ""), 2500, 5, funk); // short, long, verylong AssertSequence(s, shortJob, longJob, veryLongJob); // long, short, verylong AssertSequence(s, longJob, shortJob, veryLongJob); // long, verylong, short AssertSequence(s, longJob, veryLongJob, shortJob); // short, verylong, long AssertSequence(s, shortJob, veryLongJob, longJob); // verylong, short, long AssertSequence(s, veryLongJob, shortJob, longJob); // verylong, long, short AssertSequence(s, veryLongJob, longJob, shortJob); }
public void Test_AddJob() { Scheduler s = new Scheduler(3, 10); // Add legal jobs with the three types: Short, Long, VeryLong Func<string[], int> funk = st => 10; Job shortJob = new Job(new User("test", ""), 100, 5, funk); Job longJob = new Job(new User("test", ""), 1000, 5, funk); Job veryLongJob = new Job(new User("test", ""), 2500, 5, funk); s.AddJob(shortJob); s.AddJob(longJob); s.AddJob(veryLongJob); Assert.AreEqual(3, s.JobsInSequence.Count); // Add 4000 jobs of varying type for (uint i = 0; i < 4000; i++) { s.AddJob(new Job(new User("test", ""), i + 100, 5, funk)); } Assert.AreEqual(4003, s.JobsInSequence.Count); }
public void Test_CompareToTransitive() { Job job1 = new Job(new User("Test", ""), 100, 1, s => 0); Job job2 = new Job(new User("Test", ""), 100, 2, s => 0); Job job3 = new Job(new User("Test", ""), 100, 3, s => 0); Assert.AreEqual(0, job1.CompareTo(job2)); Assert.AreEqual(0, job2.CompareTo(job3)); Assert.AreEqual(0, job1.CompareTo(job3)); }
public void Test_CompareZero() { Job job1 = new Job(new User("Test", ""), 100, 1, s => 0); Job job2 = new Job(new User("Test", ""), 100, 2, s => 0); Assert.AreEqual(0, job1.Compare(job2, job1)); }
/// <summary> /// Store the job, to let the owner access it later on /// </summary> /// <param name="job">The job to store</param> #if DEBUG internal void StoreJob(Job job)
private void StoreJob(Job job) #endif { Contract.Requires(job != null); Contract.Requires(job.User != null); Contract.Assume(!_jobs.ContainsKey(job.User) || _jobs[job.User] != null); lock (_tmDAOLock) _tmDAO.AddJob(job); lock (_activityLock) { if (!_jobs.ContainsKey(job.User)) _jobs.Add(job.User, new List<Job>()); _jobs[job.User].Add(job); } }
public void StoreJobTest() { int expectedTime = 100; //Milliseconds User owner = new User("test", ""); Job job = new Job(owner, (uint)expectedTime, 1, s => 0); _b.SubmitJob(job); IEnumerable<Job> jobs = _b.GetJobs(owner); if(!jobs.Contains(job)) Assert.Fail("The job was not stored!"); }
/// <summary> /// Cancel a waiting job /// </summary> /// <param name="job">The job to remove from the queue</param> public void CancelJob(Job job) { Contract.Requires(job != null); Contract.Requires(job.State == JobState.Waiting); lock (_stateLock) { job.CancelJob(); EventHandler handler = JobCancelled; if (handler != null) handler(job, EventArgs.Empty); } }
private void AddJobs(uint amount) { for (uint index = 0; index < amount; index++) { uint time = (uint)_random.Next(100, 5000); int cpus = _random.Next(1, 6); Job job = new Job(_user, time, cpus, s => 0); _jobs.Enqueue(job); } _jobsAdded += amount; }
/****************************************************************************************** * The following methods relate to events * ****************************************************************************************/ /// <summary> /// Subscribes from all event handlers related to parameter job /// </summary> /// <param name="job">The job to subscribe to</param> private void Subscribe(Job job) { job.JobRunning += OnJobRunning; job.JobCancelled += OnJobCancelled; job.JobTerminated += OnJobTerminated; job.JobFailed += OnJobFailed; job.JobDone += OnJobDone; }
/// <summary> /// Helper method. Checks that the sequence of jobs returned is in the same order as they were added /// </summary> /// <param name="s">The scheduler</param> /// <param name="first">Job to add first</param> /// <param name="second">Job to add second</param> /// <param name="third">Job to add last</param> private void AssertSequence(Scheduler s, Job first, Job second, Job third) { s.AddJob(first); s.AddJob(second); s.AddJob(third); Assert.AreEqual(first, s.PopJob()); Assert.AreEqual(second, s.PopJob()); Assert.AreEqual(third, s.PopJob()); }
/// <summary> /// Unsubscribes from all event handlers related to parameter job /// </summary> /// <param name="job">The job to unsubscribe to</param> private void Unsubscribe(Job job) { job.JobRunning -= OnJobRunning; job.JobCancelled -= OnJobCancelled; job.JobTerminated -= OnJobTerminated; job.JobFailed -= OnJobFailed; job.JobDone -= OnJobDone; }
public void Test_RemoveJobNoTInScheduler() { Scheduler s = new Scheduler(3, 10); Job phonyJob = new Job(new User("test", ""), 2500, 5, st => 10); try { s.RemoveJob(phonyJob); Assert.Fail("It was possible to remove a job not in the scheduler"); } catch (ArgumentException) { // This is good } }
public void Test_RemoveJobInScheduler() { Scheduler s = new Scheduler(3, 10); Job job = new Job(new User("test", ""), 2000, 5, st => 10); s.AddJob(job); // Remove a job in the scheduler s.RemoveJob(job); Assert.AreEqual(0, s.JobsInSequence.Count); }
public void GetJobsTest() { User owner = new User("test", ""); Job job = new Job(owner, 1000, 1, s => 0); _b.SubmitJob(job); _b.ExecuteAll(); IEnumerable<Job> jobs = _b.GetJobs(owner); if (!jobs.Contains(job)) Assert.Fail(); }
public void Test_ProcessEmptyArgs() { Job job = new Job(new User("Test", ""), 100, 1, s => 0); job.Process(new String[] { }); }
public void FinishCurrentJobsTest() { uint numberOfJobs = 5; List<Job> jobs = new List<Job>((int)numberOfJobs); uint counter = 0; Job job; for (int index = 0; index < numberOfJobs; index++) { job = new Job(new User("test", ""), 100, 1, s => 0) { Description = "Job " + index }; job.JobDone += delegate { counter++; }; jobs.Add(job); _b.SubmitJob(job); } _b.JobDone += delegate { if (counter == numberOfJobs) Assert.AreEqual(BSStatus.Stopped, _b.Status); }; _b.ExecuteAll(); _b.FinishCurrentJobs(); }
public void Test_ProcessNullArgs() { Job job = new Job(new User("Test", ""), 100, 1, s => 0); try { job.Process(null); } catch { // This is good } }
/// <summary> /// Terminate a running job /// </summary> /// <param name="job">The job to terminate</param> public void TerminateJob(Job job) { Contract.Requires(job != null); Contract.Requires(job.State == JobState.Running); Contract.Ensures(job.State == JobState.Terminated); lock (_activityLock) { job.Terminate(); } }
public void Test_CompareToSymmetric() { Job job1 = new Job(new User("Test", ""), 100, 1, s => 0); Job job2 = new Job(new User("Test", ""), 100, 2, s => 0); Assert.AreEqual(0, job1.CompareTo(job2)); Assert.AreEqual(0, job2.CompareTo(job1)); }
public void SubmitJobTest() { Job job = new Job(new User("test", ""), 1000, 1, s => 0); _b.SubmitJob(job); IEnumerable<Job> list = _b.GetJobs(job.User); Assert.IsTrue(list.Contains(job)); }
/// <summary> /// Add job to queue /// </summary> /// <param name="job">The job to be added</param> public void SubmitJob(Job job) { Contract.Requires(job != null); Contract.Requires(job.User != null); StoreJob(job); lock (_schedulerLock) _scheduler.AddJob(job); EventHandler handler = JobSubmitted; if (handler != null) handler(job, EventArgs.Empty); StartJobFromEvent(); }
public void ExecuteAllTest() { //Also tests StartNextJob() uint numbOfJobs = 100; //Using the event from this job to see when all jobs are handled Job lastJob = null; User owner = new User("test", ""); for (uint index = 0; index < numbOfJobs; index++) { Job job = new Job(owner, 100, 1, s => 0); _b.SubmitJob(job); lastJob = job; } IEnumerable jobs = _b.GetJobs(owner); uint counterDone = 0; uint counterUndone = 0; foreach (Job j in jobs) if (JobState.Done == j.State) counterDone++; else counterUndone++; //No jobs should be done Assert.AreEqual((uint)0, counterDone); Assert.AreEqual(numbOfJobs, counterUndone); _b.ExecuteAll(); //Will let the test try to finish for 5 second, which should be more than enough! int counter = 0; while (_b.Status != BSStatus.Ready) { if (counter++ > 50) Assert.Fail("Benchmark was unable to reach the state: Ready"); Thread.Sleep(100); } counterDone = 0; counterUndone = 0; foreach (Job j in jobs) if (j.State == JobState.Done) counterDone++; else counterUndone++; Assert.AreEqual(numbOfJobs, counterDone); Assert.AreEqual((uint)0, counterUndone); }