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