public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, "fakeObjectCall");
var returnValue = ResolveReturnValue(fakeObjectCall);
fakeObjectCall.SetReturnValue(returnValue);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall));
var returnType = fakeObjectCall.Method.ReturnType;
if (typeof(Task).GetTypeInfo().IsAssignableFrom(returnType))
{
Task task;
if (returnType == typeof(Task))
{
task = TaskHelper.Canceled();
}
else
{
var taskResultType = returnType.GetTypeInfo().GetGenericArguments()[0];
task = TaskHelper.Canceled(taskResultType);
}
fakeObjectCall.SetReturnValue(task);
}
else
{
var token = GetCanceledTokens(fakeObjectCall).First();
token.ThrowIfCancellationRequested();
}
}
/// <summary>
/// Applies an action to the call, might set a return value or throw
/// an exception.
/// </summary>
/// <param name="fakeObjectCall">The call to apply the interceptor to.</param>
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, "fakeObjectCall");
var parameters = fakeObjectCall.Arguments.GetUnderlyingArgumentsArray();
var valueFromWrappedInstance = fakeObjectCall.Method.Invoke(this.wrappedObject, parameters);
fakeObjectCall.SetReturnValue(valueFromWrappedInstance);
}
void IFakeObjectCallRule.Apply(IInterceptedFakeObjectCall invocation)
{
this.ApplyWasCalled = true;
if (this.Apply != null)
{
this.Apply(invocation);
}
}
public static object ResolveReturnValue(IInterceptedFakeObjectCall fakeObjectCall)
{
object result;
if (!FakeManager.TryCreateDummy(fakeObjectCall.Method.ReturnType, out result))
{
return fakeObjectCall.Method.ReturnType.GetDefaultValue();
}
return result;
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
var newRule = new CallRuleMetadata
{
CalledNumberOfTimes = 1,
Rule = new PropertyBehaviorRule(fakeObjectCall.Method, this.FakeManager) { Value = fakeObjectCall.Arguments[0] }
};
this.FakeManager.allUserRulesField.AddFirst(newRule);
}
private bool TryHandleToString(IInterceptedFakeObjectCall fakeObjectCall)
{
if (!fakeObjectCall.Method.MethodHandle.Equals(ObjectMethodsMethodHandles[1]))
{
return false;
}
fakeObjectCall.SetReturnValue("Faked {0}".FormatInvariant(this.FakeManager.FakeObjectType.FullName));
return true;
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
var newRule = new CallRuleMetadata
{
Rule = new PropertyBehaviorRule(fakeObjectCall.Method, FakeManager) { Value = CreateFake(fakeObjectCall.Method.ReturnType) },
CalledNumberOfTimes = 1
};
this.FakeManager.allUserRulesField.AddFirst(newRule);
newRule.Rule.Apply(fakeObjectCall);
}
private static object ResolveReturnValue(IInterceptedFakeObjectCall fakeObjectCall)
{
object result = null;
if (!FakeManager.TryCreateDummy(fakeObjectCall.Method.ReturnType, out result))
{
result = Helpers.GetDefaultValueOfType(fakeObjectCall.Method.ReturnType);
}
return result;
}
private bool TryHandleGetHashCode(IInterceptedFakeObjectCall fakeObjectCall)
{
if (!fakeObjectCall.Method.MethodHandle.Equals(ObjectMethodsMethodHandles[2]))
{
return false;
}
fakeObjectCall.SetReturnValue(this.FakeManager.GetHashCode());
return true;
}
private bool TryHandleGetHashCode(IInterceptedFakeObjectCall fakeObjectCall)
{
if (!IsSameMethod(fakeObjectCall.Method, ObjectMethods[2]))
{
return false;
}
fakeObjectCall.SetReturnValue(this.fakeManager.GetHashCode());
return true;
}
/// <summary>
/// Applies an action to the call, might set a return value or throw
/// an exception.
/// </summary>
/// <param name="fakeObjectCall">The call to apply the interceptor to.</param>
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
if (this.recorder.IsRecording)
{
this.wrappedRule.Apply(fakeObjectCall);
this.recorder.RecordCall(fakeObjectCall.AsReadOnly());
}
else
{
this.recorder.ApplyNext(fakeObjectCall);
}
}
/// <summary>
/// Applies the call if the call has been recorded.
/// </summary>
/// <param name="fakeObjectCall">The call to apply to from recording.</param>
public void ApplyNext(IInterceptedFakeObjectCall fakeObjectCall)
{
this.AssertThatCallQueueIsNotEmpty();
var callToApply = this.callQueue.Dequeue();
AssertThatMethodsMatches(fakeObjectCall, callToApply);
ApplyOutputArguments(fakeObjectCall, callToApply);
fakeObjectCall.SetReturnValue(callToApply.RecordedCall.ReturnValue);
callToApply.HasBeenApplied = true;
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
if (this.IsPropertyGetter(fakeObjectCall))
{
fakeObjectCall.SetReturnValue(this.Value);
}
else
{
this.Value = fakeObjectCall.Arguments[0];
}
this.fakeManager.MoveRuleToFront(this);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, "fakeObjectCall");
if (this.IsPropertyGetter(fakeObjectCall))
{
fakeObjectCall.SetReturnValue(this.Value);
}
else
{
this.Value = fakeObjectCall.Arguments.Last();
}
this.fakeManager.MoveRuleToFront(this);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, "fakeObjectCall");
var newRule = new CallRuleMetadata
{
CalledNumberOfTimes = 1,
Rule = new PropertyBehaviorRule(fakeObjectCall.Method, this.fakeManager)
{
Indices = fakeObjectCall.Arguments.Take(fakeObjectCall.Arguments.Count - 1).ToArray(),
Value = fakeObjectCall.Arguments.Last()
}
};
this.fakeManager.allUserRulesField.AddFirst(newRule);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
if (this.TryHandleToString(fakeObjectCall))
{
return;
}
if (this.TryHandleGetHashCode(fakeObjectCall))
{
return;
}
if (this.TryHandleEquals(fakeObjectCall))
{
return;
}
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, "fakeObjectCall");
var newRule = new CallRuleMetadata
{
Rule = new PropertyBehaviorRule(fakeObjectCall.Method, FakeManager)
{
Value = CreateFake(fakeObjectCall.Method.ReturnType),
Indices = fakeObjectCall.Arguments.ToArray(),
},
CalledNumberOfTimes = 1
};
this.FakeManager.allUserRulesField.AddFirst(newRule);
newRule.Rule.Apply(fakeObjectCall);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall));
var newRule = new CallRuleMetadata
{
Rule = new PropertyBehaviorRule(fakeObjectCall.Method, this.fakeManager)
{
Value = fakeObjectCall.GetDefaultReturnValue(),
Indices = fakeObjectCall.Arguments.ToArray(),
},
CalledNumberOfTimes = 1
};
this.fakeManager.AllUserRules.AddFirst(newRule);
newRule.Rule.Apply(fakeObjectCall);
}
public virtual void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, "fakeObjectCall");
foreach (var action in this.Actions)
{
action.Invoke(fakeObjectCall);
}
this.Applicator.Invoke(fakeObjectCall);
this.ApplyOutAndRefParametersValueProducer(fakeObjectCall);
if (this.CallBaseMethod)
{
fakeObjectCall.CallBaseMethod();
}
}
/// <summary>
/// Applies an action to the call, might set a return value or throw
/// an exception.
/// </summary>
/// <param name="fakeObjectCall">The call to apply the interceptor to.</param>
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall));
var parameters = fakeObjectCall.Arguments.GetUnderlyingArgumentsArray();
object valueFromWrappedInstance;
try
{
valueFromWrappedInstance = fakeObjectCall.Method.Invoke(this.wrappedObject, parameters);
}
catch (TargetInvocationException ex)
{
ex.InnerException?.Rethrow();
throw;
}
fakeObjectCall.SetReturnValue(valueFromWrappedInstance);
}
private bool TryHandleEquals(IInterceptedFakeObjectCall fakeObjectCall)
{
if (!fakeObjectCall.Method.MethodHandle.Equals(ObjectMethodsMethodHandles[0]))
{
return false;
}
var argument = fakeObjectCall.Arguments[0] as ITaggable;
if (argument != null)
{
fakeObjectCall.SetReturnValue(argument.Tag.Equals(this.FakeManager));
}
else
{
fakeObjectCall.SetReturnValue(false);
}
return true;
}
private void ApplyOutAndRefParametersValues(IInterceptedFakeObjectCall fakeObjectCall)
{
if (this.OutAndRefParametersValues == null)
{
return;
}
var indexes = GetIndexesOfOutAndRefParameters(fakeObjectCall);
if (this.OutAndRefParametersValues.Count != indexes.Count)
{
throw new InvalidOperationException(ExceptionMessages.NumberOfOutAndRefParametersDoesNotMatchCall);
}
foreach (var argument in indexes.Zip(this.OutAndRefParametersValues))
{
fakeObjectCall.SetArgumentValue(argument.Item1, argument.Item2);
}
}
public virtual void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
foreach (var action in this.Actions)
{
action.Invoke(fakeObjectCall);
}
this.Applicator.Invoke(fakeObjectCall);
this.ApplyOutAndRefParametersValues(fakeObjectCall);
if (this.CallBaseMethod)
{
fakeObjectCall.CallBaseMethod();
}
}
private static IEnumerable <Tuple <int, object> > GetIndicesAndValuesOfOutputParameters(IInterceptedFakeObjectCall call, CallData recordedCall)
{
return
((from argument in call.Method.GetParameters().Zip(Enumerable.Range(0, int.MaxValue))
where argument.Item1.ParameterType.IsByRef
select argument.Item2).Zip(recordedCall.OutputArguments));
}
private static ICollection<int> GetIndexesOfOutAndRefParameters(IInterceptedFakeObjectCall fakeObjectCall)
{
var indexes = new List<int>();
var arguments = fakeObjectCall.Method.GetParameters();
for (var i = 0; i < arguments.Length; i++)
{
if (arguments[i].ParameterType.IsByRef)
{
indexes.Add(i);
}
}
return indexes;
}
private static void ProcessFakeObjectCall(IFakeCallProcessor fakeCallProcessor, IInterceptedFakeObjectCall interceptedCall)
{
fakeCallProcessor.Process(interceptedCall);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
var eventCall = EventCall.GetEventCall(fakeObjectCall);
this.HandleEventCall(eventCall);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
var eventCall = EventCall.GetEventCall(fakeObjectCall);
this.HandleEventCall(eventCall);
}
private static void ApplyRule(CallRuleMetadata rule, IInterceptedFakeObjectCall fakeObjectCall)
{
logger.Debug("Applying rule {0}.", rule.Rule.ToString());
rule.CalledNumberOfTimes++;
rule.Rule.Apply(fakeObjectCall);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall));
fakeObjectCall.SetReturnValue(this.Value);
}
private static void ApplyRule(CallRuleMetadata rule, IInterceptedFakeObjectCall fakeObjectCall)
{
rule.CalledNumberOfTimes++;
rule.Rule.Apply(fakeObjectCall);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
throw new ExpectationException(ExceptionMessages.CallToUnconfiguredMethodOfStrictFake(fakeObjectCall));
}
void IFakeObjectCallRule.Apply(IInterceptedFakeObjectCall invocation)
{
this.ApplyWasCalled = true;
this.Apply(invocation);
}
private static void ApplyOutputArguments(IInterceptedFakeObjectCall call, CallDataMetadata callToApply)
{
foreach (var outputArgument in call.Method.GetParameters()
.Select((parameter, index) => new { Parameter = parameter, Index = index })
.Where(argument => argument.Parameter.ParameterType.IsByRef)
.Select(argument => argument.Index).Zip(callToApply.RecordedCall.OutputArguments, (index, outputArgument) => new { Index = index, Value = outputArgument }))
{
call.SetArgumentValue(outputArgument.Index, outputArgument.Value);
}
}
private static object DefaultReturnValue(IInterceptedFakeObjectCall fakeObjectCall)
{
return(DefaultReturnValueRule.ResolveReturnValue(fakeObjectCall));
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
var returnValue = ResolveReturnValue(fakeObjectCall);
fakeObjectCall.SetReturnValue(returnValue);
}
void IFakeCallProcessor.Process(IInterceptedFakeObjectCall fakeObjectCall)
{
foreach (var listener in this.interceptionListeners)
{
listener.OnBeforeCallIntercepted(fakeObjectCall);
}
var ruleToUse =
(from rule in this.AllRules
where rule.Rule.IsApplicableTo(fakeObjectCall) && rule.HasNotBeenCalledSpecifiedNumberOfTimes()
select rule).First();
try
{
ApplyRule(ruleToUse, fakeObjectCall);
}
finally
{
var readonlyCall = fakeObjectCall.AsReadOnly();
this.RecordCall(readonlyCall);
foreach (var listener in this.interceptionListeners.Reverse())
{
listener.OnAfterCallIntercepted(readonlyCall, ruleToUse.Rule);
}
}
}
/// <summary> /// Applies an action to the call, might set a return value or throw /// an exception. /// </summary> /// <param name="fakeObjectCall">The call to apply the interceptor to.</param> public void Apply(IInterceptedFakeObjectCall fakeObjectCall) => fakeObjectCall.CallWrappedMethod(this.WrappedObject);
private static void AssertThatMethodsMatches(IInterceptedFakeObjectCall call, CallDataMetadata callToApply)
{
if (!callToApply.RecordedCall.Method.Equals(call.Method))
{
throw new RecordingException(ExceptionMessages.MethodMissmatchWhenPlayingBackRecording);
}
}
public static object GetDefaultReturnValue(this IInterceptedFakeObjectCall call) =>
DummyManager.TryCreateDummy(call.Method.ReturnType, new LoopDetectingResolutionContext(), out object result)
? result
: call.Method.ReturnType.GetDefaultValue();
private static void ApplyRule(CallRuleMetadata rule, IInterceptedFakeObjectCall fakeObjectCall)
{
rule.CalledNumberOfTimes++;
rule.Rule.Apply(fakeObjectCall);
}
private static void SetReturnValue(IInterceptedFakeObjectCall fakeObjectCall, RecordedCall recordedCall)
{
fakeObjectCall.SetReturnValue(recordedCall.ReturnValue);
}
public abstract void Apply(IInterceptedFakeObjectCall fakeObjectCall);
public override void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall));
fakeObjectCall.SetReturnValue(fakeObjectCall.GetDefaultReturnValue());
}