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); }