public void ActivationSched_NewTask_ContinueWith_Wrapped() { TaskScheduler scheduler = masterScheduler.GetWorkItemGroup(context).TaskRunner; Task <Task> wrapped = new Task <Task>(() => { output.WriteLine("#0 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Task t0 = new Task(() => { output.WriteLine("#1 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #1"); }); Task t1 = t0.ContinueWith(task => { Assert.IsFalse(task.IsFaulted, "Task #1 Faulted=" + task.Exception); output.WriteLine("#2 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #2"); }); t0.Start(scheduler); return(t1); }); wrapped.Start(scheduler); bool ok = wrapped.Unwrap().Wait(TimeSpan.FromSeconds(2)); Assert.IsTrue(ok, "Finished OK"); }
public void TimeSeriesBasics() { TimeSeries series = new TimeSeries(); Assert.IsTrue(series.Count == 0); series.Add(3.0, 2.0, 1.0); Assert.IsTrue(series[0] == 3.0); Assert.IsTrue(series[1] == 2.0); Assert.IsTrue(series[2] == 1.0); Assert.IsTrue(series.Count == 3); Assert.IsFalse(series.Contains(0.0)); Assert.IsTrue(series.Contains(1.0)); Assert.IsTrue(series.IndexOf(0.0) == -1); Assert.IsTrue(series.IndexOf(1.0) == 2); Assert.IsTrue(TestUtilities.IsNearlyEqual(series.Mean, 2.0)); series[2] = 0.0; Assert.IsTrue(series.Count == 3); Assert.IsTrue(series.Contains(0.0)); Assert.IsFalse(series.Contains(1.0)); Assert.IsTrue(series.IndexOf(0.0) == 2); Assert.IsTrue(series.IndexOf(1.0) == -1); Assert.IsTrue(TestUtilities.IsNearlyEqual(series.Mean, 5.0 / 3.0)); series.Clear(); Assert.IsTrue(series.Count == 0); Assert.IsFalse(series.Contains(0.0)); Assert.IsTrue(series.IndexOf(0.0) == -1); }
/// <summary> /// Debugs a project with and without a process-wide PYTHONPATH value. /// If <see cref="DebugPythonProjectSubFolderStartupFileSysPath"/> fails /// this test may also fail. /// </summary> public void DebugPythonProjectWithAndWithoutClearingPythonPath(VisualStudioApp app, DotNotWaitOnNormalExit optionSetter) { var sysPathSln = app.CopyProjectForTest(@"TestData\SysPath.sln"); var helloWorldSln = app.CopyProjectForTest(@"TestData\HelloWorld.sln"); var testDataPath = Path.Combine(PathUtils.GetParent(helloWorldSln), "HelloWorld").Replace("\\", "\\\\"); var pyService = app.ServiceProvider.GetUIThread().Invoke(() => app.ServiceProvider.GetPythonToolsService()); using (new EnvironmentVariableSetter("PYTHONPATH", testDataPath)) { app.OpenProject(sysPathSln); using (new PythonServiceGeneralOptionsSetter(pyService, clearGlobalPythonPath: false)) { ClearOutputWindowDebugPaneText(app); app.Dte.ExecuteCommand("Debug.Start"); WaitForMode(app, dbgDebugMode.dbgDesignMode); WaitForDebugOutput(app, text => text.Contains(testDataPath)); } ClearOutputWindowDebugPaneText(app); app.Dte.ExecuteCommand("Debug.Start"); WaitForMode(app, dbgDebugMode.dbgDesignMode); var outputWindowText = WaitForDebugOutput(app, text => text.Contains("DONE")); Assert.IsFalse(outputWindowText.Contains(testDataPath), outputWindowText); } }
public void Sched_Task_StartNew_ContinueWith_TaskScheduler() { UnitTestSchedulingContext rootContext = new UnitTestSchedulingContext(); OrleansTaskScheduler scheduler = TestInternalHelper.InitializeSchedulerForTesting(rootContext); output.WriteLine("#0 - StartNew - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Task t0 = Task.Factory.StartNew(state => { output.WriteLine("#1 - StartNew - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #1"); }, null, CancellationToken.None, TaskCreationOptions.None, scheduler); Task t1 = t0.ContinueWith(task => { Assert.IsFalse(task.IsFaulted, "Task #1 Faulted=" + task.Exception); output.WriteLine("#2 - StartNew - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #2"); }, scheduler); bool ok = t1.Wait(TimeSpan.FromSeconds(30)); if (!ok) throw new TimeoutException(); }
public void BivariateSampleManipulations() { BivariateSample s = new BivariateSample(); s.Add(1.0, 9.0); s.Add(new XY(2.0, 8.0)); s.Add(new double[] { 3.0, 4.0 }, new double[] { 7.0, 6.0 }); s.Add(new XY[] { new XY(5.0, 5.0), new XY(6.0, 4.0) }); Assert.IsTrue(s.Count == 6); Assert.IsTrue(!s.X.Contains(9.0)); s.TransposeXY(); Assert.IsTrue(s.X.Contains(9.0)); s.TransposeXY(); Assert.IsTrue(s.Remove(2.0, 8.0)); Assert.IsTrue(s.Count == 5); Assert.IsFalse(s.Remove(2.0, 8.0)); Assert.IsTrue(s.Count == 5); Assert.IsTrue(s.Remove(new XY(6.0, 4.0))); Assert.IsTrue(s.Count == 4); Assert.IsTrue(s.Contains(1.0, 9.0)); Assert.IsFalse(s.Contains(9.0, 1.0)); Assert.IsTrue(s.Contains(new XY(4.0, 6.0))); s.Clear(); Assert.IsTrue(s.Count == 0); }
public void CanChooseTest3() { var test = new P5669(); var groups = Utils.Read2DArray("[[1,2,3],[3,4]]"); Assert.IsFalse(test.CanChoose(groups, new[] { 7, 7, 1, 2, 3, 4, 7, 7 })); }
public void Sched_Task_NewTask_ContinueWith_Wrapped() { TaskScheduler scheduler = new QueuedTaskScheduler(); Task wrapped = new Task(() => { output.WriteLine("#0 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Task t0 = new Task(() => { output.WriteLine("#1 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #1"); }); Task t1 = t0.ContinueWith(task => { Assert.IsFalse(task.IsFaulted, "Task #1 Faulted=" + task.Exception); output.WriteLine("#2 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #2"); }); t0.Start(scheduler); bool ok = t1.Wait(TimeSpan.FromSeconds(15)); if (!ok) throw new TimeoutException(); }); wrapped.Start(scheduler); bool finished = wrapped.Wait(TimeSpan.FromSeconds(30)); if (!finished) throw new TimeoutException(); }
public void Sched_Task_StartTask_Wait_Wrapped() { UnitTestSchedulingContext cntx = new UnitTestSchedulingContext(); OrleansTaskScheduler scheduler = TestInternalHelper.InitializeSchedulerForTesting(cntx); const int NumTasks = 100; ManualResetEvent[] flags = new ManualResetEvent[NumTasks]; for (int i = 0; i < NumTasks; i++) { flags[i] = new ManualResetEvent(false); } Task[] tasks = new Task[NumTasks]; for (int i = 0; i < NumTasks; i++) { int taskNum = i; // Capture tasks[i] = new Task(() => { output.WriteLine("Inside Task-" + taskNum); flags[taskNum].WaitOne(); }); output.WriteLine("Created Task-" + taskNum + " Id=" + tasks[taskNum].Id); } Task[] wrappers = new Task[NumTasks]; for (int i = 0; i < NumTasks; i++) { int taskNum = i; // Capture wrappers[i] = new Task(() => { output.WriteLine("Inside Wrapper-" + taskNum); tasks[taskNum].Start(scheduler); }); wrappers[i].ContinueWith(t => { Assert.IsFalse(t.IsFaulted, "Warpper.IsFaulted-" + taskNum + " " + t.Exception); Assert.IsTrue(t.IsCompleted, "Wrapper.IsCompleted-" + taskNum); }); output.WriteLine("Created Wrapper-" + taskNum + " Task.Id=" + wrappers[taskNum].Id); } foreach (var wrapper in wrappers) { wrapper.Start(scheduler); } foreach (var flag in flags) { flag.Set(); } for (int i = 0; i < wrappers.Length; i++) { bool ok = wrappers[i].Wait(TimeSpan.FromMilliseconds(NumTasks * 150 * 2)); Assert.IsTrue(ok, "Wait completed successfully for Wrapper-" + i); } for (int i = 0; i < tasks.Length; i++) { bool ok = tasks[i].Wait(TimeSpan.FromMilliseconds(NumTasks * 150 * 2)); Assert.IsTrue(ok, "Wait completed successfully for Task-" + i); Assert.IsFalse(tasks[i].IsFaulted, "Task.IsFaulted-" + i + " " + tasks[i].Exception); Assert.IsTrue(tasks[i].IsCompleted, "Task.IsCompleted-" + i); } }
public void Task_MasterTaskScheduler() { string testName = "Task_MasterTaskScheduler"; var baseline = DoBaseTestRun(testName + "-Baseline", numTasks); var tasks = new List <Task>(numTasks); var masterScheduler = GetTaskScheduler(); TaskScheduler[] schedulers = new TaskScheduler[numTasks]; for (int i = 0; i < numTasks; i++) { schedulers[i] = new TaskSchedulerWrapper(masterScheduler); } QueuedTaskSchedulerTests_Set1.TimeRun(1, baseline, testName, output, () => { for (int i = 0; i < numTasks; i++) { Task t = CreateTask(i); t.Start(schedulers[i]); tasks.Add(t); } Task.WaitAll(tasks.ToArray()); }); foreach (Task t in tasks) { Assert.IsTrue(t.IsCompleted, "Task is completed"); Assert.IsFalse(t.IsFaulted, "Task did not fault"); Assert.IsNull(t.Exception, "Task did not return an Exception"); } }
public void GetGrain_Derived_WithPrefix() { var g = GrainClient.GrainFactory.GetGrain <IDerivedFromBase>(GetRandomGrainId(), "UnitTests.Grains"); Assert.IsFalse(g.Foo().Result); Assert.IsTrue(g.Bar().Result); }
public void DataSetManipulationsTest() { UncertainMeasurement <double> d1 = new UncertainMeasurement <double>(3.0, new UncertainValue(2.0, 1.0)); UncertainMeasurement <double> d2 = new UncertainMeasurement <double>(-3.0, new UncertainValue(2.0, 1.0)); UncertainMeasurement <double> d3 = new UncertainMeasurement <double>(3.0, new UncertainValue(-2.0, 1.0)); Assert.IsTrue(d1 != null); UncertainMeasurement <double>[] data = new UncertainMeasurement <double>[] { d1, d2 }; UncertainMeasurementSample set = new UncertainMeasurementSample(); set.Add(data); Assert.IsFalse(set.Contains(d3)); Assert.IsTrue(set.Count == data.Length); set.Add(d3); Assert.IsTrue(set.Contains(d3)); Assert.IsTrue(set.Count == data.Length + 1); set.Remove(d3); Assert.IsFalse(set.Contains(d3)); Assert.IsTrue(set.Count == data.Length); set.Clear(); Assert.IsTrue(set.Count == 0); }
public void GetGrain_Derived_WithFullName_FromBase() { var grainFullName = typeof(DerivedFromBaseGrain).FullName; var g = GrainClient.GrainFactory.GetGrain <IBase>(GetRandomGrainId(), grainFullName); Assert.IsFalse(g.Foo().Result); }
public void GetGrain_OneImplementation_Prefix() { var grainFullName = typeof(BaseGrain1).FullName; var g = GrainClient.GrainFactory.GetGrain <IBase1>(GetRandomGrainId(), grainFullName); Assert.IsFalse(g.Foo().Result); }
public void Comparer_OutsideRange() { string testName = Guid.NewGuid().ToString(); //TestContext.TestName; string rangeParamName = "Column1"; string toValue = "Rem10"; string fromValue = "Rem12"; var compareClause = MemoryStorage.GetComparer(rangeParamName, fromValue, toValue); var data = new Dictionary <string, object>(); data[rangeParamName] = "Rem09"; Assert.IsTrue(compareClause(data), "From={0} To={1} Compare Value={2}", fromValue, toValue, data[rangeParamName]); data[rangeParamName] = "Rem10"; Assert.IsTrue(compareClause(data), "From={0} To={1} Compare Value={2}", fromValue, toValue, data[rangeParamName]); data[rangeParamName] = "Rem11"; Assert.IsFalse(compareClause(data), "From={0} To={1} Compare Value={2}", fromValue, toValue, data[rangeParamName]); data[rangeParamName] = "Rem12"; Assert.IsTrue(compareClause(data), "From={0} To={1} Compare Value={2}", fromValue, toValue, data[rangeParamName]); data[rangeParamName] = testName; Assert.IsTrue(compareClause(data), "From={0} To={1} Compare Value={2}", fromValue, toValue, data[rangeParamName]); }
public void Add2Remove1UntilFull() { IObjectPool <CachedMessageBlock <TestCachedMessage> > pool = new MyTestPooled(); ICacheDataAdapter <TestQueueMessage, TestCachedMessage> dataAdapter = new TestCacheDataAdapter(); CachedMessageBlock <TestCachedMessage> block = pool.Allocate(); int first = 0; int last = -1; while (block.HasCapacity) { // add message to end of block AddAndCheck(block, dataAdapter, first, last); last++; if (!block.HasCapacity) { continue; } // add message to end of block AddAndCheck(block, dataAdapter, first, last); last++; // removed message from start of block RemoveAndCheck(block, first, last); first++; } Assert.AreEqual(TestBlockSize / 2, block.OldestMessageIndex); Assert.AreEqual(TestBlockSize - 1, block.NewestMessageIndex); Assert.IsFalse(block.IsEmpty); Assert.IsFalse(block.HasCapacity); }
public void Task_OrleansTaskScheduler() { string testName = "Task_OrleansTaskScheduler"; var baseline = DoBaseTestRun(testName + "-Baseline", numTasks); var tasks = new List <Task>(numTasks); UnitTestSchedulingContext rootContext = new UnitTestSchedulingContext(); TaskScheduler taskScheduler = TestInternalHelper.InitializeSchedulerForTesting(rootContext); QueuedTaskSchedulerTests_Set1.TimeRun(1, baseline, testName, output, () => { for (int i = 0; i < numTasks; i++) { string context = i.ToString(); Task t = CreateTask(i, context); t.Start(taskScheduler); tasks.Add(t); } Task.WaitAll(tasks.ToArray()); }); foreach (Task t in tasks) { Assert.IsTrue(t.IsCompleted, "Task is completed"); Assert.IsFalse(t.IsFaulted, "Task did not fault"); Assert.IsNull(t.Exception, "Task did not return an Exception"); } }
public void CanChooseTest2() { var test = new P5669(); var groups = Utils.Read2DArray("[[10,-2],[1,2,3,4]]"); Assert.IsFalse(test.CanChoose(groups, new[] { 1, 2, 3, 4, 10, -2 })); }
public void Task_OneSyncContext() { string testName = "Task_OneSyncContext"; var baseline = DoBaseTestRun(testName + "-Baseline", numTasks); var syncContext = new AsyncTestContext(output); SynchronizationContext.SetSynchronizationContext(syncContext); var tasks = new List <Task>(numTasks); QueuedTaskSchedulerTests_Set1.TimeRun(1, baseline, testName, output, () => { for (int i = 0; i < numTasks; i++) { Task t = CreateTask(i); t.Start(); tasks.Add(t); } Task.WaitAll(tasks.ToArray()); }); foreach (Task t in tasks) { Assert.IsTrue(t.IsCompleted, "Task is completed"); Assert.IsFalse(t.IsFaulted, "Task did not fault"); Assert.IsNull(t.Exception, "Task did not return an Exception"); } }
public void Sched_Task_StartTask_2() { UnitTestSchedulingContext cntx = new UnitTestSchedulingContext(); OrleansTaskScheduler scheduler = TestInternalHelper.InitializeSchedulerForTesting(cntx); ManualResetEvent pause1 = new ManualResetEvent(false); ManualResetEvent pause2 = new ManualResetEvent(false); Task task1 = new Task(() => { pause1.WaitOne(); output.WriteLine("Task-1"); }); Task task2 = new Task(() => { pause2.WaitOne(); output.WriteLine("Task-2"); }); pause1.Set(); task1.Start(scheduler); bool ok = task1.Wait(TimeSpan.FromMilliseconds(100)); if (!ok) throw new TimeoutException(); Assert.IsTrue(task1.IsCompleted, "Task.IsCompleted-1"); Assert.IsFalse(task1.IsFaulted, "Task.IsFaulted-1"); task2.Start(scheduler); pause2.Set(); ok = task2.Wait(TimeSpan.FromMilliseconds(100)); if (!ok) throw new TimeoutException(); Assert.IsTrue(task2.IsCompleted, "Task.IsCompleted-2"); Assert.IsFalse(task2.IsFaulted, "Task.IsFaulted-2"); }
private void DiscoverAssemblies(AssemblyLoader loader, List <string> exclusionList, bool validate = true) { var result = loader.DiscoverAssemblies(); var text = new StringBuilder(); text.Append("\nFound assemblies:"); foreach (var i in result) { text.Append(String.Format("\n\t* {0}", i)); } logger.Info(text.ToString()); if (validate) { var found = false; foreach (var i in result) { var fileName = Path.GetFileName(i); // we shouldn't have any blacklisted assemblies in the list. Assert.IsFalse(exclusionList.Contains(fileName), "Assemblies on an exclusion list should be ignored."); if (fileName == ExpectedFileName) { found = true; } } Assert.IsTrue( found, String.Format( "{0} should have been found by the assembly loader", ExpectedFileName)); } }
public void Sched_Task_NewTask_ContinueWith_TaskScheduler() { UnitTestSchedulingContext rootContext = new UnitTestSchedulingContext(); OrleansTaskScheduler scheduler = TestInternalHelper.InitializeSchedulerForTesting(rootContext); output.WriteLine("#0 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Task t0 = new Task(() => { output.WriteLine("#1 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #1"); }); Task t1 = t0.ContinueWith(task => { Assert.IsFalse(task.IsFaulted, "Task #1 Faulted=" + task.Exception); output.WriteLine("#2 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}", SynchronizationContext.Current, TaskScheduler.Current); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #2"); }, scheduler); t0.Start(scheduler); bool ok = t1.Wait(TimeSpan.FromSeconds(30)); if (!ok) throw new TimeoutException(); }
public void DeleteVacation_VacationInFuture_VacationEdited() { var result = _service.Delete(_futureVacationId); Assert.IsFalse(result.BadRequest); Assert.AreEqual(_futureVacationId, result.Result.Id); }
// check that premature wait finishes on time but does not throw with false and later wait throws. public void ErrorHandlingTimedMethodWithError() { var grainFullName = typeof(ErrorGrain).FullName; IErrorGrain grain = GrainClient.GrainFactory.GetGrain <IErrorGrain>(GetRandomGrainId(), grainFullName); Task promise = grain.LongMethodWithError(2000); // there is a race in the test here. If run in debugger, the invocation can actually finish OK Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); Assert.IsFalse(promise.Wait(1000), "The task shouldn't have completed yet."); stopwatch.Stop(); Assert.IsTrue(stopwatch.ElapsedMilliseconds >= 900, "Waited less than 900ms"); // check that we waited at least 0.9 second Assert.IsTrue(stopwatch.ElapsedMilliseconds <= 1100, "Waited longer than 1100ms"); try { promise.Wait(); Assert.Fail("Should have thrown"); } catch (Exception) { } Assert.IsTrue(promise.Status == TaskStatus.Faulted); }
public void ParseNoArgs() { CounterControl prog = new CounterControl(); Assert.IsTrue(prog.ParseArguments(new string[] { })); Assert.IsFalse(prog.Unregister); }
public void FailSideCastAfterContinueWith() { Xunit.Assert.Throws <InvalidCastException>(() => { // GeneratorTestDerivedGrain1Reference extends GeneratorTestGrainReference // GeneratorTestDerivedGrain2Reference extends GeneratorTestGrainReference try { IGeneratorTestDerivedGrain1 grain = GrainClient.GrainFactory.GetGrain <IGeneratorTestDerivedGrain1>(GetRandomGrainId()); IGeneratorTestDerivedGrain2 cast = null; Task <bool> av = grain.StringIsNullOrEmpty(); Task <bool> av2 = av.ContinueWith((Task <bool> t) => Assert.IsTrue(t.Result)).ContinueWith((_AppDomain) => { cast = grain.AsReference <IGeneratorTestDerivedGrain2>(); }).ContinueWith((_) => cast.StringConcat("a", "b", "c")).ContinueWith((_) => cast.StringIsNullOrEmpty().Result); Assert.IsFalse(av2.Result); } catch (AggregateException ae) { Exception ex = ae.InnerException; while (ex is AggregateException) { ex = ex.InnerException; } throw ex; } Assert.Fail("Exception should have been raised"); }); }
public void DoNotNeedsRunAsAdminForUnknownCommand() { CounterControl prog = new CounterControl(); prog.ParseArguments(new string[] { "/xyz" }); Assert.IsFalse(prog.NeedRunAsAdministrator); }
public void CollectionCommitTest() { var col = new EmployeeCollection(); for (var i = 1; i <= 5; i++) { var e = CreateEmployee(); e.EmployeeNumber = i; col.Attach(e); } col.StartTrackingChanges(); var p = col.Items.First(_ => _.EmployeeNumber == Faker.RandomNumber.Next(2, 4)); Debug.WriteLine($"Employee No: {p.EmployeeNumber}"); p.StateStatus = EntityObjectState.Deleted; Assert.IsTrue(p.IsDirty, "Object Must be Dirty"); //Assert.IsTrue(col.IsDirty, "Collection must be Dirty"); col.RemoveDeletedItemsAndClearChanges(); Assert.IsFalse(col.IsDirty, "Collection Must NOT be dirty"); Assert.AreEqual(4, col.Items.Count()); }
public void IsHttpCreateStreamWorks() { var response = _httpProtocolDownlaoder.GetFileInfo(_resourceDetailhttp); Assert.IsFalse(false); Assert.IsNotNull(response.ReturnedValue); }
internal async Task ReminderSimple() { var reminder = CreateReminder(MakeTestGrainReference(), "0"); await remindersTable.UpsertRow(reminder); reminder = await remindersTable.ReadRow(reminder.GrainRef, reminder.ReminderName); string etagTemp = reminder.ETag; Assert.IsNotNull(etagTemp); reminder.ETag = await remindersTable.UpsertRow(reminder); var removeRowRes = await remindersTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, etagTemp); Assert.IsFalse(removeRowRes, "should have failed. Etag is wrong"); removeRowRes = await remindersTable.RemoveRow(reminder.GrainRef, "bla", reminder.ETag); Assert.IsFalse(removeRowRes, "should have failed. reminder name is wrong"); removeRowRes = await remindersTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag); Assert.IsTrue(removeRowRes, "should have succeeded. Etag is right"); removeRowRes = await remindersTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag); Assert.IsFalse(removeRowRes, "should have failed. reminder shouldn't exist"); }
public async Task ActivationSched_WhenAny_Timeout() { TaskScheduler scheduler = masterScheduler.GetWorkItemGroup(context).TaskRunner; ManualResetEvent pause1 = new ManualResetEvent(false); ManualResetEvent pause2 = new ManualResetEvent(false); var finish = new TaskCompletionSource <bool>(); Task <int> task1 = null; Task <int> task2 = null; Task join = null; Task wrapper = new Task(() => { task1 = Task <int> .Factory.StartNew(() => { output.WriteLine("Task-1 Started"); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current=" + TaskScheduler.Current); pause1.WaitOne(); output.WriteLine("Task-1 Done"); return(1); }); task2 = Task <int> .Factory.StartNew(() => { output.WriteLine("Task-2 Started"); Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current=" + TaskScheduler.Current); pause2.WaitOne(); output.WriteLine("Task-2 Done"); return(2); }); join = Task.WhenAny(task1, task2, Task.Delay(TimeSpan.FromSeconds(2))); finish.SetResult(true); }); wrapper.Start(scheduler); var timeoutLimit = TimeSpan.FromSeconds(1); try { await finish.Task.WithTimeout(timeoutLimit); } catch (TimeoutException) { Assert.Fail("Result did not arrive before timeout " + timeoutLimit); } Assert.IsNotNull(join, "Joined promise assigned"); await join; Assert.IsTrue(join.IsCompleted && !join.IsFaulted, "Join Status " + join.Status); Assert.IsFalse(task1.IsFaulted, "Task-1 Faulted " + task1.Exception); Assert.IsFalse(task1.IsCompleted, "Task-1 Status " + task1.Status); Assert.IsFalse(task2.IsFaulted, "Task-2 Faulted " + task2.Exception); Assert.IsFalse(task2.IsCompleted, "Task-2 Status " + task2.Status); pause1.Set(); task1.Ignore(); pause2.Set(); task2.Ignore(); }