stakx · Mar 9, 2019 · Mar 9, 2019 · Mar 9, 2019 · Mar 9, 2019 · Mar 9, 2019
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -16,7 +16,7 @@ This release contains several **minor breaking changes**. Please review your cod
 * `mock.Verify[All]` now performs a more thorough error aggregation. Error messages of inner/recursive mocks are included in the error message using indentation to show the relationship between mocks. (@stakx, #762)
 * `mock.Verify` no longer creates setups, nor will it override existing setups, as a side-effect of using a recursive expression. (@stakx, #765)
 * More accurate detection of argument matchers with `SetupSet` and `VerifySet`, especially when used in fluent setup expressions or with indexers (@stakx, #767)
-* `mock.Verify(expression)` no longer includes setups in its error message, as they are completely irrelevant in the context of this method (@stakx, #779)
+* `mock.Verify(expression)` error messages now contain a full listing of all invocations that occurred across all involved mocks. Setups are no longer listed, since they are completely irrelevant in the context of call verification. (@stakx, #779, #780)
 
 #### Added
 

diff --git a/src/Moq/AsInterface.cs b/src/Moq/AsInterface.cs
@@ -2,9 +2,7 @@
 // All rights reserved. Licensed under the BSD 3-Clause License; see License.txt.
 
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Reflection;
 
 namespace Moq
 {
@@ -74,5 +72,10 @@ protected override object OnGetObject()
 		{
 			return this.owner.Object;
 		}
+
+		public override string ToString()
+		{
+			return this.owner.ToString();
+		}
 	}
 }
diff --git a/src/Moq/Extensions.cs b/src/Moq/Extensions.cs
@@ -273,11 +273,26 @@ private static void AddPropertiesInDepthFirstOrderTo(this Type type, List<Proper
 			}
 		}
 
-		public static bool TryFind(this IEnumerable<IDeterministicReturnValueSetup> setups, MethodInfo method, out IDeterministicReturnValueSetup setup)
+		public static bool TryFind(this IEnumerable<IDeterministicReturnValueSetup> setups, InvocationShape expectation, out IDeterministicReturnValueSetup setup)
 		{
 			foreach (Setup s in setups)
 			{
-				if (s.Method == method)
+				if (s.Expectation.Equals(expectation))
+				{
+					setup = (IDeterministicReturnValueSetup)s;
+					return true;
+				}
+			}
+
+			setup = default;
+			return false;
+		}
+
+		public static bool TryFind(this IEnumerable<IDeterministicReturnValueSetup> setups, Invocation invocation, out IDeterministicReturnValueSetup setup)
+		{
+			foreach (Setup s in setups)
+			{
+				if (s.Matches(invocation))
 				{
 					setup = (IDeterministicReturnValueSetup)s;
 					return true;

diff --git a/src/Moq/FluentMockVisitor.cs b/src/Moq/FluentMockVisitor.cs
@@ -172,7 +172,7 @@ private static Mock<TResult> FluentMock<T, TResult>(Mock<T> mock, Expression<Fun
 
 			Mock fluentMock;
 			object result;
-			if (mock.GetInnerMockSetups().TryFind(info, out var inner))
+			if (mock.GetInnerMockSetups().TryFind(new InvocationShape(setup, info, arguments), out var inner))
 			{
 				fluentMock = inner.GetInnerMock();
 				result = inner.ReturnValue;

diff --git a/src/Moq/ImmutablePoppableStack.cs b/src/Moq/ImmutablePoppableStack.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2007, Clarius Consulting, Manas Technology Solutions, InSTEDD.
+// All rights reserved. Licensed under the BSD 3-Clause License; see License.txt.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Moq
+{
+	internal readonly struct ImmutablePopOnlyStack<T>
+	{
+		private readonly T[] items;
+		private readonly int index;
+
+		public ImmutablePopOnlyStack(IEnumerable<T> items)
+			Debug.Assert(items != null);
+
+			this.items = items.ToArray();
+			this.index = 0;
+		}
+
+		private ImmutablePopOnlyStack(T[] items, int index)
+		{
+			Debug.Assert(items != null);
+			Debug.Assert(0 <= index && index <= items.Length);
+
+			this.items = items;
+			this.index = index;
+		}
+
+		public bool Empty => this.index == this.items.Length;
+
+		public T Pop(out ImmutablePopOnlyStack<T> stackBelowTop)
+		{
+			Debug.Assert(this.index < this.items.Length);
+
+			var top = this.items[this.index];
+			stackBelowTop = new ImmutablePopOnlyStack<T>(this.items, this.index + 1);
+			return top;
+		}
+	}
+}
diff --git a/src/Moq/Interception/InterceptionAspects.cs b/src/Moq/Interception/InterceptionAspects.cs
@@ -332,7 +332,7 @@ public override InterceptionAction Handle(Invocation invocation, Mock mock)
 				var returnValue = mock.GetDefaultValue(method, out var innerMock);
 				if (innerMock != null)
 				{
-					mock.AddInnerMockSetup(method, returnValue);
+					mock.AddInnerMockSetup(invocation, returnValue);
 				}
 				invocation.Return(returnValue);
 			}

diff --git a/src/Moq/Invocation.cs b/src/Moq/Invocation.cs
@@ -1,7 +1,6 @@
 // Copyright (c) 2007, Clarius Consulting, Manas Technology Solutions, InSTEDD.
 // All rights reserved. Licensed under the BSD 3-Clause License; see License.txt.
 
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
@@ -13,6 +12,7 @@ internal abstract class Invocation : IInvocation
 	{
 		private object[] arguments;
 		private MethodInfo method;
+		private object returnValue;
 		private VerificationState verificationState;
 
 		/// <summary>
@@ -45,6 +45,8 @@ protected Invocation(MethodInfo method, params object[] arguments)
 
 		IReadOnlyList<object> IInvocation.Arguments => this.arguments;
 
+		public object ReturnValue => this.returnValue;
+
 		internal bool Verified => this.verificationState == VerificationState.Verified;
 
 		/// <summary>
@@ -79,6 +81,7 @@ protected Invocation(MethodInfo method, params object[] arguments)
 		/// and that no more calls to any of the three <c>Return</c> methods will be made.
 		/// <para>
 		/// Implementations must ensure that any by-reference parameters are written back from <see cref="Arguments"/>.
+		/// Implementations must also call <see cref="SetReturnValue(object)"/>.
 		/// </para>
 		/// </remarks>
 		public abstract void Return(object value);
@@ -119,6 +122,13 @@ internal void MarkAsVerifiedIfMatchedByVerifiableSetup()  // this supports the `
 			}
 		}
 
+		protected void SetReturnValue(object returnValue)
+		{
+			Debug.Assert(this.returnValue == null);  // quick & dirty check against double invocations
+
+			this.returnValue = returnValue;
+		}
+
 		/// <inheritdoc/>
 		public override string ToString()
 		{