public void EnqueuesAtScheduledTime()
{
var job = new Job1();
FakeClock.Setup();
FakeClock.Now = new DateTimeOffset(2018, 1, 1, 0, 0, 0, TimeSpan.Zero);
var enqueueAt = FakeClock.Now + TimeSpan.FromMilliseconds(10);
Action <IJob, Exception> errorHandler = (j, e) => { };
sut.OnApplicationStarted();
sut.ScheduleJob(job, enqueueAt, errorHandler);
bool enqueued = false;
workerProcess.When(x => x.EnqueueJob(job, errorHandler)).Do(ci => enqueued = true);
enqueued.Should().BeFalse();
FakeClock.Now = new DateTimeOffset(2018, 1, 1, 0, 0, 0, 10, TimeSpan.Zero);
while (!enqueued)
{
Thread.Yield();
}
enqueued.Should().BeTrue();
sut.OnApplicationStopping();
}
public void AtomicDataResource_Allocate_Deallocate_InJob()
{
const int MAX = 5000;
var resource = new AtomicFloatResource(MAX, Allocator.Persistent);
var holder = new NativeArray <AtomicFloat>(MAX, Allocator.Persistent);
var job0 = new Job0()
{
resource = resource,
holder = holder,
};
job0.Schedule(MAX, 32).Complete();
Assert.AreEqual(MAX, resource.getCountInUse());
var job1 = new Job1()
{
resource = resource,
holder = holder,
};
job1.Schedule(MAX, 32).Complete();
Assert.AreEqual(0, resource.getCountInUse());
holder.Dispose();
resource.Dispose();
}
public async Task EnqeueJobAsync_Immediate()
{
var job = new Job1();
await sut.EnqeueJobAsync(job, null);
workerProcess.Received(1).EnqueueJob(job, Arg.Any <Action <IJob, Exception> >());
}
public void EnqueueJob_RunsTask()
{
var job = new Job1();
sut.OnApplicationStarted();
sut.EnqueueJob(job, (j, e) => { });
sut.OnApplicationStopping();
jobRunner.Received(1).RunJobAsync(job, CancellationToken.None);
}
public async Task EnqeueJobAsync_Delayed()
{
FakeClock.Setup();
var job = new Job1();
await sut.EnqeueJobAsync(job, TimeSpan.FromSeconds(5));
var expectedScheduleTime = FakeClock.Now + TimeSpan.FromSeconds(5);
schedulerProcess.Received(1).ScheduleJob(job, expectedScheduleTime, Arg.Any <Action <IJob, Exception> >());
}
public void NativeLimitedCounter_OverTheNumber()
{
const int MAX = 1000;
var counter = new NativeLimitedCounter(Allocator.Persistent);
var job = new Job1();
job.counter = counter;
job.maximum = MAX;
job.Schedule(MAX * 2, 32).Complete();
Assert.AreEqual(MAX, counter.Count);
counter.Dispose();
}
void JobTest()
{
//NativeArray<int> nativeArray = new NativeArray<int>(1, Allocator.TempJob);
//Job1 tempJob = new Job1() { i = 6, j = 7, result = nativeArray };
Job1 tempJob = new Job1()
{
i = 6, j = 7
};
JobHandle jobHandle = tempJob.Schedule();
jobHandle.Complete();
Debug.Log(tempJob.result);
//nativeArray.Dispose();
}
public void CallsErrorHandler()
{
var job = new Job1();
var exception = new Exception("Test exception");
jobRunner.RunJobAsync(job, CancellationToken.None).Throws(exception);
var errorHandler = Substitute.For <Action <IJob, Exception> >();
sut.OnApplicationStarted();
sut.EnqueueJob(job, errorHandler);
sut.OnApplicationStopping();
errorHandler.Received(1).Invoke(job, exception);
}
void MultiJobTest()
{
float tempStart = Time.realtimeSinceStartup;
NativeList <JobHandle> nativeList = new NativeList <JobHandle>(Allocator.TempJob);
for (int i = 0; i < 10; ++i)
{
Job1 tempJob = new Job1()
{
i = 6, j = 7
};
nativeList.Add(tempJob.Schedule());
}
JobHandle.CompleteAll(nativeList);
nativeList.Dispose();
float tempSumTime = Time.realtimeSinceStartup - tempStart;
Debug.Log("ThreadSumTime: " + tempSumTime);
}
public void ThrottlesTasks()
{
schedulerConfiguration.WorkerTaskParallelism = 2;
bool job1Finish = false;
bool job2Finish = false;
var job1 = new Job1();
var job2 = new Job1();
var job3 = new Job1();
async Task Job1()
{
while (!job1Finish)
{
await Task.Yield();
}
}
Lazy <Task> job1Task = new Lazy <Task>(Job1);
async Task Job2()
{
while (!job2Finish)
{
await Task.Yield();
}
}
Lazy <Task> job2Task = new Lazy <Task>(Job2);
async Task Job3()
{
job1Task.Value.IsCompleted.Should().BeTrue();
}
Lazy <Task> job3Task = new Lazy <Task>(Job3);
jobRunner.RunJobAsync(job1, CancellationToken.None).Returns(ci => job1Task.Value);
jobRunner.RunJobAsync(job2, CancellationToken.None).Returns(ci => job2Task.Value);
jobRunner.RunJobAsync(job3, CancellationToken.None).Returns(ci => job3Task.Value);
sut.OnApplicationStarted();
sut.EnqueueJob(job1, (j, e) => { });
sut.EnqueueJob(job2, (j, e) => { });
while (!job1Task.IsValueCreated || !job2Task.IsValueCreated)
{
Thread.Yield();
}
sut.EnqueueJob(job3, (j, e) => { });
Thread.Yield();
job3Task.IsValueCreated.Should().BeFalse();
job1Finish = true;
job2Finish = true;
sut.OnApplicationStopping();
job3Task.Value.IsCompleted.Should().BeTrue();
}
public async Task ReschedulesOnError(int configMaxAttemptCount)
{
schedulerConfiguration.HandleAttemptCount = configMaxAttemptCount;
FakeClock.Setup();
FakeClock.Now = new DateTimeOffset(2019, 1, 1, 0, 0, 0, TimeSpan.Zero);
var job = new Job1();
Action <IJob, Exception> errorHandler = null;
workerProcess.When(x => x.EnqueueJob(job, Arg.Any <Action <IJob, Exception> >()))
.Do(ci =>
{
errorHandler = ci.ArgAt <Action <IJob, Exception> >(1);
});
DateTimeOffset scheduleTime = DateTimeOffset.MinValue;
schedulerProcess.When(x => x.ScheduleJob(job, Arg.Any <DateTimeOffset>(), Arg.Any <Action <IJob, Exception> >()))
.Do(ci =>
{
scheduleTime = ci.ArgAt <DateTimeOffset>(1);
errorHandler = ci.ArgAt <Action <IJob, Exception> >(2);
});
await sut.EnqeueJobAsync(job, null);
int Pow(int bas, int exp)
{
return(Enumerable
.Repeat(bas, exp)
.Aggregate(1, (a, b) => a * b));
}
for (int numberAttempts = 1; numberAttempts <= configMaxAttemptCount; numberAttempts++)
{
errorHandler.Should().NotBeNull();
var currentErrorHandler = errorHandler;
errorHandler = null;
var exception = new Exception();
currentErrorHandler(job, exception);
schedulerProcess.Received(Math.Min(numberAttempts, configMaxAttemptCount - 1))
.ScheduleJob(job, Arg.Any <DateTimeOffset>(), Arg.Any <Action <IJob, Exception> >());
if (numberAttempts != configMaxAttemptCount) // should retry
{
int delayMultiplier = Pow(schedulerConfiguration.HandleRetryTimeoutMultiplier, numberAttempts - 1);
long minDelay = schedulerConfiguration.MinHandleRetryTimeoutStep.Ticks * delayMultiplier;
long maxDelay = schedulerConfiguration.MaxHandleRetryTimeoutStep.Ticks * delayMultiplier;
scheduleTime.Should().BeOnOrAfter(FakeClock.Now + TimeSpan.FromTicks(minDelay));
scheduleTime.Should().BeOnOrBefore(FakeClock.Now + TimeSpan.FromTicks(maxDelay));
}
}
workerProcess.Received(1).EnqueueJob(job, Arg.Any <Action <IJob, Exception> >()); // only once
}
private static void Main(string[] args)
{
IJob iJob = new Job1(); // Valid
IRepository <IJob> repo = new Repository <Job1>(); // Also valid
}
public async Task <ActionResult> Add(int?p1Count, int?p2Count, int?p3Count, int?p4Count, int?p5Count)
{
var appID = ConfigurationManager.AppSettings["ApplicationID"];
if (string.IsNullOrWhiteSpace(appID))
{
appID = "Shift.Demo.MVC";
}
var message = "";
if (p1Count > 0)
{
for (var i = 0; i < p1Count; i++)
{
var job1 = new Job1();
var progress = new SynchronousProgress <ProgressInfo>(); //placeholder to be replaced by Server progress object
var cancelToken = (new CancellationTokenSource()).Token; //placeholder to be replaced by Server token
var pauseToken = (new PauseTokenSource()).Token;
await jobClient.AddAsync(appID, () => job1.Start("Hello World!", progress, cancelToken, pauseToken));
}
message += p1Count + " - Job1 added to queue. <br/>";
}
if (p2Count > 0)
{
for (var i = 0; i < p2Count; i++)
{
var job2 = new Job2();
var progress = new SynchronousProgress <ProgressInfo>();
var cancelToken = (new CancellationTokenSource()).Token; //placeholder to be replaced by Server token
var pauseToken = (new PauseTokenSource()).Token;
await jobClient.AddAsync(appID, () => job2.Start(progress, 1, cancelToken, pauseToken));
}
message += p2Count + " - Job2 added to queue. <br/>";
}
if (p3Count > 0)
{
var simpleList = new List <int>();
for (var i = 1; i <= 100; i++)
{
simpleList.Add(i);
}
for (var i = 0; i < p3Count; i++)
{
var job3 = new Job3();
var progress = new SynchronousProgress <ProgressInfo>();
await jobClient.AddAsync(appID, () => job3.Start(progress, simpleList));
}
message += p3Count + " - Job3 added to queue. <br/>";
}
if (p4Count > 0)
{
var complexList = new List <TestData>();
for (var i = 1; i <= 100; i++)
{
var newData = new TestData();
newData.MyNumber = i;
newData.MyString = "mystring " + i;
complexList.Add(newData);
}
for (var i = 0; i < p4Count; i++)
{
var job4 = new Job4();
var progress = new SynchronousProgress <ProgressInfo>();
var cancelToken = (new CancellationTokenSource()).Token; //placeholder to be replaced by Server token
var pauseToken = (new PauseTokenSource()).Token;
await jobClient.AddAsync(appID, () => job4.Start(progress, complexList, cancelToken, pauseToken));
}
message += p4Count + " - Job4 added to queue. <br/>";
}
if (p5Count > 0)
{
var simpleList = new List <int>();
for (var i = 1; i <= 100; i++)
{
simpleList.Add(i);
}
for (var i = 0; i < p5Count; i++)
{
var job5 = new Job5();
var cancelToken = (new CancellationTokenSource()).Token; //placeholder to be replaced by Server token
var pauseToken = (new PauseTokenSource()).Token;
var progress = new SynchronousProgress <ProgressInfo>();
await jobClient.AddAsync(appID, () => job5.StartAsync(progress, simpleList, cancelToken, pauseToken));
}
message += p5Count + " - Job5 added to queue. <br/>";
}
ViewBag.Message = message;
return(View("Index"));
}
