public void Release_Overflow_ThrowsException()
{
var semaphore = new AsyncSemaphore(int.MaxValue);
Assert.AreEqual(int.MaxValue, semaphore.CurrentCount);
AssertEx.ThrowsException <InvalidOperationException>(() => semaphore.Release());
}
public void WaitAndUnwrapExceptionResultWithCT_Faulted_UnwrapsException()
{
var cts = new CancellationTokenSource();
var task = Task.Run((Func <int>)(() => { throw new NotImplementedException(); }));
AssertEx.ThrowsException <NotImplementedException>(() => task.WaitAndUnwrapException(cts.Token), allowDerivedTypes: false);
}
public void WaitAndUnwrapExceptionWithCT_Faulted_UnwrapsException()
{
var cts = new CancellationTokenSource();
var task = Task.Run(() => { throw new NotImplementedException(); });
AssertEx.ThrowsException <NotImplementedException>(() => task.WaitAndUnwrapException(cts.Token));
}
public void WaitAndUnwrapExceptionResultWithCT_CancellationTokenCancelled_Cancels()
{
var cts = new CancellationTokenSource();
cts.Cancel();
AssertEx.ThrowsException <OperationCanceledException>(() => TaskConstants <int> .Never.WaitAndUnwrapException(cts.Token));
}
public void RemoveParticipantsAsync_Underflow_ThrowsException()
{
var barrier = new AsyncBarrier(2);
barrier.SignalAndWaitAsync();
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.RemoveParticipantsAsync(2));
}
public void ExpressionJsonSerializer_AddT_ThrowsArgumentNull()
{
var ser = new ExpressionJsonSerializer
{
Rules =
{
(Person p) => new Person {
Name = p.Name, Age = p.Age
}
}
};
Expression <Func <Book, Book> > roundtrip = (Book b) => new Book {
Title = b.Title
};
Action <ArgumentNullException> argNull(string paramName) => ex => Assert.AreEqual(paramName, ex.ParamName);
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add(rule: null), argNull("rule"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(roundtrip: null), argNull("roundtrip"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>("foo", roundtrip: null), argNull("roundtrip"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(name: null, roundtrip), argNull("name"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(new Book(), roundtrip: null), ex => argNull("roundtrip"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>("foo", new Book(), roundtrip: null), argNull("roundtrip"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(name: null, new Book(), roundtrip), argNull("name"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(_ => true, roundtrip: null), argNull("roundtrip"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(filter: null, roundtrip), argNull("filter"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(new Book(), _ => true, roundtrip: null), argNull("roundtrip"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(new Book(), filter: null, roundtrip), argNull("filter"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>("foo", new Book(), _ => true, roundtrip: null), argNull("roundtrip"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>("foo", new Book(), filter: null, roundtrip), argNull("filter"));
AssertEx.ThrowsException <ArgumentNullException>(() => ser.Rules.Add <Book>(name: null, new Book(), _ => true, roundtrip), argNull("name"));
}
public void AddCount_AfterSet_ThrowsException()
{
var ce = new AsyncCountdownEvent(1);
ce.Signal();
AssertEx.ThrowsException <InvalidOperationException>(() => ce.AddCount());
}
public void WaitWithoutExceptionWithCancellationToken_CanceledToken_DoesNotBlockButThrowsException()
{
var cts = new CancellationTokenSource();
cts.Cancel();
AssertEx.ThrowsException <OperationCanceledException>(() => TaskConstants.Never.WaitWithoutException(cts.Token));
}
public void ValueOrError_CreateError()
{
var ex = new Exception();
var val = ValueOrError.CreateError <int>(ex);
Assert.AreSame(ex, val.Exception);
Assert.AreEqual(ValueOrErrorKind.Error, val.Kind);
AssertEx.ThrowsException <Exception>(() => val.Value, err => object.ReferenceEquals(err, ex));
}
public void SignalAndWaitAsync_NoParticipants_ThrowsException()
{
var barrier = new AsyncBarrier(0);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(0, barrier.ParticipantCount);
Assert.AreEqual(0, barrier.ParticipantsRemaining);
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.SignalAndWaitAsync());
}
public void SignalAndWaitAsync_Underflow_ThrowsException()
{
var tcs = new TaskCompletionSource();
var barrier = new AsyncBarrier(1, async _ => { await tcs.Task; });
barrier.SignalAndWaitAsync();
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.SignalAndWaitAsync());
tcs.SetResult();
}
public void Domain_GetType_Exceptions()
{
var domain = GetDomain();
AssertEx.ThrowsException <ArgumentNullException>(() => domain.GetType((Json.Expression)null), ex => Assert.AreEqual(ex.ParamName, "expression"));
AssertEx.ThrowsException <ArgumentNullException>(() => domain.GetType((TypeRef)null), ex => Assert.AreEqual(ex.ParamName, "typeRef"));
Assert.ThrowsException <BonsaiParseException>(() => domain.GetType(Json.Expression.Null()));
Assert.ThrowsException <BonsaiParseException>(() => domain.GetType(Json.Expression.Number("99")));
}
public void UpgradeableKey_MultiUpgradeWhenFirstUpgradeIsIncomplete_ThrowsSynchronousException()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
await rwl.ReaderLockAsync();
var key = await rwl.UpgradeableReaderLockAsync();
var _ = key.UpgradeAsync();
AssertEx.ThrowsException <InvalidOperationException>(() => key.UpgradeAsync());
});
}
public void SynchronizationContextPost_PropagatesException()
{
Action test = () => AsyncContext.Run(async() =>
{
SynchronizationContext.Current.Post(_ =>
{
throw new NotImplementedException();
}, null);
await Task.Yield();
});
AssertEx.ThrowsException <NotImplementedException>(test, allowDerivedTypes: false);
}
public void Run_Async_PropagatesException()
{
Action test = () => AsyncContext.Run(async() => { await Task.Yield(); throw new NotImplementedException(); });
AssertEx.ThrowsException <NotImplementedException>(test, allowDerivedTypes: false);
}
public void FromEvent1_EventNotFound_RaisesException()
{
var bgw = new BackgroundWorker();
AssertEx.ThrowsException <InvalidOperationException>(() => AsyncFactory <RunWorkerCompletedEventArgs> .FromEvent(bgw, "Elapsed"));
}
public void AddParticipants_Overflow_ThrowsException()
{
var barrier = new AsyncBarrier(int.MaxValue);
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.AddParticipants());
}
public void RemoteCancellationDisposable_NullChecks()
{
AssertEx.ThrowsException <ArgumentNullException>(() => new RemoteCancellationDisposable(provider: null, Guid.Empty), ex => Assert.AreEqual("provider", ex.ParamName));
}
public void ConstructorWithZeroMaxCountAndCollection_Throws()
{
AssertEx.ThrowsException <ArgumentOutOfRangeException>(() => new AsyncProducerConsumerQueue <int>(new int[0], 0));
}
public void WaitAndUnwrapExceptionResult_Faulted_UnwrapsException()
{
var task = Task.Run((Func <int>)(() => { throw new NotImplementedException(); }));
AssertEx.ThrowsException <NotImplementedException>(() => task.WaitAndUnwrapException(), allowDerivedTypes: false);
}
public void ConstructorWithMaxCountSmallerThanCollectionCount_Throws()
{
AssertEx.ThrowsException <ArgumentException>(() => new AsyncProducerConsumerQueue <int>(new[] { 3, 5 }, 1));
}
public void WaitAndUnwrapException_Faulted_UnwrapsException()
{
var task = Task.Run(() => { throw new NotImplementedException(); });
AssertEx.ThrowsException <NotImplementedException>(() => task.WaitAndUnwrapException());
}
public void AddCount_Overflow_ThrowsException()
{
var ce = new AsyncCountdownEvent(int.MaxValue);
AssertEx.ThrowsException <InvalidOperationException>(() => ce.AddCount());
}
public void Domain_AddMember_Exceptions()
{
var domain = new SerializationDomain(BonsaiVersion.Default);
AssertEx.ThrowsException <ArgumentNullException>(() => domain.AddMember(member: null), ex => Assert.AreEqual(ex.ParamName, "member"));
}
