/// <summary> /// Specifies that the arranged member will return consecutive values from the given array. /// If the arranged member is called after it has returned the last value, the behavior depends on the behavior parameter. /// </summary> /// <typeparam name="TReturn">Type of return value</typeparam> /// <param name="func">The arranged member</param> /// <param name="values">The list of values that will be returned by the arranged member. The list may be modified after the arrangement is made.</param> /// <param name="behavior">The behavior after the last value has been returned.</param> /// <returns>Reference to <see cref="IAssertable"/> interface.</returns> public static IAssertable ReturnsMany <TReturn>(this IFunc <TReturn> func, IList <TReturn> values, AfterLastValue behavior) { return(ProfilerInterceptor.GuardInternal(() => { if (values == null || values.Count == 0) { throw new ArgumentException("Expected at least one value to return", "values"); } Action <ReturnsManyImpl <TReturn> > afterEndAction = null; switch (behavior) { case AfterLastValue.ThrowAssertionFailed: afterEndAction = impl => MockingContext.Fail("List of arranged return values exhausted."); break; case AfterLastValue.KeepReturningLastValue: afterEndAction = impl => impl.CurrentIndex = values.Count - 1; break; case AfterLastValue.StartFromBeginning: afterEndAction = impl => impl.CurrentIndex = 0; break; default: throw new ArgumentException("behavior"); } return func.Returns(new ReturnsManyImpl <TReturn>(values, afterEndAction).GetNext); })); }
public void Assert() { if (!IsExpectationMet) { MockingContext.Fail("Calls should be executed in the order they are expected. Actual order of calls:\n{0}", InOrderExecutionMessage); } }
public void Assert() { if (this.strictnessViolationMessage != null) { MockingContext.Fail(this.strictnessViolationMessage.ToString()); } }
public void Assert() { if (!this.IsMet) { MockingContext.Fail("Not all prerequisites are met. Actual call processed:\n{0}", this.ExecutionMessage); } }
public void Assert() { if (!IsExpectationMet) { MockingContext.Fail("{0}Calls should be executed in the order they are expected. Actual order of calls:\n{1}", this.message != null ? this.message + " " : "", InOrderExecutionMessage); } }
public void Process(Invocation invocation) { this.wasCalled = true; this.calledInWrongOrder = (this.LastIdInOrder != this.arrangementId - 1); this.LastIdInOrder = this.arrangementId; this.InOrderExecutionLog += invocation.InputToString() + " called at:\n" + MockingContext.GetStackTrace(" "); if (this.calledInWrongOrder) { MockingContext.Fail("Last call executed out of order. Order of calls so far:\n{1}", invocation.InputToString(), InOrderExecutionMessage); } }
public static void Assert(int?lowerBound, int?upperBound, int calls, object expression) { if (IsInRange(lowerBound, upperBound, calls)) { return; } var message = String.Format("Occurrence expectation failed. {0}. Calls so far: {1}", MakeRangeString(lowerBound, upperBound), calls); if (expression != null) { message += String.Format("\nArrange expression: {0}", expression).EscapeFormatString(); } MockingContext.Fail(message); }
public void Process(Invocation invocation) { this.wasCalled = true; bool processedOnce = this.LastIdInOrder > -1; this.calledInWrongOrder = processedOnce && (this.LastIdInOrder - this.arrangementId) > 0 || (this.LastIdInOrder - this.arrangementId) < -1; this.LastIdInOrder = this.arrangementId; this.InOrderExecutionLog += invocation.InputToString() + " called at:\n" + MockingContext.GetStackTrace(" "); if (this.calledInWrongOrder) { MockingContext.Fail("{0}Last call executed out of order. Order of calls so far:\n{1}", this.message != null ? this.message + " " : "", InOrderExecutionMessage); } }
public void Process(Invocation invocation) { if (invocation.Recording || invocation.InArrange || invocation.InAssertSet) { return; } var returnType = invocation.Method.GetReturnType(); if (!typeof(Task).IsAssignableFrom(returnType)) { MockingContext.Fail("Wrong invocation to arrangement: return type of {0}.{1} is not a task", invocation.Instance != null ? MockingUtil.GetUnproxiedType(invocation.Instance) : invocation.Method.DeclaringType, invocation.Method.Name); } var elementType = returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>) ? returnType.GetGenericArguments()[0] : typeof(object); Expression <Func <Task <object> > > taskFromException = () => MockingUtil.TaskFromException <object>((Exception)null); var mock = ((MethodCallExpression)taskFromException.Body).Method .GetGenericMethodDefinition() .MakeGenericMethod(elementType) .Invoke(null, new object[] { this.exception }); var parentMock = invocation.MockMixin; var mockMixin = MocksRepository.GetMockMixin(mock, null); if (parentMock != null && mockMixin != null) { parentMock.DependentMocks.Add(mock); } invocation.ReturnValue = mock; invocation.CallOriginal = false; invocation.UserProvidedImplementation = true; }