public async Task OrderedTaskCollection_GivenForeach_WhenCalledWithTimedTasks_ThenShouldReturnInCorrectOrder()
{
var task1 = Task.Run(() =>
{
Thread.Sleep(250);
return(1);
});
var task0 = Task.FromResult(0);
var task2 = Task.Run(() =>
{
Thread.Sleep(500);
return(2);
});
var tasks = new OrderedTaskCollection <int>(
new[]
{
task1,
task2,
task0,
});
var results = new List <int>();
foreach (Task <int> task in tasks)
{
results.Add(await task);
}
results[0].Should().Be(0);
results[1].Should().Be(1);
results[2].Should().Be(2);
}
public async Task OrderedTaskCollection_ForeachWhenCalledWithTimedTasks_ShouldReturnInCorrectOrder()
{
var task1 = Task.Run(() =>
{
Thread.Sleep(100);
return(1);
});
var task0 = Task.FromResult(0);
var task2 = Task.Run(() =>
{
Thread.Sleep(200);
return(2);
});
var tasks = new OrderedTaskCollection <int>(
new[]
{
task1,
task2,
task0,
});
var results = new List <int>();
foreach (Task <int> task in tasks)
{
results.Add(await task);
}
Assert.AreEqual(0, results[0]);
Assert.AreEqual(1, results[1]);
Assert.AreEqual(2, results[2]);
}
public void OrderedTaskCollection_ForeachWhenCalledWithTimedTasks_ShouldReturnInCorrectOrder()
{
var task0 = Task.FromResult(0);
var task1 = Task.Run<int>(() =>
{
Thread.Sleep(100);
return 1;
});
var task2 = Task.Run<int>(() =>
{
Thread.Sleep(200);
return 2;
});
var tasks = new OrderedTaskCollection<int>(
new[]
{
task1,
task2,
task0,
});
var results = new List<int>();
foreach (Task<int> task in tasks)
{
results.Add(task.Result);
}
Assert.That(results[0], Is.EqualTo(0));
Assert.That(results[1], Is.EqualTo(1));
Assert.That(results[2], Is.EqualTo(2));
}
public void OrderedTaskCollection_CtorWhenCalledWithTaskList_ShouldSucceed()
{
var tasks = new OrderedTaskCollection<int>(
new[]
{
Task.FromResult(1),
});
}
public void OrderedTaskCollection_CtorWhenCalledWithTaskList_ShouldSucceed()
{
var tasks = new OrderedTaskCollection <int>(
new[]
{
Task.FromResult(1),
});
}
public void OrderedTaskCollection_GivenCtor_WhenCalledWithTaskList_ThenShouldSucceed()
{
var tasks = new OrderedTaskCollection <int>(
new[]
{
Task.FromResult(1),
});
tasks.Should().NotBeEmpty();
}
public async Task TrackingContext_MultipleTasks_ExtraHeadersPersists()
{
var extraHeaders = new Dictionary <string, string>()
{
{ "AAA", "AAA" },
{ "BBB", "BBB" },
};
TrackingContext.NewCurrentIfEmpty(extraHeaders);
List <KeyValuePair <string, string> > masterExtraHeaders = TrackingContext.Current.ExtraHeaders.OrderBy(x => x.Key).ToList();
var task0 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterExtraHeaders.SequenceEqual(tc.ExtraHeaders.OrderBy(x => x.Key).ToList()));
});
var task1 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterExtraHeaders.SequenceEqual(tc.ExtraHeaders.OrderBy(x => x.Key).ToList()));
});
var task2 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterExtraHeaders.SequenceEqual(tc.ExtraHeaders.OrderBy(x => x.Key).ToList()));
});
var tasks = new OrderedTaskCollection <bool>(
new[]
{
task0,
task1,
task2,
});
var results = new List <bool>();
foreach (Task <bool> task in tasks)
{
results.Add(await task);
}
foreach (bool result in results)
{
Assert.IsTrue(result);
}
}
public async Task TrackingContext_MultipleTasks_OriginatorUtcTimestampPersists()
{
TrackingContext.NewCurrentIfEmpty();
DateTime masterOriginatorUtcTimestamp = TrackingContext.Current.OriginatorUtcTimestamp;
var task0 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterOriginatorUtcTimestamp == tc.OriginatorUtcTimestamp);
});
var task1 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterOriginatorUtcTimestamp == tc.OriginatorUtcTimestamp);
});
var task2 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterOriginatorUtcTimestamp == tc.OriginatorUtcTimestamp);
});
var tasks = new OrderedTaskCollection <bool>(
new[]
{
task0,
task1,
task2,
});
var results = new List <bool>();
foreach (Task <bool> task in tasks)
{
results.Add(await task);
}
foreach (bool result in results)
{
Assert.IsTrue(result);
}
Assert.IsTrue(masterOriginatorUtcTimestamp == TrackingContext.Current.OriginatorUtcTimestamp);
}
public async Task TrackingContext_MultipleTasks_CallChainIdPersists()
{
TrackingContext.NewCurrentIfEmpty();
Guid masterCallChainId = TrackingContext.Current.CallChainId;
var task0 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterCallChainId == tc.CallChainId);
});
var task1 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterCallChainId == tc.CallChainId);
});
var task2 = Task.Run(() =>
{
TrackingContext tc = TrackingContext.Current;
return(masterCallChainId == tc.CallChainId);
});
var tasks = new OrderedTaskCollection <bool>(
new[]
{
task0,
task1,
task2,
});
var results = new List <bool>();
foreach (Task <bool> task in tasks)
{
results.Add(await task);
}
foreach (bool result in results)
{
Assert.IsTrue(result);
}
Assert.IsTrue(masterCallChainId == TrackingContext.Current.CallChainId);
}
public async Task OrderedTaskCollection_ForeachWhenCalledWithExceptionTasks_ShouldThrowAggregateException()
{
Func <int> throwsException = () =>
{
throw new Exception();
};
Task <int> task0 = Task.Run(throwsException);
var tasks = new OrderedTaskCollection <int>(
new[]
{
task0,
});
var results = new List <int>();
foreach (Task <int> task in tasks)
{
results.Add(await task);
}
Assert.Fail();
}
public void OrderedTaskCollection_ForeachWhenCalledWithTimedFuncs_ShouldReturnInCorrectOrder()
{
var tasks = new OrderedTaskCollection<int>(
new List<Func<int>>(new Func<int>[]
{
() =>
{
Thread.Sleep(100);
return 1;
},
() => 0,
() =>
{
Thread.Sleep(200);
return 2;
},
}));
var results = new List<int>();
foreach (Task<int> task in tasks)
{
results.Add(task.Result);
}
Assert.That(results[0], Is.EqualTo(0));
Assert.That(results[1], Is.EqualTo(1));
Assert.That(results[2], Is.EqualTo(2));
}
public void OrderedTaskCollection_CtorWhenCalledWithNullFuncList_ShouldThrowArgumentNullException()
{
var tasks = new OrderedTaskCollection<int>((IEnumerable<Func<int>>)null);
Assert.Fail();
}
public void OrderedTaskCollection_ForeachFuncs_ShouldReturnInCorrectOrder()
{
var tasks = new OrderedTaskCollection<int>(
new List<Func<int>>(new Func<int>[]
{
() =>
{
throw new Exception();
},
}));
var results = new List<int>();
foreach (Task<int> task in tasks)
{
results.Add(task.Result);
}
Assert.Fail();
}
public void OrderedTaskCollection_CtorWhenCalledWithNullTaskList_ShouldThrowArgumentNullException()
{
var tasks = new OrderedTaskCollection <int>((IEnumerable <Task <int> >)null);
Assert.Fail();
}
