public void ShouldReturnCorrectWhenCallABC()
{
Assert.AreEqual(target.CallABC(), 3);
}
public void ShouldReturnCorrectWhenCallAB()
{
Assert.AreEqual(target.InvokeNonPublicMethod <int>("CallAB", (object[])null), 2);
}
public void AzureStorageUtils_TablePropertyShouldBeSanitized()
{
var tableProperty = "/A\\C#?";
Assert.AreEqual("_A_C__", AzureStorageUtils.SanitizeTableProperty(tableProperty));
}
public void ShouldReturnCorrectWhenCallAB()
{
Assert.AreEqual(target.CallBaseAB(), 2);
}
public void DistributionCentralMomentIntegral()
{
foreach (ContinuousDistribution distribution in distributions)
{
foreach (int n in TestUtilities.GenerateIntegerValues(2, 24, 8))
{
// get the predicted central moment
double C = distribution.CentralMoment(n);
// don't try to integrate infinite moments
if (Double.IsInfinity(C) || Double.IsNaN(C))
{
continue;
}
if (C == 0.0)
{
continue;
}
IntegrationSettings settings = new IntegrationSettings();
if (C == 0.0)
{
// if moment is zero, use absolute precision
settings.AbsolutePrecision = TestUtilities.TargetPrecision;
settings.RelativePrecision = 0.0;
}
else
{
// if moment in non-zero, use relative precision
settings.AbsolutePrecision = 0.0;
settings.RelativePrecision = TestUtilities.TargetPrecision;
}
// do the integral
double m = distribution.Mean;
Func <double, double> f = delegate(double x) {
return(distribution.ProbabilityDensity(x) * MoreMath.Pow(x - m, n));
};
try {
double CI = FunctionMath.Integrate(f, distribution.Support, settings).Value;
Console.WriteLine("{0} {1} {2} {3}", distribution.GetType().Name, n, C, CI);
if (C == 0.0)
{
Assert.IsTrue(Math.Abs(CI) < TestUtilities.TargetPrecision);
}
else
{
double e = TestUtilities.TargetPrecision;
// reduce required precision, because some distributions (e.g. Kolmogorov, Weibull)
// have no analytic expressions for central moments, which must therefore be
// determined via raw moments and are thus subject to cancelation error
// can we revisit this later?
if (distribution is WeibullDistribution)
{
e = Math.Sqrt(Math.Sqrt(e));
}
if (distribution is KolmogorovDistribution)
{
e = Math.Sqrt(e);
}
if (distribution is KuiperDistribution)
{
e = Math.Sqrt(Math.Sqrt(e));
}
if (distribution is TriangularDistribution)
{
e = Math.Sqrt(e);
}
Assert.IsTrue(TestUtilities.IsNearlyEqual(C, CI, e));
}
} catch (NonconvergenceException) {
Console.WriteLine("{0} {1} {2} {3}", distribution.GetType().Name, n, C, "NC");
// deal with these later; they are integration problems, not distribution problems
}
}
}
}
private async Task SendAndReceiveFromQueueAdapter(IQueueAdapterFactory adapterFactory, IProviderConfiguration config)
{
Guid agentId = Guid.NewGuid();
IQueueAdapter adapter = await adapterFactory.CreateAdapter();
IQueueAdapterCache cache = adapterFactory.GetQueueAdapterCache();
// Create receiver per queue
IStreamQueueMapper mapper = adapterFactory.GetStreamQueueMapper();
Dictionary <QueueId, IQueueAdapterReceiver> receivers = mapper.GetAllQueues().ToDictionary(queueId => queueId, adapter.CreateReceiver);
Dictionary <QueueId, IQueueCache> caches = mapper.GetAllQueues().ToDictionary(queueId => queueId, cache.CreateQueueCache);
await Task.WhenAll(receivers.Values.Select(receiver => receiver.Initialize(TimeSpan.FromSeconds(5))));
// test using 2 streams
Guid streamId1 = Guid.NewGuid();
Guid streamId2 = Guid.NewGuid();
int receivedBatches = 0;
var streamsPerQueue = new ConcurrentDictionary <QueueId, HashSet <IStreamIdentity> >();
// reader threads (at most 2 active queues because only two streams)
var work = new List <Task>();
foreach (KeyValuePair <QueueId, IQueueAdapterReceiver> receiverKvp in receivers)
{
QueueId queueId = receiverKvp.Key;
var receiver = receiverKvp.Value;
var qCache = caches[queueId];
Task task = Task.Factory.StartNew(() =>
{
while (receivedBatches < NumBatches)
{
var messages = receiver.GetQueueMessagesAsync(CloudQueueMessage.MaxNumberOfMessagesToPeek).Result.ToArray();
if (!messages.Any())
{
continue;
}
foreach (AzureQueueBatchContainer message in messages.Cast <AzureQueueBatchContainer>())
{
streamsPerQueue.AddOrUpdate(queueId,
id => new HashSet <IStreamIdentity> {
new TestStreamIdentity {
Guid = message.StreamGuid
}
},
(id, set) =>
{
set.Add(new TestStreamIdentity {
Guid = message.StreamGuid
});
return(set);
});
output.WriteLine("Queue {0} received message on stream {1}", queueId,
message.StreamGuid);
Assert.AreEqual(NumMessagesPerBatch / 2, message.GetEvents <int>().Count(),
"Half the events were ints");
Assert.AreEqual(NumMessagesPerBatch / 2, message.GetEvents <string>().Count(),
"Half the events were strings");
}
Interlocked.Add(ref receivedBatches, messages.Length);
qCache.AddToCache(messages);
}
});
work.Add(task);
}
// send events
List <object> events = CreateEvents(NumMessagesPerBatch);
work.Add(Task.Factory.StartNew(() => Enumerable.Range(0, NumBatches)
.Select(i => i % 2 == 0 ? streamId1 : streamId2)
.ToList()
.ForEach(streamId =>
adapter.QueueMessageBatchAsync(streamId, streamId.ToString(),
events.Take(NumMessagesPerBatch).ToArray(), null, RequestContext.Export()).Wait())));
await Task.WhenAll(work);
// Make sure we got back everything we sent
Assert.AreEqual(NumBatches, receivedBatches);
// check to see if all the events are in the cache and we can enumerate through them
StreamSequenceToken firstInCache = new EventSequenceToken(0);
foreach (KeyValuePair <QueueId, HashSet <IStreamIdentity> > kvp in streamsPerQueue)
{
var receiver = receivers[kvp.Key];
var qCache = caches[kvp.Key];
foreach (IStreamIdentity streamGuid in kvp.Value)
{
// read all messages in cache for stream
IQueueCacheCursor cursor = qCache.GetCacheCursor(streamGuid, firstInCache);
int messageCount = 0;
StreamSequenceToken tenthInCache = null;
StreamSequenceToken lastToken = firstInCache;
while (cursor.MoveNext())
{
Exception ex;
messageCount++;
IBatchContainer batch = cursor.GetCurrent(out ex);
output.WriteLine("Token: {0}", batch.SequenceToken);
Assert.IsTrue(batch.SequenceToken.CompareTo(lastToken) >= 0, "order check for event {0}", messageCount);
lastToken = batch.SequenceToken;
if (messageCount == 10)
{
tenthInCache = batch.SequenceToken;
}
}
output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid);
Assert.AreEqual(NumBatches / 2, messageCount);
Assert.IsNotNull(tenthInCache);
// read all messages from the 10th
cursor = qCache.GetCacheCursor(streamGuid, tenthInCache);
messageCount = 0;
while (cursor.MoveNext())
{
messageCount++;
}
output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid);
const int expected = NumBatches / 2 - 10 + 1; // all except the first 10, including the 10th (10 + 1)
Assert.AreEqual(expected, messageCount);
}
}
}
private static void CheckRuntimeContext(ISchedulingContext context)
{
Assert.IsNotNull(RuntimeContext.Current, "Runtime context should not be null");
Assert.IsNotNull(RuntimeContext.Current.ActivationContext, "Activation context should not be null");
Assert.AreEqual(context, RuntimeContext.Current.ActivationContext, "Activation context");
}
public void Sched_Task_SchedulingContext()
{
UnitTestSchedulingContext context = new UnitTestSchedulingContext();
orleansTaskScheduler = TestInternalHelper.InitializeSchedulerForTesting(context);
ActivationTaskScheduler scheduler = orleansTaskScheduler.GetWorkItemGroup(context).TaskRunner;
var result = new TaskCompletionSource <bool>();
Task endOfChain = null;
int n = 0;
Task wrapper = new Task(() =>
{
CheckRuntimeContext(context);
// ReSharper disable AccessToModifiedClosure
Task task1 = Task.Factory.StartNew(() =>
{
output.WriteLine("===> 1a ");
CheckRuntimeContext(context);
Thread.Sleep(1000);
n = n + 3;
output.WriteLine("===> 1b");
CheckRuntimeContext(context);
});
Task task2 = task1.ContinueWith(task =>
{
output.WriteLine("===> 2");
CheckRuntimeContext(context);
n = n * 5;
});
Task task3 = task2.ContinueWith(task =>
{
output.WriteLine("===> 3");
n = n / 5;
CheckRuntimeContext(context);
});
Task task4 = task3.ContinueWith(task =>
{
output.WriteLine("===> 4");
n = n - 2;
result.SetResult(true);
CheckRuntimeContext(context);
});
// ReSharper restore AccessToModifiedClosure
endOfChain = task4.ContinueWith(task =>
{
output.WriteLine("Done Faulted={0}", task.IsFaulted);
CheckRuntimeContext(context);
Assert.IsFalse(task.IsFaulted, "Faulted with Exception=" + task.Exception);
});
});
wrapper.Start(scheduler);
bool ok = wrapper.Wait(TimeSpan.FromSeconds(1));
if (!ok)
{
throw new TimeoutException();
}
Assert.IsFalse(wrapper.IsFaulted, "Wrapper Task Faulted with Exception=" + wrapper.Exception);
Assert.IsTrue(wrapper.IsCompleted, "Wrapper Task completed");
bool finished = result.Task.Wait(TimeSpan.FromSeconds(2));
Assert.IsNotNull(endOfChain, "End of chain Task created successfully");
Assert.IsFalse(endOfChain.IsFaulted, "Task chain Faulted with Exception=" + endOfChain.Exception);
Assert.IsTrue(finished, "Wrapper Task completed ok");
Assert.IsTrue(n != 0, "Work items did not get executed");
Assert.AreEqual(1, n, "Work items executed out of order");
}
public void Sched_AC_Current_TaskScheduler()
{
UnitTestSchedulingContext context = new UnitTestSchedulingContext();
OrleansTaskScheduler orleansTaskScheduler = orleansTaskScheduler = TestInternalHelper.InitializeSchedulerForTesting(context);
ActivationTaskScheduler activationScheduler = orleansTaskScheduler.GetWorkItemGroup(context).TaskRunner;
// RuntimeContext.InitializeThread(masterScheduler);
mainDone = false;
var result = new TaskCompletionSource <bool>();
Task wrapper = null;
Task finalPromise = null;
orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() =>
{
Log(1, "Outer ClosureWorkItem " + Task.CurrentId + " starting");
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #0");
Log(2, "Starting wrapper Task");
wrapper = Task.Factory.StartNew(() =>
{
Log(3, "Inside wrapper Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #1");
Log(4, "Wrapper Task " + Task.CurrentId + " creating AC chain");
Task promise1 = Task.Factory.StartNew(() =>
{
Log(5, "#1 Inside AC Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #1");
SubProcess1(1);
});
Task promise2 = promise1.ContinueWith((_) =>
{
Log(6, "#2 Inside AC Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #2");
SubProcess1(2);
});
finalPromise = promise2.ContinueWith((_) =>
{
Log(7, "#3 Inside final AC Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #3");
SubProcess1(3);
result.SetResult(true);
});
finalPromise.Ignore();
Log(8, "Wrapper Task Id=" + Task.CurrentId + " sleeping");
Thread.Sleep(TimeSpan.FromSeconds(1));
Log(9, "Wrapper Task Id=" + Task.CurrentId + " finished");
});
Log(10, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " sleeping");
Thread.Sleep(TimeSpan.FromSeconds(1));
Log(11, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " awake");
Log(12, "Finished Outer TaskWorkItem Task Id=" + wrapper.Id);
mainDone = true;
}), context);
Log(13, "Waiting for ClosureWorkItem to spawn wrapper Task");
for (int i = 0; i < 5 * waitFactor; i++)
{
if (wrapper != null)
{
break;
}
Thread.Sleep(TimeSpan.FromSeconds(1).Multiply(waitFactor));
}
Assert.IsNotNull(wrapper, "Wrapper Task was not created");
Log(14, "Waiting for wrapper Task Id=" + wrapper.Id + " to complete");
bool finished = wrapper.Wait(TimeSpan.FromSeconds(2 * waitFactor));
Log(15, "Done waiting for wrapper Task Id=" + wrapper.Id + " Finished=" + finished);
if (!finished)
{
throw new TimeoutException();
}
Assert.IsFalse(wrapper.IsFaulted, "Wrapper Task faulted: " + wrapper.Exception);
Assert.IsTrue(wrapper.IsCompleted, "Wrapper Task should be completed");
Log(16, "Waiting for TaskWorkItem to complete");
for (int i = 0; i < 15 * waitFactor; i++)
{
if (mainDone)
{
break;
}
Thread.Sleep(1000 * waitFactor);
}
Log(17, "Done waiting for TaskWorkItem to complete MainDone=" + mainDone);
Assert.IsTrue(mainDone, "Main Task should be completed");
Assert.IsNotNull(finalPromise, "AC chain not created");
Log(18, "Waiting for final AC promise to complete");
finalPromise.Wait(TimeSpan.FromSeconds(4 * waitFactor));
Log(19, "Done waiting for final promise");
Assert.IsFalse(finalPromise.IsFaulted, "Final AC faulted: " + finalPromise.Exception);
Assert.IsTrue(finalPromise.IsCompleted, "Final AC completed");
Assert.IsTrue(result.Task.Result, "Timeout-1");
Assert.AreNotEqual(0, stageNum1, "Work items did not get executed-1");
Assert.AreEqual(3, stageNum1, "Work items executed out of order-1");
}
public void Sched_Task_Turn_Execution_Order()
{
// A unit test that checks that any turn is indeed run till completion before any other turn?
// For example, you have a long running main turn and in the middle it spawns a lot of short CWs (on Done promise) and StartNew.
// You test that no CW/StartNew runs until the main turn is fully done. And run in stress.
UnitTestSchedulingContext context = new UnitTestSchedulingContext();
OrleansTaskScheduler masterScheduler = orleansTaskScheduler = TestInternalHelper.InitializeSchedulerForTesting(context);
WorkItemGroup workItemGroup = orleansTaskScheduler.GetWorkItemGroup(context);
ActivationTaskScheduler activationScheduler = workItemGroup.TaskRunner;
mainDone = false;
stageNum1 = stageNum2 = 0;
var result1 = new TaskCompletionSource <bool>();
var result2 = new TaskCompletionSource <bool>();
Task wrapper = null;
Task finalTask1 = null;
Task finalPromise2 = null;
masterScheduler.QueueWorkItem(new ClosureWorkItem(() =>
{
Log(1, "Outer ClosureWorkItem " + Task.CurrentId + " starting");
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #0");
Log(2, "Starting wrapper Task");
wrapper = Task.Factory.StartNew(() =>
{
Log(3, "Inside wrapper Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #1");
// Execution chain #1
Log(4, "Wrapper Task Id=" + Task.CurrentId + " creating Task chain");
Task task1 = Task.Factory.StartNew(() =>
{
Log(5, "#11 Inside sub-Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #11");
SubProcess1(11);
});
Task task2 = task1.ContinueWith((Task task) =>
{
Log(6, "#12 Inside continuation Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #12");
if (task.IsFaulted)
{
throw task.Exception.Flatten();
}
SubProcess1(12);
});
Task task3 = task2.ContinueWith(task =>
{
Log(7, "#13 Inside continuation Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #13");
if (task.IsFaulted)
{
throw task.Exception.Flatten();
}
SubProcess1(13);
});
finalTask1 = task3.ContinueWith(task =>
{
Log(8, "#14 Inside final continuation Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #14");
if (task.IsFaulted)
{
throw task.Exception.Flatten();
}
SubProcess1(14);
result1.SetResult(true);
});
// Execution chain #2
Log(9, "Wrapper Task " + Task.CurrentId + " creating AC chain");
Task promise2 = Task.Factory.StartNew(() =>
{
Log(10, "#21 Inside sub-Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #21");
SubProcess2(21);
});
finalPromise2 = promise2.ContinueWith((_) =>
{
Log(11, "#22 Inside final continuation Task Id=" + Task.CurrentId);
Assert.AreEqual(activationScheduler, TaskScheduler.Current, "TaskScheduler.Current #22");
SubProcess2(22);
result2.SetResult(true);
});
finalPromise2.Ignore();
Log(12, "Wrapper Task Id=" + Task.CurrentId + " sleeping #2");
Thread.Sleep(TimeSpan.FromSeconds(1));
Log(13, "Wrapper Task Id=" + Task.CurrentId + " finished");
});
Log(14, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " sleeping");
Thread.Sleep(TimeSpan.FromSeconds(1));
Log(15, "Outer ClosureWorkItem Task Id=" + Task.CurrentId + " awake");
Log(16, "Finished Outer ClosureWorkItem Task Id=" + wrapper.Id);
mainDone = true;
}), context);
Log(17, "Waiting for ClosureWorkItem to spawn wrapper Task");
for (int i = 0; i < 5 * waitFactor; i++)
{
if (wrapper != null)
{
break;
}
Thread.Sleep(TimeSpan.FromSeconds(1).Multiply(waitFactor));
}
Assert.IsNotNull(wrapper, "Wrapper Task was not created");
Log(18, "Waiting for wrapper Task Id=" + wrapper.Id + " to complete");
bool finished = wrapper.Wait(TimeSpan.FromSeconds(2 * waitFactor));
Log(19, "Done waiting for wrapper Task Id=" + wrapper.Id + " Finished=" + finished);
if (!finished)
{
throw new TimeoutException();
}
Assert.IsFalse(wrapper.IsFaulted, "Wrapper Task faulted: " + wrapper.Exception);
Assert.IsTrue(wrapper.IsCompleted, "Wrapper Task should be completed");
Log(20, "Waiting for TaskWorkItem to complete");
for (int i = 0; i < 15 * waitFactor; i++)
{
if (mainDone)
{
break;
}
Thread.Sleep(1000 * waitFactor);
}
Log(21, "Done waiting for TaskWorkItem to complete MainDone=" + mainDone);
Assert.IsTrue(mainDone, "Main Task should be completed");
Assert.IsNotNull(finalTask1, "Task chain #1 not created");
Assert.IsNotNull(finalPromise2, "Task chain #2 not created");
Log(22, "Waiting for final task #1 to complete");
bool ok = finalTask1.Wait(TimeSpan.FromSeconds(4 * waitFactor));
Log(23, "Done waiting for final task #1 complete Ok=" + ok);
if (!ok)
{
throw new TimeoutException();
}
Assert.IsFalse(finalTask1.IsFaulted, "Final Task faulted: " + finalTask1.Exception);
Assert.IsTrue(finalTask1.IsCompleted, "Final Task completed");
Assert.IsTrue(result1.Task.Result, "Timeout-1");
Log(24, "Waiting for final promise #2 to complete");
finalPromise2.Wait(TimeSpan.FromSeconds(4 * waitFactor));
Log(25, "Done waiting for final promise #2");
Assert.IsFalse(finalPromise2.IsFaulted, "Final Task faulted: " + finalPromise2.Exception);
Assert.IsTrue(finalPromise2.IsCompleted, "Final Task completed");
Assert.IsTrue(result2.Task.Result, "Timeout-2");
Assert.AreNotEqual(0, stageNum1, "Work items did not get executed-1");
Assert.AreEqual(14, stageNum1, "Work items executed out of order-1");
Assert.AreNotEqual(0, stageNum2, "Work items did not get executed-2");
Assert.AreEqual(22, stageNum2, "Work items executed out of order-2");
}
public void ToDictionary_returns_non_null_if_object_is_null()
{
var result = ObjectExtensions.ToDictionary(null);
Assert.IsNotNull(result);
}
