public void WaitForAllOf_Completes_WhenOneHasError()
{
var canThrow = false;
var expectedException = new Exception("Test exception");
var task = WaitForAllOf(
Never.BoxResult(),
WaitForCondition(
"Throw",
() =>
{
if (canThrow)
{
throw expectedException;
}
return(canThrow);
}))
.ExpectWithinSeconds(1)
.ToTask(this.Executor);
this.AdvanceDefaultFrame();
Assert.IsFalse(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
canThrow = true;
this.AdvanceDefaultFrame();
var exception = GetFailureException(task);
Assert.AreSame(expectedException, exception.InnerException);
}
public void AndThen_TimesOutOnFirst_WithDeferredSecondCondition()
{
var task = Never.AndThen(_ => ImmediateTrue).ExpectWithinSeconds(1).ToTask(this.Executor);
this.Scheduler.AdvanceFrame(OneSecond);
Assert.IsNotNull(GetFailureException(task));
}
public void ExpectCondition_ContainsErrorDetails_WhenTimedOut()
{
this.AssertErrorDetailsAfterOneSecond(
Never.ExpectWithinSeconds(1).BoxResult(),
@"\[!\] Never EXPECTED WITHIN.*
\s+Failed with.*
\s+Test operation stack");
}
public void Dispose_CancelsInstructions()
{
var task = Never.ExpectWithinSeconds(1).ToTask(this.Executor);
this.Executor.Dispose();
var exception = GetFailureException(task);
Assert.IsInstanceOf <TaskCanceledException>(exception.InnerException);
}
public void ExpectResponder_ContainsErrorDetails_WhenConditionTimedOut()
{
var responder = Never.ThenRespondWithAction("Nop", Nop);
this.AssertErrorDetailsAfterOneSecond(
responder.ExpectWithinSeconds(1),
@"timed out.*
\[!\] Nop EXPECTED WITHIN [^!]*
Failed with.*
Test operation stack");
}
public void ExpectResponder_TerminatesWithError_IfWaitNotFulfilled()
{
var task = Never
.ThenRespondWithAction("NOP", Nop)
.ExpectWithinSeconds(1)
.ToTask(this.Executor);
Assert.IsFalse(task.IsFaulted);
this.Scheduler.AdvanceFrame(OneSecond);
Assert.IsNotNull(GetFailureException(task));
}
public void ExpectWithinSeconds_CancelsSuccessfully()
{
var cts = new CancellationTokenSource();
var task = Never
.ExpectWithinSeconds(1)
.ToTask(this.Executor, cts.Token);
cts.Cancel();
var error = GetFailureException(task);
Assert.IsInstanceOf <TaskCanceledException>(error.InnerException);
}
public void ExpectResponder_ContainsErrorDetails_WhenInstructionTimedOut()
{
var responder = ImmediateTrue.ThenRespondWith("Response", Never.ExpectWithinSeconds(0.5));
this.AssertErrorDetailsAfterOneSecond(
responder.BoxResult().ExpectWithinSeconds(1),
@"timed out.*
\[!\] Response EXPECTED WITHIN.*
\s+\[!\] Never EXPECTED WITHIN.*
\s+Failed with.*
\s+Test operation stack");
}
public void ExpectCondition_TerminatesWithError_AfterTimeout()
{
var task = Never
.ExpectWithinSeconds(1)
.ToTask(this.Executor);
Assert.IsFalse(task.IsFaulted);
this.Scheduler.AdvanceFrame(OneSecond);
var error = GetFailureException(task);
Assert.IsInstanceOf <TimeoutException>(error.InnerException);
}
public void BoxedCondition_PublishesError_WhenTimedOut()
{
var task = Never
.BoxResult()
.ExpectWithinSeconds(1)
.ToTask(this.Executor);
this.AdvanceDefaultFrame();
Assert.IsFalse(task.IsFaulted);
this.Scheduler.AdvanceFrame(OneSecond);
Assert.IsNotNull(GetFailureException(task));
}
public void Until_Description_MatchesExpected()
{
var state = Never
.ThenRespondWithAction("complete", _ => { })
.Optionally()
.Until(Never)
.CreateState();
StateAssert.StringContainsInOrder(state.ToString())
.Details("UNTIL")
.NotStarted("Never")
.Details("RESPOND TO ANY OF")
.NotStarted("complete");
}
public void Until_TimesOut_AsExpected()
{
var completed = false;
var task = Never
.ThenRespondWithAction("complete", _ => completed = true)
.Optionally()
.Until(Never)
.ExpectWithinSeconds(1)
.ToTask(this.Executor);
this.Scheduler.AdvanceFrame(OneSecond);
Assert.IsFalse(completed);
Assert.IsNotNull(GetFailureException(task));
}
public void StandardResponse()
{
Never b = new Never();
b.SendOrderEvent += new OrderSourceDelegate(b_SendOrder);
sbcount = 0;
Assert.That(b.isValid);
Assert.That(sbcount == 0);
// default response does not trade
// for every tick that it trades
for (int i = 0; i < timesales.Length; i++)
{
b.GotTick(timesales[i]);
Assert.That(o.isValid);
}
Assert.AreEqual(0, sbcount);
}
public void StandardResponse()
{
Never b = new Never();
b.SendOrder += new OrderDelegate(b_SendOrder);
sbcount = 0;
Assert.That(b.isValid);
Assert.That(sbcount == 0);
// default response does not trade
// for every tick that it trades
for (int i = 0; i < timesales.Length; i++)
{
b.GotTick(timesales[i]);
Assert.That(o.isValid);
}
Assert.AreEqual(0, sbcount);
}
public void WaitMessage_ContainsCorrectDetails()
{
var state = Never.ExpectWithinSeconds(1).CreateState();
this.AdvanceDefaultFrame(); // Should not count in time
state.ToTask(this.Executor); // Start execution
StateAssert.StringContainsInOrder(state.ToString())
.Waiting("Never")
.Details(@"Started 0\.00 s ≈ 0 frames ago");
this.AdvanceDefaultFrame();
StateAssert.StringContainsInOrder(state.ToString())
.Waiting("Never")
.Details($@"Started {OneFrame.TotalSeconds:0.00} s ≈ 1 frames ago");
}
public void CanceledMessage_ContainsCorrectDetails()
{
using (var cts = new CancellationTokenSource())
{
var state = Never.ExpectWithinSeconds(1).CreateState();
this.AdvanceDefaultFrame(); // Should not count in time
// Start execution, canceled after one frame
state.ToTask(this.Executor, cts.Token);
this.AdvanceDefaultFrame();
cts.Cancel();
StateAssert.StringContainsInOrder(state.ToString())
.Canceled("Never")
.Details($@"Canceled after {OneFrame.TotalSeconds:0.00} s ≈ 1 frames");
}
}
public void TestBuildPolicy()
{
var always = new Always();
always.AddJid("*****@*****.**");
always.AddJid("*****@*****.**");
var never = new Never();
never.AddJid("*****@*****.**");
never.AddJid("*****@*****.**");
never.AddJid("*****@*****.**");
var prefs = new Preferences()
{
Default = DefaultPreference.Roster,
Never = never,
Always = always
};
prefs.ShouldBe(PREFS6);
}
public _(Never <T> parent, IObserver <T> observer)
: base(parent, observer)
{
}
