Resolve issue 237 by wrapping method callsin try finally.

Source/NSubstitute.Acceptance.Specs/FieldReports/Issue237_ReceivedInOrderErrorHandling.cs

@@ -0,0 +1,81 @@
+using System;
+using NUnit.Framework;
+
+namespace NSubstitute.Acceptance.Specs.FieldReports
+{
+    public class Issue237_ReceivedInOrderErrorHandling
+    {
+        public interface IAmAnInterface
+        {
+            void MethodA(int a, int b);
+            void MethodB(int a, int b);
+
+            int MethodC();
+        }
+
+        [Test]
+        [ExpectedException(typeof(Exception))]
+        public void AnExceptionIsReceivedWhenExpected()
+        {
+            Received.InOrder(() =>
+            {
+                throw new Exception("An Exception!");
+            });
+        }
+
+        [Test]
+        public void MethodCallsAreReceivedInOrder()
+        {
+            IAmAnInterface _interface = Substitute.For<IAmAnInterface>();
+            _interface.MethodA(1, 2);
+            _interface.MethodB(1, 2);
+            Received.InOrder(() =>
+            {
+                _interface.MethodA(1, 2);
+                _interface.MethodB(1, 2);
+            });
+        }
+
+        [Test]
+        public void MethodCallsAreReceivedInOrder2()
+        {
+            IAmAnInterface _interface = Substitute.For<IAmAnInterface>();
+            _interface.MethodA(1, 2);
+            _interface.MethodB(1, 2);
+            Received.InOrder(() =>
+            {
+                _interface.MethodA(1, 2);
+                _interface.MethodB(1, 2);
+            });
+        }
+
+        [Test]
+        public void AfterTheFailingTestIsRunWhenTheSuccessfulTestIsRunTheSuccessfulTestShouldSucceed()
+        {
+            try
+            {
+                AnExceptionIsReceivedWhenExpected();
+            }
+            catch (Exception)
+            {
+                // suppress exception from first test
+            }
+            MethodCallsAreReceivedInOrder();
+        }
+
+        [Test]
+        public void AfterTheFailingTestIsRunIShouldBeAbleToConfigureASubstitute()
+        {
+            try
+            {
+                AnExceptionIsReceivedWhenExpected();
+            }
+            catch (Exception)
+            {
+                // suppress failure of test A
+            }
+            var foo = Substitute.For<IAmAnInterface>();
+            foo.MethodC().Returns(1);
+        }
+    }
+}

Source/NSubstitute.Acceptance.Specs/NSubstitute.Acceptance.Specs.csproj

@@ -102,6 +102,7 @@
     <Compile Include="FieldReports\Issue129_AmbiguousArgsWithOutRef.cs" />
     <Compile Include="FieldReports\Issue149_ArgMatcherInReturns.cs" />
     <Compile Include="FieldReports\Issue170_MultidimensionalArray.cs" />
+    <Compile Include="FieldReports\Issue237_ReceivedInOrderErrorHandling.cs" />
     <Compile Include="FieldReports\Issue211_ReceivedInOrderParamsFormatting.cs" />
     <Compile Include="FieldReports\Issue75_DoesNotWorkWithMembersThatUseDynamic.cs" />
     <Compile Include="FieldReports\Issue_RaiseEventOnNonSubstitute.cs" />

Source/NSubstitute.Acceptance.Specs/SequenceChecking.cs

@@ -166,8 +166,7 @@ namespace NSubstitute.Acceptance.Specs
                                  _foo.Finish();
                              });
         }
-
-
+        
         [Test]
         public void Check_auto_subbed_props()
         {
@@ -258,6 +257,36 @@ namespace NSubstitute.Acceptance.Specs
                                  _foo.OnFoo += Arg.Any<Action>();
                              });
         }
+        
+        [Test]
+        public void Pass_when_exception_in_first_sequenced_call_is_caught_and_second_call_is_exact()
+        {
+            try
+            {
+                Received.InOrder(() =>
+                {
+                    throw new Exception("An Exception!");
+                });
+            }
+            catch (Exception)
+            {
+                //suppress error
+            }
+            
+            _foo.Start(2);
+            _bar.Begin();
+            _foo.Finish();
+            _bar.End();
+            
+            Received.InOrder(() =>
+            {
+                _foo.Start(2);
+                _bar.Begin();
+                _foo.Finish();
+                _bar.End();
+
+            });
+        }
 
         [SetUp]
         public void SetUp()

Source/NSubstitute/Core/SubstitutionContext.cs

@@ -115,8 +115,14 @@ namespace NSubstitute.Core
         {
             var query = new Query();
             _currentQuery.Value = query;
-            calls();
-            _currentQuery.Value = null;
+            try
+            {
+                calls();
+            }
+            finally
+            {
+                _currentQuery.Value = null;
+            }
             return query.Result();
         }
     }