/// <summary>
/// Gets the all expectations for a mocked object and method combination,
/// regardless of the expected arguments / callbacks / contraints.
/// </summary>
/// <param name="proxy">Mocked object.</param>
/// <param name="method">Method.</param>
/// <returns>List of all relevant expectation</returns>
public override ExpectationsList GetAllExpectationsForProxyAndMethod(object proxy, MethodInfo method)
{
Validate.IsNotNull(proxy, "proxy");
Validate.IsNotNull(method, "method");
ExpectationsList expectations = new ExpectationsList();
foreach (object action in recordedActions)
{
ProxyMethodExpectationTriplet triplet = action as ProxyMethodExpectationTriplet;
if (triplet != null)
{
if (MockedObjectsEquality.Instance.Equals(triplet.Proxy, proxy) &&
MethodsEquals(method, triplet))
{
expectations.Add(triplet.Expectation);
}
}
else //Action is another recorder
{
IMethodRecorder innerRecorder = (IMethodRecorder)action;
expectations.AddRange(innerRecorder.GetAllExpectationsForProxyAndMethod(proxy, method));
}
}
return(expectations);
}
/// <summary>
/// Gets the all expectations for proxy.
/// </summary>
/// <param name="proxy">Mocked object.</param>
/// <returns>List of all relevant expectation</returns>
protected override ExpectationsList DoGetAllExpectationsForProxy(object proxy)
{
Validate.IsNotNull(proxy, "proxy");
ExpectationsList expectations = new ExpectationsList();
foreach (object action in recordedActions)
{
ProxyMethodExpectationTriplet triplet = action as ProxyMethodExpectationTriplet;
if (triplet != null)
{
if (MockedObjectsEquality.Instance.Equals(triplet.Proxy, proxy))
{
expectations.Add(triplet.Expectation);
}
}
else //Action is another recorder
{
IMethodRecorder innerRecorder = (IMethodRecorder)action;
ExpectationsList expectationsForProxy = innerRecorder.GetAllExpectationsForProxy(proxy);
expectations.AddRange(expectationsForProxy);
}
}
return(expectations);
}
private static bool MethodsEquals(MethodInfo method, ProxyMethodExpectationTriplet triplet)
{
if (method.IsGenericMethod == false)
{
return(triplet.Method == method);
}
return(triplet.Method.GetGenericMethodDefinition() == method.GetGenericMethodDefinition());
}
/// <summary>
/// Records the specified call with the specified args on the mocked object.
/// </summary>
/// <param name="proxy">Mocked object.</param>
/// <param name="method">Method.</param>
/// <param name="expectation">Expectation.</param>
protected override void DoRecord(object proxy, MethodInfo method, IExpectation expectation)
{
Validate.IsNotNull(proxy, "proxy");
Validate.IsNotNull(method, "method");
Validate.IsNotNull(expectation, "expectation");
ProxyMethodExpectationTriplet entry = new ProxyMethodExpectationTriplet(proxy, method, expectation);
recordedActions.Add(entry);
}
/// <summary>
/// Determines if the object equal to this instance
/// </summary>
/// <param name="obj">Obj.</param>
/// <returns></returns>
public override bool Equals(object obj)
{
ProxyMethodExpectationTriplet other = obj as ProxyMethodExpectationTriplet;
if (other == null)
{
return(false);
}
return(method == other.method &&
MockedObjectsEquality.Instance.Compare(proxy, other.proxy) == 0 &&
expectation == other.expectation);
}
/// <summary>
/// Handle the real execution of this method for the derived class
/// </summary>
protected override void DoRemoveExpectation(IExpectation expectation)
{
for (int i = 0; i < recordedActions.Count; i++)
{
ProxyMethodExpectationTriplet triplet = recordedActions[i] as ProxyMethodExpectationTriplet;
if (triplet != null)
{
if (triplet.Expectation == expectation)
{
recordedActions.RemoveAt(i);
}
}
//Action cannot be another recorder, since then the RemoveExpectation would've
//passed us to the top most recorder.
}
}
/// <summary>
/// Gets the next expected calls string.
/// </summary>
public override string GetExpectedCallsMessage()
{
StringBuilder sb = new StringBuilder();
sb.Append("Unordered: { ");
foreach (object action in recordedActions)
{
ProxyMethodExpectationTriplet triplet = action as ProxyMethodExpectationTriplet;
if (triplet != null)
{
sb.Append(triplet.Expectation.ErrorMessage);
}
else
{
string nested = ((IMethodRecorder)action).GetExpectedCallsMessage();
sb.Append(nested);
}
}
sb.Append(" }");
return(sb.ToString());
}
/// <summary>
/// Replaces the old expectation with the new expectation for the specified proxy/method pair.
/// This replace ALL expectations that equal to old expectations.
/// </summary>
/// <param name="proxy">Proxy.</param>
/// <param name="method">Method.</param>
/// <param name="oldExpectation">Old expectation.</param>
/// <param name="newExpectation">New expectation.</param>
protected override void DoReplaceExpectation(object proxy, MethodInfo method, IExpectation oldExpectation, IExpectation newExpectation)
{
Validate.IsNotNull(proxy, "proxy");
Validate.IsNotNull(method, "method");
Validate.IsNotNull(oldExpectation, "oldExpectation");
Validate.IsNotNull(newExpectation, "newExpectation");
foreach (object action in recordedActions)
{
ProxyMethodExpectationTriplet triplet = action as ProxyMethodExpectationTriplet;
if (triplet != null)
{
if (MockedObjectsEquality.Instance.Equals(triplet.Proxy, proxy) &&
triplet.Method == method &&
triplet.Expectation == oldExpectation)
{
triplet.Expectation = newExpectation;
}
}
//Action cannot be another recorder, since then the RemoveExpectation would've
//passed us to the top most recorder.
}
}
/// <summary>
/// Gets the next expected calls string.
/// </summary>
public override string GetExpectedCallsMessage()
{
StringBuilder sb = new StringBuilder();
sb.Append("Ordered: { ");
if (recordedActions.Count > 0)
{
ProxyMethodExpectationTriplet triplet = recordedActions[0] as ProxyMethodExpectationTriplet;
if (triplet != null)
{
sb.Append(triplet.Expectation.ErrorMessage);
}
else //Action is another recorder
{
sb.Append(((IMethodRecorder)recordedActions[0]).GetExpectedCallsMessage());
}
}
else
{
sb.Append("No method call is expected");
}
sb.Append(" }");
return(sb.ToString());
}
public void EqualsTest()
{
ProxyInstance proxy1 = new ProxyInstance(null);
ProxyInstance proxy2 = new ProxyInstance(null);
MethodInfo method1 = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) }),
method2 = endsWith;
IExpectation expectation1 = new AnyArgsExpectation(new FakeInvocation(method1), new Range(1, 1)),
expectation2 = new AnyArgsExpectation(new FakeInvocation(method2), new Range(1, 1));
ProxyMethodExpectationTriplet same1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
same2 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1);
Assert.AreEqual(same1, same2);
Assert.AreEqual(same2, same1);
ProxyMethodExpectationTriplet proxyDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
proxyDiff2 = new ProxyMethodExpectationTriplet(proxy2, method1, expectation1);
Assert.AreNotEqual(proxyDiff2, proxyDiff1);
Assert.AreNotEqual(proxyDiff1, proxyDiff2);
ProxyMethodExpectationTriplet methodDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
methodDiff2 = new ProxyMethodExpectationTriplet(proxy1, method2, expectation1);
Assert.AreNotEqual(methodDiff1, methodDiff2);
Assert.AreNotEqual(methodDiff2, methodDiff1);
ProxyMethodExpectationTriplet expectationDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
expectationDiff2 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation2);
Assert.AreNotEqual(expectationDiff1, expectationDiff2);
Assert.AreNotEqual(expectationDiff2, expectationDiff1);
ProxyMethodExpectationTriplet allDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
allDiff2 = new ProxyMethodExpectationTriplet(proxy2, method2, expectation2);
Assert.AreNotEqual(allDiff1, allDiff2);
Assert.AreNotEqual(allDiff2, allDiff1);
}
public void FalseOnEqualToNull()
{
ProxyMethodExpectationTriplet triplet = new ProxyMethodExpectationTriplet(proxy, this.endsWith, this.expectation);
Assert.IsFalse(triplet.Equals(null));
}
private static bool MethodsEquals(MethodInfo method, ProxyMethodExpectationTriplet triplet)
{
if(method.IsGenericMethod==false)
return triplet.Method == method;
return triplet.Method.GetGenericMethodDefinition() == method.GetGenericMethodDefinition();
}
/// <summary>
/// Records the specified call with the specified args on the mocked object.
/// </summary>
/// <param name="proxy">Mocked object.</param>
/// <param name="method">Method.</param>
/// <param name="expectation">Expectation.</param>
protected override void DoRecord(object proxy, MethodInfo method, IExpectation expectation)
{
Validate.IsNotNull(proxy, "proxy");
Validate.IsNotNull(method, "method");
Validate.IsNotNull(expectation, "expectation");
ProxyMethodExpectationTriplet entry = new ProxyMethodExpectationTriplet(proxy, method, expectation);
recordedActions.Add(entry);
}
/// <summary>
/// Handles the real getting of the recorded expectation or null.
/// </summary>
protected override IExpectation DoGetRecordedExpectationOrNull(object proxy, MethodInfo method, object[] args)
{
int actionPos = 0;
while (actionPos < recordedActions.Count)
{
ProxyMethodExpectationTriplet triplet = recordedActions[actionPos] as ProxyMethodExpectationTriplet;
if (triplet != null)
{
if (MockedObjectsEquality.Instance.Equals(triplet.Proxy, proxy) &&
triplet.Method == method &&
triplet.Expectation.CanAcceptCalls &&
triplet.Expectation.IsExpected(args))
{
// Ensure that this expectation is the first one in the list.
while (actionPos > 0)
{
recordedActions.RemoveAt(0);
actionPos--;
}
// This call satisfies that expectation.
triplet.Expectation.AddActualCall();
// Is this expectation complete?
if (!triplet.Expectation.CanAcceptCalls)
{
recordedActions.RemoveAt(0);
}
return(triplet.Expectation);
}
else
{
// The expectation didn't match. Is the expectation satisfied, so can we consider
// looking at the next expectation?
if (triplet.Expectation.ExpectationSatisfied)
{
actionPos++;
}
else
{
// No.
return(null);
}
}
}
else // Action is another recorder
{
IMethodRecorder innerRecorder = (IMethodRecorder)recordedActions[actionPos];
if (innerRecorder.HasExpectations == false) // so don't need to consider it
{
actionPos++;
continue;
}
if (ShouldConsiderThisReplayer(innerRecorder) == false)
{
break;
}
IExpectation expectation = innerRecorder.GetRecordedExpectationOrNull(proxy, method, args);
if (expectation != null)
{
// Ensure that this expectation is the first one in the list.
while (actionPos > 0)
{
recordedActions.RemoveAt(0);
actionPos--;
}
replayerToCall = innerRecorder;
recordedActions.RemoveAt(0);
return(expectation);
}
break;
}
}
if (parentRecorder == null)
{
return(null);
}
// We only reach this place if we still has valid expectations, but they are not
// mandatory, (AtLeastOnce(), etc). In this case, the recorder (and its children) cannot satisfy the
// expectation, so we move to the parent recorder and let it handle it.
parentRecorder.ClearReplayerToCall(this);
// We need this to give the correct exception if the method is an unepxected one.
// Check the redirection in UnexpectedMethodCall()
parentRecorderRedirection = parentRecorder;
return(parentRecorder.GetRecordedExpectationOrNull(proxy, method, args));
}
public void ReturnSamevaluesAsInCtor()
{
ProxyMethodExpectationTriplet triplet = new ProxyMethodExpectationTriplet(proxy, this.endsWith, this.expectation);
Assert.AreEqual(proxy, triplet.Proxy);
Assert.AreEqual(endsWith, triplet.Method);
Assert.AreEqual(expectation, triplet.Expectation);
}
/// <summary>
/// Handles the real getting of the recorded expectation or null.
/// </summary>
protected override IExpectation DoGetRecordedExpectationOrNull(object proxy, MethodInfo method, object[] args)
{
Validate.IsNotNull(proxy, "proxy");
Validate.IsNotNull(method, "method");
Validate.IsNotNull(args, "args");
// Need this because we may want to modify the recordedAction list as we traverse it
// See: ClearReplayerToCall();
ArrayList traversalSafeCopy = new ArrayList(recordedActions);
bool allSatisfied = true;
foreach (object action in traversalSafeCopy)
{
ProxyMethodExpectationTriplet triplet = action as ProxyMethodExpectationTriplet;
if (triplet != null)
{
if (MockedObjectsEquality.Instance.Equals(triplet.Proxy, proxy) &&
triplet.Method == method &&
triplet.Expectation.CanAcceptCalls &&
triplet.Expectation.IsExpected(args))
{
triplet.Expectation.AddActualCall();
return(triplet.Expectation);
}
if (!triplet.Expectation.ExpectationSatisfied)
{
allSatisfied = false;
}
}
else //Action is another recorder
{
IMethodRecorder innerRecorder = (IMethodRecorder)action;
if (ShouldConsiderThisReplayer(innerRecorder) == false)
{
continue;
}
IExpectation expectation = innerRecorder.GetRecordedExpectationOrNull(proxy, method, args);
if (expectation != null)
{
replayerToCall = innerRecorder;
return(expectation);
}
if (innerRecorder.HasExpectations)
{
allSatisfied = false;
}
}
}
// We still have unsatisifed expectation or we don't have a parent recorder
if (!allSatisfied || parentRecorder == null)
{
return(null);
}
// We only reach this place if we still has valid expectations, but they are not
// mandatory, (AtLeastOnce(), etc). In this case, the recorder (and its children) cannot satisfy the
// expectation, so we move to the parent recorder and let it handle it.
parentRecorder.ClearReplayerToCall(this);
// We need this to give the correct exception if the method is an unepxected one.
// Check the redirection in UnexpectedMethodCall()
parentRecorderRedirection = parentRecorder;
return(parentRecorder.GetRecordedExpectationOrNull(proxy, method, args));
}
public void GetHashCodeReturnSameValue()
{
ProxyMethodExpectationTriplet triplet = new ProxyMethodExpectationTriplet(proxy, this.endsWith, this.expectation);
Assert.AreEqual(triplet.GetHashCode(), triplet.GetHashCode());
}
