Index: Rhino.Mocks.Tests/OrderingExpectationTest.cs =================================================================== --- Rhino.Mocks.Tests/OrderingExpectationTest.cs (revision 0) +++ Rhino.Mocks.Tests/OrderingExpectationTest.cs (revision 0) @@ -0,0 +1,93 @@ +#if DOTNET35 +using MbUnit.Framework; +using Rhino.Mocks.Exceptions; + +namespace Rhino.Mocks.Tests +{ + [TestFixture] public class OrderingExpectationTest + { + public interface IBefore { void MethodBefore(); } + + public interface IAfter { void MethodAfter(); } + + private IBefore mockBefore; + private IAfter mockAfter; + + [SetUp] public void SetUp() + { + mockBefore = MockRepository.GenerateStub(); + mockAfter = MockRepository.GenerateStub(); + } + + [Test] public void Before_and_After_succeeds_if_all_beforeCalls_occurred_before_afterCalls() + { + AllBeforeThenAllAfter(); + + mockBefore.AssertWasCalled(b => b.MethodBefore()) + .Before(mockAfter.AssertWasCalled(a => a.MethodAfter())); + + mockAfter.AssertWasCalled(a => a.MethodAfter()) + .After(mockBefore.AssertWasCalled(b => b.MethodBefore())); + } + + [Test] public void Before_and_After_succeeds_if_before_occurred_before_after() + { + BeforeAfterInterlaced(); + + mockBefore.AssertWasCalled(b => b.MethodBefore()).First() + .Before(mockAfter.AssertWasCalled(a => a.MethodAfter()).First()) + .Before(mockBefore.AssertWasCalled(b => b.MethodBefore()).Last()); + + mockAfter.AssertWasCalled(a => a.MethodAfter()).Last() + .After(mockBefore.AssertWasCalled(b => b.MethodBefore()).Last()) + .After(mockAfter.AssertWasCalled(a=>a.MethodAfter()).First()); + } + + [Test] public void Before_and_After_chokes_if_one_of_beforeCalls_occurred_after_any_of_afterCalls() + { + BeforeAfterInterlaced(); + Throws.Exception(delegate{ + mockBefore.AssertWasCalled(b => b.MethodBefore()) + .Before(mockAfter.AssertWasCalled(a => a.MethodAfter())); + }); + Throws.Exception(delegate + { + mockAfter.AssertWasCalled(a => a.MethodAfter()) + .After(mockBefore.AssertWasCalled(b => b.MethodBefore())); + }); + } + + [Test] public void Before_and_After_chokes_if_before_occurred_after_after() + { + BeforeAfterInterlaced(); + Throws.Exception(delegate{ + mockBefore.AssertWasCalled(b => b.MethodBefore()).Last() + .Before(mockAfter.AssertWasCalled(a => a.MethodAfter()).First()); + }); + Throws.Exception(delegate + { + mockAfter.AssertWasCalled(a => a.MethodAfter()).First() + .After(mockBefore.AssertWasCalled(b => b.MethodBefore()).Last()); + }); + } + + private void AllBeforeThenAllAfter() + { + mockBefore.MethodBefore(); + mockBefore.MethodBefore(); + mockAfter.MethodAfter(); + mockAfter.MethodAfter(); + mockAfter.MethodAfter(); + } + + private void BeforeAfterInterlaced() + { + mockBefore.MethodBefore(); + mockAfter.MethodAfter(); + mockBefore.MethodBefore(); + mockAfter.MethodAfter(); + mockAfter.MethodAfter(); + } + } +} +#endif Index: Rhino.Mocks.Tests/PartialMockTests.cs =================================================================== --- Rhino.Mocks.Tests/PartialMockTests.cs (revision 2212) +++ Rhino.Mocks.Tests/PartialMockTests.cs (working copy) @@ -28,6 +28,7 @@ using System; +using System.Collections.Generic; using System.Text; using System.Windows.Forms; using MbUnit.Framework; @@ -105,6 +106,38 @@ Assert.AreEqual(4, withParameters.Int); mocks.VerifyAll(); } + + [Test] + public void CanMockGenericMethodWithListArrayArgument() + { + var mock = mocks.PartialMock(); + mocks.ReplayAll(); + mock.GenericMethodWithListArrayArgument(null); + } + + [Test] + public void CanMockGenericMethodWithGenericOfGenericArgument() + { + var mock = mocks.PartialMock(); + mocks.ReplayAll(); + mock.GenericMethodWithGenericOfGenericArgument(null); + } + + [Test] + public void CanMockGenericMethodReturnsListArray() + { + var mock = mocks.PartialMock(); + mocks.ReplayAll(); + mock.GenericMethodReturnsListArray(); + } + + [Test] + public void CanMockGenericMethodReturnsGenericOfGenericType() + { + var mock = mocks.PartialMock(); + mocks.ReplayAll(); + mock.GenericMethodReturnsGenericOfGenericType(); + } } public abstract class AbstractClass @@ -141,4 +174,15 @@ set { i = value; } } } + + public abstract class ComplexClass + { + public virtual void GenericMethodWithListArrayArgument(List[] action) { } + public virtual void GenericMethodWithGenericOfGenericArgument(IEnumerable> compararers) { } + public virtual List[] GenericMethodReturnsListArray() { return null; } + public virtual IEnumerable> GenericMethodReturnsGenericOfGenericType() { return null; } + + /* ... */ + } + } Index: Rhino.Mocks.Tests/Rhino.Mocks.Tests 3.5.csproj =================================================================== --- Rhino.Mocks.Tests/Rhino.Mocks.Tests 3.5.csproj (revision 2212) +++ Rhino.Mocks.Tests/Rhino.Mocks.Tests 3.5.csproj (working copy) @@ -117,6 +117,7 @@ + Code Index: Rhino.Mocks/CallRecord.cs =================================================================== --- Rhino.Mocks/CallRecord.cs (revision 0) +++ Rhino.Mocks/CallRecord.cs (revision 0) @@ -0,0 +1,22 @@ +using System.Reflection; +using System.Threading; +using Rhino.Mocks.Interfaces; + +namespace Rhino.Mocks +{ + /// + /// Record about information of a specific method invokation + /// + public class CallRecord + { + private static long sequencer = long.MinValue; + + internal CallRecord() + { + Sequence = Interlocked.Increment(ref sequencer); + } + internal object[] Arguments { get; set; } + internal long Sequence { get; private set; } + internal MethodInfo Method { get; set; } + } +} \ No newline at end of file Index: Rhino.Mocks/ExpectationVerificationInformation.cs =================================================================== --- Rhino.Mocks/ExpectationVerificationInformation.cs (revision 2212) +++ Rhino.Mocks/ExpectationVerificationInformation.cs (working copy) @@ -10,6 +10,23 @@ private IList argumentsForAllCalls; public IExpectation Expected { get { return expected; } set { expected = value; } } - public IList ArgumentsForAllCalls { get { return argumentsForAllCalls; } set { argumentsForAllCalls = value; } } + public ICollection AllCallRecords { get; set; } + public IList ArgumentsForAllCalls + { + get + { + if (argumentsForAllCalls==null) + { + var allCalls = AllCallRecords; + var a = new List(allCalls.Count); + foreach (var call in allCalls) + { + a.Add(call.Arguments); + } + argumentsForAllCalls = a; + } + return argumentsForAllCalls; + } + } } } Index: Rhino.Mocks/Impl/ProxyInstance.cs =================================================================== --- Rhino.Mocks/Impl/ProxyInstance.cs (revision 2212) +++ Rhino.Mocks/Impl/ProxyInstance.cs (working copy) @@ -51,7 +51,7 @@ private IDictionary eventsSubscribers; private readonly Type[] implemented; - private readonly IDictionary> methodToActualCalls = new Dictionary>(); + private readonly IDictionary> methodToActualCalls = new Dictionary>(); private object[] constructorArguments = new object[0]; private IList dependentMocks = new List(); @@ -284,10 +284,10 @@ /// /// Only method calls in replay mode are counted /// - public ICollection GetCallArgumentsFor(MethodInfo method) + public ICollection GetCallArgumentsFor(MethodInfo method) { if (methodToActualCalls.ContainsKey(method) == false) - return new List(); + return new List(); return methodToActualCalls[method]; } @@ -302,8 +302,11 @@ if(repository.IsInReplayMode(this)==false) return; if (methodToActualCalls.ContainsKey(method) == false) - methodToActualCalls[method] = new List(); - methodToActualCalls[method].Add(args); + methodToActualCalls[method] = new List(); + methodToActualCalls[method].Add(new CallRecord{ + Arguments = args, + Method = method, + }); } /// Index: Rhino.Mocks/Interfaces/IMockedObject.cs =================================================================== --- Rhino.Mocks/Interfaces/IMockedObject.cs (revision 2212) +++ Rhino.Mocks/Interfaces/IMockedObject.cs (working copy) @@ -128,7 +128,7 @@ /// /// Only method calls in replay mode are counted /// - ICollection GetCallArgumentsFor(MethodInfo method); + ICollection GetCallArgumentsFor(MethodInfo method); /// /// Records the method call Index: Rhino.Mocks/Rhino.Mocks 2.0.csproj =================================================================== --- Rhino.Mocks/Rhino.Mocks 2.0.csproj (revision 2212) +++ Rhino.Mocks/Rhino.Mocks 2.0.csproj (working copy) @@ -74,6 +74,7 @@ + Code @@ -139,6 +140,7 @@ + @@ -255,6 +257,7 @@ Code + ayende-open-source.snk @@ -264,4 +267,4 @@ - + \ No newline at end of file Index: Rhino.Mocks/Rhino.Mocks 3.5.csproj =================================================================== --- Rhino.Mocks/Rhino.Mocks 3.5.csproj (revision 2212) +++ Rhino.Mocks/Rhino.Mocks 3.5.csproj (working copy) @@ -22,13 +22,15 @@ v3.5 + + bin\debug\ false 285212672 false - TRACE;DEBUG;DOTNET35 + TRACE;DEBUG;DOTNET35, FOR_NET_2_0 bin\debug\Rhino.Mocks.XML true 4096 @@ -52,7 +54,7 @@ true false false - false + true 4 pdbonly Rhino.Mocks.XML @@ -77,6 +79,7 @@ + Code @@ -266,6 +269,7 @@ + Index: Rhino.Mocks/RhinoMocksExtensions.cs =================================================================== --- Rhino.Mocks/RhinoMocksExtensions.cs (revision 2212) +++ Rhino.Mocks/RhinoMocksExtensions.cs (working copy) @@ -213,9 +213,13 @@ /// /// The mock. /// The action. - public static void AssertWasCalled(this T mock, Action action) + /// + /// One or more s for all the calls that have + /// been made in the order of the time the calls are made. + /// + public static IList AssertWasCalled(this T mock, Action action) { - AssertWasCalled(mock, action, DefaultConstraintSetup); + return AssertWasCalled(mock, action, DefaultConstraintSetup); } private static void DefaultConstraintSetup(IMethodOptions options) @@ -230,19 +234,24 @@ /// The mock. /// The action. /// The setup constraints. - public static void AssertWasCalled(this T mock, Action action, Action> setupConstraints) + /// + /// One or more (s) for all the matched calls + /// in the order of time the calles are made. + /// + public static IList AssertWasCalled(this T mock, Action action, Action> setupConstraints) { ExpectationVerificationInformation verificationInformation = GetExpectationsToVerify(mock, action, setupConstraints); - - foreach (var args in verificationInformation.ArgumentsForAllCalls) + List records = new List(); + foreach (var record in verificationInformation.AllCallRecords) { - if (verificationInformation.Expected.IsExpected(args)) + if (verificationInformation.Expected.IsExpected(record.Arguments)) { verificationInformation.Expected.AddActualCall(); + records.Add(record); } } if (verificationInformation.Expected.ExpectationSatisfied) - return; + return records; throw new ExpectationViolationException(verificationInformation.Expected.BuildVerificationFailureMessage()); } @@ -253,10 +262,14 @@ /// /// The mock. /// The action. - public static void AssertWasCalled(this T mock, Func action) + /// + /// One or more s for all the calls that have + /// been made in the order of the time the calls are made. + /// + public static IList AssertWasCalled(this T mock, Function action) { var newAction = new Action(t => action(t)); - AssertWasCalled(mock, newAction, DefaultConstraintSetup); + return AssertWasCalled(mock, newAction, DefaultConstraintSetup); } /// @@ -267,14 +280,17 @@ /// The mock. /// The action. /// The setup constraints. - public static void AssertWasCalled(this T mock, Func action, Action> setupConstraints) + /// + /// One or more (s) for all the matched calls + /// in the order of time the calles are made. + /// + public static IList AssertWasCalled(this T mock, Function action, Action> setupConstraints) { var newAction = new Action(t => action(t)); - AssertWasCalled(mock, newAction, setupConstraints); + return AssertWasCalled(mock, newAction, setupConstraints); } - - /// + /// /// Asserts that a particular method was NOT called on this mock object /// /// @@ -312,7 +328,7 @@ /// /// The mock. /// The action. - public static void AssertWasNotCalled(this T mock, Func action) + public static void AssertWasNotCalled(this T mock, Function action) { var newAction = new Action(t => action(t)); AssertWasNotCalled(mock, newAction, DefaultConstraintSetup); @@ -325,7 +341,7 @@ /// The mock. /// The action. /// The setup constraints. - public static void AssertWasNotCalled(this T mock, Func action, Action> setupConstraints) + public static void AssertWasNotCalled(this T mock, Function action, Action> setupConstraints) { var newAction = new Action(t => action(t)); AssertWasNotCalled(mock, newAction, setupConstraints); @@ -361,10 +377,10 @@ throw new InvalidOperationException( "The expectation was removed from the waiting expectations list, did you call Repeat.Any() ? This is not supported in AssertWasCalled()"); IExpectation expected = expectationsToVerify[0]; - ICollection argumentsForAllCalls = mockedObject.GetCallArgumentsFor(expected.Method); + ICollection argumentsForAllCalls = mockedObject.GetCallArgumentsFor(expected.Method); return new ExpectationVerificationInformation { - ArgumentsForAllCalls = new List(argumentsForAllCalls), + AllCallRecords = new List(argumentsForAllCalls), Expected = expected }; } @@ -449,6 +465,106 @@ eventRaiser.Raise(args); } + /// + /// Assert that all calls specified by + /// occurred before all calls specified by + /// + /// + /// Calls that happens before + /// + /// + /// Calls that happens after + /// + public static IList Before(this IList beforeCalls, IList afterCalls) + { + Ordered(Last(beforeCalls), First(afterCalls)); + return afterCalls; + } + + /// + /// Assert that all calls specified by + /// occurred after all calls specified by + /// + /// + /// Calls that happens after + /// + /// + /// Calls that happens before + /// + public static IList After(this IList afterCalls, IList beforeCalls) + { + Ordered(Last(beforeCalls), First(afterCalls)); + return beforeCalls; + } + + /// + /// Assert that the call specified by + /// occurred before the call specified by + /// + /// + /// Call that occurred before + /// + /// + /// Call that occurred after + /// + public static CallRecord Before(this CallRecord before, CallRecord after) + { + Ordered(before, after); + return after; + } + + /// + /// Assert that the call specified by + /// occurred after the call specified by + /// + /// + /// Call that occurred after + /// + /// + /// Call that occurred before + /// + public static CallRecord After(this CallRecord after, CallRecord before) + { + Ordered(before, after); + return before; + } + + /// + /// Returns the last executed call in the . + /// + /// + /// A list of call records ordered by the time they were executed. + /// + /// The last call executed in + public static CallRecord Last(this IList callRecords) + { + return callRecords[callRecords.Count - 1]; + } + + /// + /// Returns the first executed call in the . + /// + /// + /// A list of call records ordered by the time they were executed. + /// + /// The first call executed in + public static CallRecord First(this IList callRecords) + { + return callRecords[0]; + } + + private static void Ordered(CallRecord before, CallRecord after) + { + if (before.Sequence > after.Sequence) + { + throw new ExpectationViolationException( + "Expected that call " + before.Method + + " occurs before call " + after.Method + + ", but the expectation is not satisfied."); + + } + } + private static void AssertExactlySingleExpectaton(MockRepository mocks, T mockToRecordExpectation) { if (mocks.Replayer.GetAllExpectationsForProxy(mockToRecordExpectation).Count == 0)