public void Enforce_that_loops_must_be_disposed()
{
using (Sequence.Create())
{
Sequence.Loop();
}
}
public void Enforce_that_all_steps_in_a_sequence_must_be_completed()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Method1()).InSequence();
}
}
public void Enforce_only_one_active_sequence()
{
using (Sequence.Create())
{
Assert.Throws <SequenceUsageException>(() => Sequence.Create());
}
}
public void Enforce_active_sequence_for_mock_calls_within_sequences()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Method1()).InSequence(Times.AtMostOnce());
}
Assert.Throws <SequenceUsageException>(() => mock.Object.Method1());
}
public void Explicit_MockSequence_Dispose_is_ignored()
{
using (var sequence = Sequence.Create())
{
sequence.Dispose();
sequence.Dispose();
sequence.Dispose();
}
}
public void Property_set_before_previous_one_verified()
{
using (Sequence.Create())
{
mock.SetupSet(_ => _.Property1 = 0).InSequence();
mock.SetupSet(_ => _.Property2 = 0).InSequence();
Assert.Throws <SequenceException>(() => mock.Object.Property2 = 0);
}
}
public void Method_call_before_previous_one_verified()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Method1()).InSequence();
mock.Setup(_ => _.Method2()).InSequence();
Assert.Throws <SequenceException>(() => mock.Object.Method2());
}
}
public void Enforce_mock_calls_outside_sequences_if_mock_is_strict()
{
var strictMock = new Mock <I>(MockBehavior.Strict);
using (Sequence.Create())
{
}
Assert.Throws <MockException>(() => strictMock.Object.Method1());
}
public void Method_call_out_of_sequence()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Method1()).InSequence(Times.AtMostOnce());
mock.Setup(_ => _.Method2()).InSequence();
mock.Object.Method2();
Assert.Throws <SequenceException>(() => mock.Object.Method1());
}
}
public void Property_set_out_of_sequence()
{
using (Sequence.Create())
{
mock.SetupSet(_ => _.Property1 = 0).InSequence(Times.AtMostOnce());
mock.SetupSet(_ => _.Property2 = 0).InSequence();
mock.Object.Property2 = 0;
Assert.Throws <SequenceException>(() => mock.Object.Property1 = 0);
}
}
public void Property_set_in_sequence()
{
using (Sequence.Create())
{
mock.SetupSet(_ => _.Property1 = 0).InSequence();
mock.SetupSet(_ => _.Property2 = 0).InSequence();
mock.Object.Property1 = 0;
mock.Object.Property2 = 0;
}
}
public void Property_get_via_Setup()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Property1).InSequence().Returns(0);
mock.Setup(_ => _.Property2).InSequence().Returns(0);
var foo = mock.Object.Property1;
foo = mock.Object.Property2;
}
}
public void Property_get_before_previous_one_verified()
{
using (Sequence.Create())
{
mock.SetupGet(_ => _.Property1).InSequence().Returns(0);
mock.SetupGet(_ => _.Property2).InSequence().Returns(0);
int foo;
Assert.Throws <SequenceException>(() => foo = mock.Object.Property2);
}
}
public void Property_get_out_of_sequence()
{
using (Sequence.Create())
{
mock.SetupGet(_ => _.Property1).InSequence(Times.AtMostOnce()).Returns(0);
mock.SetupGet(_ => _.Property2).InSequence().Returns(0);
int foo = mock.Object.Property2;
Assert.Throws <SequenceException>(() => foo = mock.Object.Property1);
}
}
public void Method_call_in_sequence()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Method1()).InSequence();
mock.Setup(_ => _.Method2()).InSequence();
mock.Object.Method1();
mock.Object.Method2();
}
}
public void Multiple_mocks_in_same_sequence()
{
var mock1 = new Mock <I>();
var mock2 = new Mock <I>();
using (Sequence.Create())
{
mock1.Setup(_ => _.Method1()).InSequence();
mock2.Setup(_ => _.Method1()).InSequence();
Assert.Throws <SequenceException>(() => mock2.Object.Method1());
}
}
public void Loop_with_prior_missing_call()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Method1()).InSequence();
using (Sequence.Loop(Times.Exactly(1)))
{
mock.Setup(_ => _.Method2()).InSequence();
}
Assert.Throws <SequenceException>(() => mock.Object.Method2());
}
}
public void Loop_steps_with_non_loop_steps()
{
using (Sequence.Create())
{
mock.Setup(_ => _.Method1()).InSequence();
using (Sequence.Loop(Times.Exactly(1)))
{
mock.Setup(_ => _.Method2()).InSequence();
}
mock.Setup(_ => _.Method3()).InSequence();
mock.Object.Method1();
mock.Object.Method2();
mock.Object.Method3();
}
}
public void Support_multiple_sequences_in_different_threads()
{
var mock1 = new Mock <I>();
var mock2 = new Mock <I>();
using (Sequence.Create())
{
mock1.Setup(_ => _.Method1()).InSequence();
mock1.Setup(_ => _.Method2()).InSequence();
var calledOnThread = new AutoResetEvent(false);
var calledOnMain = new AutoResetEvent(false);
new Thread(() =>
{
using (Sequence.Create())
{
mock2.Setup(_ => _.Method1()).InSequence();
mock2.Setup(_ => _.Method2()).InSequence();
calledOnMain.WaitOne();
mock2.Object.Method1();
calledOnThread.Set();
calledOnMain.WaitOne();
mock2.Object.Method2();
calledOnThread.Set();
}
}).Start();
mock1.Object.Method1();
calledOnMain.Set();
calledOnThread.WaitOne();
mock1.Object.Method2();
calledOnMain.Set();
}
}
public void Empty_sequence_is_ignored()
{
using (Sequence.Create())
{
}
}
