private void RaiseEvent(EventCall call) { Delegate raiseMethod; if (this.RegisteredEventHandlers.TryGetValue(call.Event, out raiseMethod)) { var arguments = this.GetArgumentsFromEventRaiser(call); try { raiseMethod.DynamicInvoke(arguments); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { // Exceptions thrown by event handlers should propagate outward as is, not // be wrapped in a TargetInvocationException. TryPreserveStackTrace(ex.InnerException); throw ex.InnerException; } throw; } } }
public void Apply(IInterceptedFakeObjectCall fakeObjectCall) { if (EventCall.TryGetEventCall(fakeObjectCall, out var eventCall)) { this.HandleEventCall(eventCall); } }
private void RaiseEvent(EventCall call) { Delegate raiseMethod = null; if (this.RegisteredEventHandlers.TryGetValue(call.Event, out raiseMethod)) { var arguments = call.EventHandler.Target as IEventRaiserArguments; var sender = arguments.Sender ?? this.FakeManager.Object; try { raiseMethod.DynamicInvoke(sender, arguments.EventArguments); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { // Exceptions thrown by event handlers should propagate outward as is, not // be wrapped in a TargetInvocationException. TryPreserveStackTrace(ex.InnerException); throw ex.InnerException; } throw; } } }
/// <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 (EventCall.TryGetEventCall(fakeObjectCall, out var eventCall) && eventCall.IsEventRaiser()) { throw new InvalidOperationException(ExceptionMessages.WrappingFakeCannotRaiseEvent); } fakeObjectCall.CallWrappedMethod(this.WrappedObject); }
public void Apply(IInterceptedFakeObjectCall fakeObjectCall) { string message = ExceptionMessages.CallToUnconfiguredMethodOfStrictFake(fakeObjectCall); if (EventCall.TryGetEventCall(fakeObjectCall, out _)) { message += Environment.NewLine + ExceptionMessages.HandleEventsOnStrictFakes; } throw new ExpectationException(message); }
private void RaiseEvent(EventCall call) { Delegate raiseMethod = null; if (this.RegisteredEventHandlers.TryGetValue(call.Event, out raiseMethod)) { var arguments = call.EventHandler.Target as IEventRaiserArguments; var sender = arguments.Sender ?? this.FakeManager.Object; raiseMethod.DynamicInvoke(sender, arguments.EventArguments); } }
public void HandleEventCall(EventCall eventCall) { if (eventCall.IsEventSubscription()) { if (eventCall.TryTakeEventRaiserArgumentProvider(out var argumentProvider)) { this.RaiseEvent(eventCall, argumentProvider); } else { this.AddEventListener(eventCall); } } else { this.RemoveEventListener(eventCall); } }
private void HandleEventCall(EventCall eventCall) { if (eventCall.IsEventRegistration()) { if (eventCall.IsEventRaiser()) { this.RaiseEvent(eventCall); } else { this.AddEventListener(eventCall); } } else { this.RemoveEventListener(eventCall); } }
private void RaiseEvent(EventCall call, IEventRaiserArgumentProvider argumentProvider) { if (this.RegisteredEventHandlers.TryGetValue(call.Event, out var raiseMethod)) { var arguments = argumentProvider.GetEventArguments(this.fakeManager.Object !); try { raiseMethod.DynamicInvoke(arguments); } catch (TargetInvocationException ex) { // Exceptions thrown by event handlers should propagate outward as is, not // be wrapped in a TargetInvocationException. ex.InnerException?.Rethrow(); throw; } } }
private void HandleEventCall(EventCall eventCall) { if (eventCall.IsEventRegistration()) { if (EventHandlerArgumentProviderMap.TryTakeArgumentProviderFor( eventCall.EventHandler, out var argumentProvider)) { this.RaiseEvent(eventCall, argumentProvider); } else { this.AddEventListener(eventCall); } } else { this.RemoveEventListener(eventCall); } }
public bool IsApplicableTo(IFakeObjectCall fakeObjectCall) { if (fakeObjectCall.Method.IsSameMethodAs(EqualsMethod)) { return(!this.HasOption(StrictFakeOptions.AllowEquals)); } if (fakeObjectCall.Method.IsSameMethodAs(GetHashCodeMethod)) { return(!this.HasOption(StrictFakeOptions.AllowGetHashCode)); } if (fakeObjectCall.Method.IsSameMethodAs(ToStringMethod)) { return(!this.HasOption(StrictFakeOptions.AllowToString)); } if (EventCall.TryGetEventCall(fakeObjectCall, out _)) { return(!this.HasOption(StrictFakeOptions.AllowEvents)); } return(true); }
public bool IsApplicableTo(IFakeObjectCall fakeObjectCall) { return(EventCall.GetEvent(fakeObjectCall.Method) != null); }
public void Apply(IInterceptedFakeObjectCall fakeObjectCall) { var eventCall = EventCall.GetEventCall(fakeObjectCall, this.eventHandlerArgumentProviderMap); this.HandleEventCall(eventCall); }
public bool IsApplicableTo(IFakeObjectCall fakeObjectCall) { Guard.AgainstNull(fakeObjectCall, "fakeObjectCall"); return(EventCall.GetEvent(fakeObjectCall.Method) != null); }
private object[] GetArgumentsFromEventRaiser(EventCall call) { var argumentListBuilder = this.eventHandlerArgumentProviderMap.TakeArgumentProviderFor(call.EventHandler); return(argumentListBuilder.GetEventArguments(this.FakeManager.Object)); }
private void AddEventListener(EventCall call) { this.AddHandler(call.Event, call.EventHandler); }
private void RemoveEventListener(EventCall call) { this.RemoveHandler(call.Event, call.EventHandler); }
public void Apply(IInterceptedFakeObjectCall fakeObjectCall) { var eventCall = EventCall.GetEventCall(fakeObjectCall); this.HandleEventCall(eventCall); }
public bool IsApplicableTo(IFakeObjectCall fakeObjectCall) { Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall)); return(EventCall.TryGetEventCall(fakeObjectCall, out _)); }
public bool IsApplicableTo(IFakeObjectCall fakeObjectCall) { Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall)); return(EventCall.GetEvent(fakeObjectCall.Method) is object); }