/// <summary> /// Constructs a <see cref="UnexpectedInvocationException"/> with the given parameters. /// </summary> /// <param name="factory">The MockFactory that threw this exception</param> /// <param name="invocation">The unexpected invocation</param> /// <param name="expectations">The expectations collection to describe</param> /// <param name="message">A message to help the user understand what was unexpected</param> internal UnexpectedInvocationException(MockFactory factory, Invocation invocation, IExpectationList expectations, string message) { if (factory == null) throw new ArgumentNullException("factory"); if (invocation == null) throw new ArgumentNullException("invocation"); if (expectations == null) throw new ArgumentNullException("expectations"); Factory = factory; var writer = new DescriptionWriter(); writer.WriteLine(); if (invocation.IsPropertySetAccessor) writer.WriteLine(UNEXPECTED_PROPERTY_SETTER_PREFIX); else if (invocation.IsPropertyGetAccessor) writer.WriteLine(UNEXPECTED_PROPERTY_GETTER_PREFIX); else writer.WriteLine(MESSAGE_PREFIX); writer.Write(" "); ((ISelfDescribing)invocation).DescribeTo(writer); writer.Write(message); //expectations.DescribeActiveExpectationsTo(writer); //expectations.DescribeUnmetExpectationsTo(writer); expectations.DescribeTo(writer); _message = writer.ToString(); }
public void Process(Invocation invocation) { foreach (var kvp in this.values) { invocation.Args[kvp.Key] = kvp.Value; } }
private async Task Run(IRtmpConnection connection) { var count = 1; var token = _tokenSource.Token; while (!token.IsCancellationRequested) { await Task.Delay(TimeSpan.FromMilliseconds(120000), token); if (token.IsCancellationRequested) return; var date = DateTime.UtcNow.ToString("ddd MMM d yyyy HH:mm:ss 'GMTZ'"); try { var session = _sessionManager.CurrentSession; if (session == null) continue; var invoke = new Invocation<int>("loginService", "performLCDSHeartBeat", session.accountSummary.accountId, session.token, count, date); await invoke.Execute(connection); } catch (AggregateException agg) { agg.Handle(e => e is TaskCanceledException); } count++; } _tokenSource = null; _heartbeat = null; }
public void Process(Invocation invocation) { ++calls; Telerik.JustMock.DebugView.TraceEvent(IndentLevel.DispatchResult, () => String.Format("Calls so far: {0}", calls)); Assert(null, this.UpperBound, calls, null); }
public void Process(Invocation invocation) { var returnValue = CallOverride(invocation); if (implementationOverride.Method.ReturnType != typeof(void) && !this.ignoreDelegateReturnValue) invocation.ReturnValue = returnValue; invocation.UserProvidedImplementation = true; }
public object CallOverride(Invocation invocation) { var args = implementationOverride.Method.GetParameters().Length > 0 && invocation.Args != null ? invocation.Args : Empty; var paramsCount = invocation.Method.GetParameters().Length; var implementationParamsCount = implementationOverride.Method.GetParameters().Length; if (invocation.Method.IsExtensionMethod() && paramsCount - 1 == implementationParamsCount) { args = args.Skip(1).ToArray(); } int extraParamCount = 1 + (implementationOverride.Target != null && implementationOverride.Method.IsStatic ? 1 : 0); if (!invocation.Method.IsStatic && extraParamCount + paramsCount == implementationParamsCount) { args = new[] { invocation.Instance }.Concat(args).ToArray(); } try { var returnValue = ProfilerInterceptor.GuardExternal(() => overrideInvoker(args, this.implementationOverride)); return returnValue; } catch (InvalidCastException ex) { throw new MockException("The implementation callback has an incorrect signature", ex); } }
public void Process(Invocation invocation) { if (!invocation.UserProvidedImplementation && !invocation.Recording && (invocation.Method.GetReturnType() != typeof(void) || !throwOnlyOnValueReturningMethods) && !(invocation.Method is ConstructorInfo)) throw new StrictMockException(invocation.Method.DeclaringType); }
public void Process(Invocation invocation) { if (ShouldCallOriginal(invocation)) { invocation.UserProvidedImplementation = true; invocation.CallOriginal = true; } }
public async void Can_automatically_cancel_the_invocation_after_a_fixed_timespan() { var connection = new MockRtmpConnection {ShouldTimeout = true}; var invocation = new Invocation<object>(Invocation.EndpointName, "service", "method"); await invocation.Execute(connection, TimeSpan.FromSeconds(1)); }
public async void Can_return_faults_when_a_service_call_fails() { var connection = new MockRtmpConnection {ShouldSucceed = false}; var failure = new Func<Fault, Exception>(fault => new InvalidOperationException()); var invocation = new Invocation<object>(Invocation.EndpointName, "service", "method", null, failure); await invocation.Execute(connection); }
public void Process(Invocation invocation) { if ((!invocation.Recording || invocation.RetainBehaviorDuringRecording) && !invocation.UserProvidedImplementation) { invocation.UserProvidedImplementation = true; invocation.CallOriginal = true; } }
public object Invoke(object target, MethodInfo methodInfo, object[] parameters) { var i = new Invocation( methodInfo.Name, methodInfo.ReturnType, parameters); return Invoke(i); }
public void Process(Invocation invocation) { var method = invocation.Method; if (method is ConstructorInfo && method.IsPrivate && method.IsStatic) { var mixin = MocksRepository.GetMockMixinFromInvocation(invocation); invocation.CallOriginal = mixin == null || !mixin.IsStaticConstructorMocked; } }
public void Process(Invocation invocation) { if (invocation.IsReturnValueSet) return; var returnType = invocation.Method.GetReturnType(); if (returnType == typeof(void) || returnType.IsValueType) return; if (invocation.Method.Name == "ToString" && invocation.Method.GetParameters().Length == 0 && invocation.UserProvidedImplementation) return; if (invocation.Method.Name == "GetType" && invocation.Method.GetReturnType() == typeof(Type) && invocation.Method.GetParameters().Length == 0) return; object mock = null; List<KeyValuePair<object, object>> mocksList; if (mocks.TryGetValue(invocation.Method, out mocksList)) { // can't put the key part in a Dictionary, // because we can't be sure that GetHashCode() works mock = mocksList.FirstOrDefault(kvp => Equals(kvp.Key, invocation.Instance)).Value; } if (mock == null) { var parentMock = invocation.MockMixin; var repository = parentMock.Repository; if (MustReturnMock(invocation) || this.type == RecursiveMockingBehaviorType.ReturnDefault) { mock = CreateMock(returnType, repository, invocation); } if (mock == null) return; if (mocksList == null) { mocksList = new List<KeyValuePair<object, object>>(); mocks.Add(invocation.Method, mocksList); } mocksList.Add(new KeyValuePair<object, object>(invocation.Instance, mock)); var mockMixin = MocksRepository.GetMockMixin(mock, null); if (parentMock != null && mockMixin != null) parentMock.DependentMocks.Add(mock); } invocation.ReturnValue = mock; invocation.CallOriginal = false; invocation.UserProvidedImplementation = true; }
public void Process(Invocation invocation) { var method = invocation.Method; if (method is ConstructorInfo && !method.IsStatic) { var mixin = invocation.MockMixin; invocation.CallOriginal = mixin != null ? !mixin.IsInstanceConstructorMocked : true; invocation.UserProvidedImplementation = true; } }
public void Intercept(Invocation methodInvoke) { // 执行目标方法 methodInvoke.Invoke(); // 如果输出流方式或包含输出流方式 if (methodInvoke.MethodMetaData.OutputType == TypeCategory.BinaryType && methodInvoke.RetValue != null) { TransferFile tfile = ((TransferFile)methodInvoke.RetValue); NDWR.Util.Kit.SetAbsCache(tfile.ID, tfile); methodInvoke.RetValue = tfile.ID; } }
public void Process(Invocation invocation) { var mockMixin = invocation.MockMixin; if (mockMixin == null) { mockMixin = invocation.Repository.CreateExternalMockMixin(null, invocation.Instance, Behavior.CallOriginal); mockMixin.IsInstanceConstructorMocked = true; } invocation.CallOriginal = !mockMixin.IsInstanceConstructorMocked; }
public async void Can_execute_a_service_call() { var connection = new MockRtmpConnection {ShouldSucceed = true}; var successful = false; var success = new Action<object>(o => successful = true); var invocation = new Invocation<object>(Invocation.EndpointName, "service", "method", success, null); var result = await invocation.Execute(connection); Assert.That(result, Is.Not.Null); Assert.That(successful, Is.True); }
public void Intercept(Invocation methodInvoke) { try { methodInvoke.Invoke(); } catch (Exception ex) { methodInvoke.SystemErrors.Add( new RspError(SystemError.ServiceException, ex.Message) ); log.Error("ExceptionInterceptor捕获到异常", ex); //throw ex; } }
public void Process(Invocation invocation) { if (invocation.Method.IsVirtual && typeof(object).GetMethods().Any(method => method.Name == invocation.Method.Name && method.ReturnType == invocation.Method.GetReturnType() && method.GetParameters().Select(p => p.ParameterType).SequenceEqual(invocation.Method.GetParameters().Select(p => p.ParameterType)) )) { invocation.CallOriginal = true; } }
public async Task Logout(IRtmpConnection connection) { if (CurrentSession == null) return; if (string.IsNullOrWhiteSpace(CurrentSession.token)) return; var invoke = new Invocation<AcknowledgeMessage>("loginService", "logout", CurrentSession.token); var message = await invoke.Execute(connection); return; }
public void Process(Invocation invocation) { var mockMethod = invocation.Method; var inheritanceChain = mockMethod.GetInheritanceChain(); var delegatedImplMethod = inheritanceChain.FirstOrDefault(method => types.Any(t => method.DeclaringType.IsAssignableFrom(t))); if (delegatedImplMethod != null) { invocation.ReturnValue = delegatedImplMethod.Invoke(implementer, invocation.Args); invocation.UserProvidedImplementation = true; } }
protected override void Analyze(Invocation invocation, string invocationPointer) { if (invocation.StartTime > invocation.EndTime) { string endTimePointer = invocationPointer.AtProperty(SarifPropertyName.EndTime); LogResult( endTimePointer, nameof(RuleResources.SARIF007_Default), FormatDateTime(invocation.EndTime), FormatDateTime(invocation.StartTime)); } }
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 void Track(MethodBase method, object[] arguments, IInternalSetup setup) { Invocation invocation = new Invocation(setup, arguments); _invocations.AddOrUpdate( method, new List<Invocation> { invocation }, (key, existing) => { existing.Add(invocation); return existing; }); }
public async Task<LolSession> Login(IRtmpConnection connection, AuthenticationCredentials credentials) { Credentials = credentials; var invoke = new Invocation<LolSession>("loginService", "login", credentials); CurrentSession = await invoke.Execute(connection); await AuthorizeSession(connection, CurrentSession); if (_action != null) _action(); return CurrentSession; }
public async void Can_manually_cancel_the_invocation() { var connection = new MockRtmpConnection {ShouldTimeout = true}; var invocation = new Invocation<object>(Invocation.EndpointName, "service", "method"); using (var tcs = new CancellationTokenSource()) { var task = invocation.Execute(connection, tcs.Token); // immediately cancel tcs.Cancel(); await task; } }
public void Process(Invocation invocation) { if (!invocation.UserProvidedImplementation && !invocation.Recording && (invocation.Method.GetReturnType() != typeof(void) || !throwOnlyOnValueReturningMethods) && !(invocation.Method is ConstructorInfo)) { if (strictnessViolationMessage == null) strictnessViolationMessage = new StringBuilder(); strictnessViolationMessage.AppendFormat("Called unarranged member '{0}' on strict mock of type '{1}'\n", invocation.Method, invocation.Method.DeclaringType); throw new StrictMockException(invocation.Method.DeclaringType); } }
public void Process(Invocation invocation) { var method = invocation.Method; var candidateEvent = method.GetEventFromAddOrRemove(); if (candidateEvent == null) return; invocation.UserProvidedImplementation = true; var delg = (Delegate)invocation.Args[0]; if (candidateEvent.GetAddMethod() == invocation.Method) this.AddEventHandler(candidateEvent, delg); else this.RemoveEventHandler(candidateEvent, delg); }
public void Process(Invocation invocation) { if (!invocation.UserProvidedImplementation && !invocation.Recording && (invocation.Method.GetReturnType() != typeof(void) || !throwOnlyOnValueReturningMethods) && !(invocation.Method is ConstructorInfo) && !invocation.InArrange) { if (strictnessViolationMessage == null) strictnessViolationMessage = new StringBuilder(); strictnessViolationMessage.AppendFormat( throwOnlyOnValueReturningMethods ? MissingReturnValueMessage : GenericErrorMessage, invocation.Method, invocation.Method.DeclaringType); throw new StrictMockException(strictnessViolationMessage.ToString()); } }
private static Run CreateRun( IEnumerable <string> analysisTargets, OptionallyEmittedData dataToInsert, IEnumerable <string> invocationTokensToRedact, IEnumerable <string> invocationPropertiesToLog, string defaultFileEncoding = null) { var run = new Run { Invocations = new List <Invocation>(), DefaultEncoding = defaultFileEncoding }; if (analysisTargets != null) { run.Artifacts = new List <Artifact>(); foreach (string target in analysisTargets) { Uri uri = new Uri(UriHelper.MakeValidUri(target), UriKind.RelativeOrAbsolute); var fileData = Artifact.Create( new Uri(target, UriKind.RelativeOrAbsolute), dataToInsert); var fileLocation = new ArtifactLocation { Uri = uri }; fileData.Location = fileLocation; // This call will insert the file object into run.Files if not already present fileData.Location.Index = run.GetFileIndex(fileData.Location, addToFilesTableIfNotPresent: true, dataToInsert); } } var invocation = Invocation.Create(dataToInsert.HasFlag(OptionallyEmittedData.EnvironmentVariables), invocationPropertiesToLog); // TODO we should actually redact across the complete log file context // by a dedicated rewriting visitor or some other approach. if (invocationTokensToRedact != null) { invocation.CommandLine = Redact(invocation.CommandLine, invocationTokensToRedact); invocation.Machine = Redact(invocation.Machine, invocationTokensToRedact); invocation.Account = Redact(invocation.Account, invocationTokensToRedact); if (invocation.WorkingDirectory != null) { invocation.WorkingDirectory.Uri = Redact(invocation.WorkingDirectory.Uri, invocationTokensToRedact); } if (invocation.EnvironmentVariables != null) { string[] keys = invocation.EnvironmentVariables.Keys.ToArray(); foreach (string key in keys) { string value = invocation.EnvironmentVariables[key]; invocation.EnvironmentVariables[key] = Redact(value, invocationTokensToRedact); } } } run.Invocations.Add(invocation); return(run); }
public int Run(string a, string b) { Calls.Add(Invocation.Split(a, b)); return(88); }
public void Process(Invocation invocation) { if (invocation.IsReturnValueSet) { return; } var returnType = invocation.Method.GetReturnType(); if (returnType == typeof(void) || returnType.IsValueType) { return; } if (invocation.Method.Name == "ToString" && invocation.Method.GetParameters().Length == 0 && invocation.UserProvidedImplementation) { return; } if (invocation.Method.Name == "GetType" && invocation.Method.GetReturnType() == typeof(Type) && invocation.Method.GetParameters().Length == 0) { return; } object mock = null; List <KeyValuePair <object, object> > mocksList; if (mocks.TryGetValue(invocation.Method, out mocksList)) { // can't put the key part in a Dictionary, // because we can't be sure that GetHashCode() works mock = mocksList.FirstOrDefault(kvp => Equals(kvp.Key, invocation.Instance)).Value; } if (mock == null) { var parentMock = invocation.MockMixin; var repository = parentMock.Repository; if (MustReturnMock(invocation) || this.type == RecursiveMockingBehaviorType.ReturnDefault) { mock = CreateMock(returnType, repository, invocation); } if (mock == null) { return; } if (mocksList == null) { mocksList = new List <KeyValuePair <object, object> >(); mocks.Add(invocation.Method, mocksList); } mocksList.Add(new KeyValuePair <object, object>(invocation.Instance, mock)); var mockMixin = MocksRepository.GetMockMixin(mock, null); if (parentMock != null && mockMixin != null) { parentMock.DependentMocks.Add(mock); } } invocation.ReturnValue = mock; invocation.CallOriginal = false; invocation.UserProvidedImplementation = true; }
internal Run CreateRun(RunVersionOne v1Run) { Run run = null; if (v1Run != null) { if (v1Run.TryGetProperty("sarifv2/run", out run)) { return(run); } else { _currentV1Run = v1Run; _v1FileKeytoV2IndexMap = CreateFileKeyToIndexMapping(v1Run.Files); _v1RuleKeyToV2IndexMap = CreateRuleKeyToIndexMapping(v1Run.Rules); RunAutomationDetails id = null; RunAutomationDetails[] aggregateIds = null; if (v1Run.Id != null || v1Run.StableId != null) { id = new RunAutomationDetails { Guid = v1Run.Id, Id = v1Run.StableId != null ? v1Run.StableId + "/" : null }; } if (v1Run.AutomationId != null) { aggregateIds = new[] { new RunAutomationDetails { Id = v1Run.AutomationId + "/" } }; } run = new Run() { AutomationDetails = id, RunAggregates = aggregateIds, BaselineGuid = v1Run.BaselineId, Properties = v1Run.Properties, Language = v1Run.Tool?.Language ?? "en-US", Tool = CreateTool(v1Run.Tool), ColumnKind = ColumnKind.Utf16CodeUnits }; _currentRun = run; if (v1Run.Rules != null) { run.Tool.Driver.Rules = new List <ReportingDescriptor>(); foreach (var pair in v1Run.Rules) { run.Tool.Driver.Rules.Add(CreateRule(pair.Value)); } } if (v1Run.Files != null) { run.Artifacts = new List <Artifact>(); foreach (KeyValuePair <string, FileDataVersionOne> pair in v1Run.Files) { FileDataVersionOne fileDataVersionOne = pair.Value; if (fileDataVersionOne.Uri == null) { fileDataVersionOne.Uri = new Uri(pair.Key, UriKind.RelativeOrAbsolute); } run.Artifacts.Add(CreateFileData(fileDataVersionOne, pair.Key)); } } if (v1Run.LogicalLocations != null) { // Pass 1 over results. In this phase, we're simply collecting fully qualified names that // may be duplicated in the logical locations dictionary. We're doing this so that we // can properly construct the v2 logical instances in the converted array (i.e., we can't // populate the v2 logicalLocation.FullyQualifiedName property in cases where the // v1 key is a synthesized value and not actually the fully qualified name) var visitor = new VersionOneLogicalLocationKeyToLogicalLocationDataVisitor(); visitor.VisitRunVersionOne(v1Run); _v1KeyToFullyQualifiedNameMap = visitor.LogicalLocationKeyToFullyQualifiedNameMap; _v1LogicalLocationKeyToDecoratedNameMap = visitor.LogicalLocationKeyToDecoratedNameMap; run.LogicalLocations = new List <LogicalLocation>(); HashSet <string> populatedKeys = new HashSet <string>(); foreach (KeyValuePair <string, LogicalLocationVersionOne> pair in v1Run.LogicalLocations) { PopulateLogicalLocation( run, v1Run.LogicalLocations, _v1LogicalLocationKeyToDecoratedNameMap, _v1KeyToFullyQualifiedNameMap, pair.Key, pair.Value, populatedKeys); } } // Even if there is no v1 invocation, there may be notifications // in which case we will need a v2 invocation to contain them Invocation invocation = CreateInvocation(v1Run.Invocation, v1Run.ToolNotifications, v1Run.ConfigurationNotifications); if (invocation != null) { run.Invocations = new List <Invocation>() { invocation }; } if (v1Run.Results != null) { run.Results = new List <Result>(); foreach (ResultVersionOne v1Result in v1Run.Results) { Result result = CreateResult(v1Result); run.Results.Add(result); } } // Stash the entire v1 run in this v2 run's property bag if (EmbedVersionOneContentInPropertyBag) { run.SetProperty($"{FromPropertyBagPrefix}/run", v1Run); } } } _currentRun = null; return(run); }
public int Run(IList <string> args) { Calls.Add(Invocation.List(args)); return(99); }
protected bool Equals(Invocation other) { return(Equals(Args, other.Args) && Equals(Function, other.Function)); }
public abstract bool MatchesIgnoringIsActive(Invocation invocation);
public void CantSetParameterValueForNonOutOrRefParameter() { var invocation = new Invocation(target, typeof(IMyInterface).GetMethod("MethodWithInputValue"), null, new object[1], null, 0); Assert.Throws <InvalidOperationException>(() => invocation.ParameterValues[0] = 0); }
public void ParameterAndGenericArgumentsListsHasRestrictedAccess() { var item = new object(); var type = typeof(object); var invocation = new Invocation( target, typeof(IMyInterface).GetMethod("MethodWithGenericArguments"), new List <Type> { type }, new List <object> { item }, null, 0); var parameterValues = invocation.ParameterValues; var genericArguments = invocation.GenericArguments; AssertIsNotSupported(() => parameterValues.Add(item)); AssertIsNotSupported(() => genericArguments.Add(type)); AssertIsNotSupported(() => parameterValues.Remove(item)); AssertIsNotSupported(() => genericArguments.Remove(type)); AssertIsNotSupported(() => parameterValues.RemoveAt(0)); AssertIsNotSupported(() => genericArguments.RemoveAt(0)); AssertIsNotSupported(() => parameterValues.Insert(0, item)); AssertIsNotSupported(() => genericArguments.Insert(0, type)); AssertIsNotSupported(parameterValues.Clear); AssertIsNotSupported(parameterValues.Clear); Assert.AreEqual(1, parameterValues.Count); Assert.AreEqual(1, genericArguments.Count); Assert.IsTrue(parameterValues.Contains(item)); Assert.IsTrue(genericArguments.Contains(type)); Assert.AreEqual(0, parameterValues.IndexOf(item)); Assert.AreEqual(0, genericArguments.IndexOf(type)); Assert.AreEqual(item, parameterValues[0]); Assert.AreEqual(type, genericArguments[0]); parameterValues[0] = item; AssertIsNotSupported(() => genericArguments[0] = type); var arrayCopy = new object[1]; parameterValues.CopyTo(arrayCopy, 0); Assert.AreEqual(item, arrayCopy[0]); var arrayCopy2 = new Type[1]; genericArguments.CopyTo(arrayCopy2, 0); Assert.AreEqual(type, arrayCopy2[0]); var enumerator = ((System.Collections.IEnumerable)parameterValues).GetEnumerator(); Assert.IsTrue(enumerator.MoveNext()); Assert.AreEqual(item, enumerator.Current); Assert.IsFalse(enumerator.MoveNext()); var enumerator2 = ((System.Collections.IEnumerable)genericArguments).GetEnumerator(); Assert.IsTrue(enumerator2.MoveNext()); Assert.AreEqual(type, enumerator2.Current); Assert.IsFalse(enumerator2.MoveNext()); Assert.IsFalse(parameterValues.IsReadOnly); Assert.IsFalse(genericArguments.IsReadOnly); }
public void CantSetParameterValueToNonAssignableValue() { var invocation = new Invocation(target, typeof(IMyInterface).GetMethod("MethodWithOutAndRefValues"), null, new object[2], null, 0); Assert.Throws <InvalidOperationException>(() => invocation.ParameterValues[0] = new object()); }
public void CantSetReturnValueForMethodWithoutReturnValue() { var invocation = new Invocation(target, typeof(IMyInterface).GetMethod("MethodWithoutReturnValue"), null, new object[2], null, 0); Assert.Throws <InvalidOperationException>(() => invocation.ReturnValue = 0); }
public void CantSetReturnValueToNonAssignableValue() { var invocation = new Invocation(target, typeof(IMyInterface).GetMethod("Method"), null, new object[0], default(int), 0); Assert.Throws <InvalidOperationException>(() => invocation.ReturnValue = null); }
public abstract bool Perform(Invocation invocation);
void IAction.Invoke(Invocation invocation) { invocation.SetterResult = invocation.Arguments[invocation.Arguments.Length - 1]; }
public abstract bool Matches(Invocation invocation);
public override void Execute(Invocation invocation) { Debug.Assert(invocation.Method != null); Debug.Assert(invocation.Method.ReturnType != null); var method = invocation.Method; if (this.mock.CallBase) { #if FEATURE_DEFAULT_INTERFACE_IMPLEMENTATIONS var tryCallDefaultInterfaceImplementation = false; #endif var declaringType = method.DeclaringType; if (declaringType.IsInterface) { if (this.mock.MockedType.IsInterface) { // Case 1: Interface method of an interface proxy. #if FEATURE_DEFAULT_INTERFACE_IMPLEMENTATIONS // Fall through to invoke default implementation (if one exists). tryCallDefaultInterfaceImplementation = true; #else // There is no base method to call, so fall through. #endif } else { Debug.Assert(mock.MockedType.IsClass); Debug.Assert(mock.ImplementsInterface(declaringType)); // Case 2: Explicitly implemented interface method of a class proxy. if (this.mock.InheritedInterfaces.Contains(declaringType)) { // Case 2a: Re-implemented interface. // The base class has its own implementation. Only call base method if it isn't an event accessor. if (!method.IsEventAddAccessor() && !method.IsEventRemoveAccessor()) { invocation.ReturnValue = invocation.CallBase(); return; } } else { Debug.Assert(this.mock.AdditionalInterfaces.Contains(declaringType)); // Case 2b: Additional interface. #if FEATURE_DEFAULT_INTERFACE_IMPLEMENTATIONS // Fall through to invoke default implementation (if one exists). tryCallDefaultInterfaceImplementation = true; #else // There is no base method to call, so fall through. #endif } } } else { Debug.Assert(declaringType.IsClass); // Case 3: Non-interface method of a class proxy. // Only call base method if it isn't abstract. if (!method.IsAbstract) { invocation.ReturnValue = invocation.CallBase(); return; } } #if FEATURE_DEFAULT_INTERFACE_IMPLEMENTATIONS if (tryCallDefaultInterfaceImplementation && !method.IsAbstract) { // Invoke default implementation. invocation.ReturnValue = invocation.CallBase(); return; } #endif } if (method.ReturnType != typeof(void)) { var returnValue = this.mock.GetDefaultValue(method, out var innerMock); if (innerMock != null && invocation.MatchingSetup == null) { var setup = new InnerMockSetup(originalExpression: null, this.mock, expectation: MethodExpectation.CreateFrom(invocation), returnValue); this.mock.MutableSetups.Add(setup); setup.Execute(invocation); } else { invocation.ReturnValue = returnValue; } } }
public abstract bool ContainsOrderedExpectationFor(Invocation invocation);
public void Before <TParam, TResult>(Invocation <TParam, TResult> invocation) => StartWatch(invocation);
public int Run(string a) { Calls.Add(Invocation.Split(a)); return(89); }
private object CreateMock(Type returnType, MocksRepository repository, Invocation invocation) { var parentMock = invocation.MockMixin; var replicator = parentMock as IMockReplicator; object mock = null; if (returnType.IsArray) { mock = Array.CreateInstance(returnType.GetElementType(), Enumerable.Repeat(0, returnType.GetArrayRank()).ToArray()); } var idictionaryType = returnType.GetImplementationOfGenericInterface(typeof(IDictionary <,>)); if (mock == null && idictionaryType != null) { var dictType = typeof(Dictionary <,>).MakeGenericType(idictionaryType.GetGenericArguments()); mock = MockCollection.Create(returnType, repository, replicator, (IEnumerable)MockingUtil.CreateInstance(dictType)); } var ienumerableType = returnType.GetImplementationOfGenericInterface(typeof(IEnumerable <>)); if (mock == null && ienumerableType != null) { var listType = typeof(List <>).MakeGenericType(ienumerableType.GetGenericArguments()); mock = MockCollection.Create(returnType, repository, replicator, (IEnumerable)MockingUtil.CreateInstance(listType)); } if (mock == null && typeof(Task).IsAssignableFrom(returnType)) { var elementType = returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>) ? returnType.GetGenericArguments()[0] : typeof(object); var taskResultValue = MustReturnMock(invocation) ? CreateMock(elementType, repository, invocation) : elementType.GetDefaultValue(); Expression <Func <Task <object> > > taskFromResult = () => MockingUtil.TaskFromResult((object)null); mock = ((MethodCallExpression)taskFromResult.Body).Method .GetGenericMethodDefinition() .MakeGenericMethod(elementType) .Invoke(null, new object[] { taskResultValue }); } #if !PORTABLE if (mock == null && returnType.IsByRef) { var delegateType = typeof(object).Assembly.GetType("Telerik.JustMock.RefDelegate`1").MakeGenericType(new [] { returnType.GetElementType() }); ConstructorInfo constructor = delegateType.GetConstructor(new[] { typeof(object), typeof(IntPtr) }); MethodInfo genericMethodInfo = this.GetType().GetMethod("GetDefaultRef", BindingFlags.NonPublic | BindingFlags.Instance); MethodInfo methodInfo = genericMethodInfo.MakeGenericMethod(returnType.GetElementType()); mock = constructor.Invoke(new object[] { this, methodInfo.MethodHandle.GetFunctionPointer() }); } #endif if (mock == null && MustReturnMock(invocation, checkPropertyOnTestFixture: true)) { if (typeof(String) == returnType) { mock = String.Empty; } else { try { mock = replicator.CreateSimilarMock(repository, returnType, null, true, null); } catch (MockException) { } } } return(mock); }
public int Run() { Calls.Add(Invocation.Split()); return(79); }
/// <summary> /// Invoke the action asynchronously /// </summary> /// <remarks>Returns immediately and will run the client-specified callback when the action /// later completes. Any output arguments can then be retrieved by calling /// EndRestore().</remarks> /// <param name="aCallback">Delegate to run when the action completes. /// This is guaranteed to be run but may indicate an error</param> public void BeginRestore(CallbackAsyncComplete aCallback) { Invocation invocation = iService.Invocation(iActionRestore, aCallback); iService.InvokeAction(invocation); }
protected override void ExecuteCore(Invocation invocation) { invocation.Return(this.returnValue); }
/// <summary> /// Invoke the action asynchronously /// </summary> /// <remarks>Returns immediately and will run the client-specified callback when the action /// later completes. Any output arguments can then be retrieved by calling /// EndApply().</remarks> /// <param name="aCallback">Delegate to run when the action completes. /// This is guaranteed to be run but may indicate an error</param> public void BeginApply(CallbackAsyncComplete aCallback) { Invocation invocation = iService.Invocation(iActionApply, aCallback); iService.InvokeAction(invocation); }
public void AfterReturning <TParam, TResult>(Invocation <TParam, TResult> invocation) => StopWatch(invocation);
/// <summary> /// 复制调用中参数的信息 /// </summary> /// <param name="invocation">The invocation.</param> /// <param name="arguments">The arguments.</param> /// <returns></returns> public Invocation CopyArguments(Invocation invocation, List <KeyValuePair <string, object> > arguments) { invocation.Arguments = arguments == null ? new KeyValuePair <string, object> [0] : arguments.ToArray(); return(invocation); }
public void AfterThrowing <TParam, TResult>(Invocation <TParam, TResult> invocation, ref Exception exception) => StopWatch(invocation);
public override void Execute(Invocation invocation) { throw this.exception; }
/// <summary> /// Parses an invocation from a TSV Line /// </summary> /// <remarks> /// This code is version aware. For now we only have one version and we'll treat all future line format versions /// as unsupported (indisinguisable from wrong file formats). This will make new lines not show up in old /// consumers. Updated version should support reading old ones. /// </remarks> public static bool TryParseTsvLine(string line, out Invocation invocation, out string errorDetails) { invocation = default; if (string.IsNullOrEmpty(line)) { errorDetails = "empty line"; return(false); } var parts = line.Split('\t'); // Check for line format version if (parts.Length < 1 || !int.TryParse(parts[0], NumberStyles.None, CultureInfo.InvariantCulture, out var lineVersion)) { errorDetails = "Error extracting line version"; return(false); } switch (lineVersion) { case 0: if (parts.Length != 8) { errorDetails = "Unexpected number of parts for v1: " + parts.Length; return(false); } var sessionId = parts[1]; if (string.IsNullOrEmpty(sessionId)) { errorDetails = "Failed to parse sessionId"; return(false); } if (!DateTime.TryParseExact(parts[2], "O", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var buildStartTimeUtc)) { errorDetails = "Failed to parse activityId"; return(false); } var primaryConfigFile = parts[3]; if (string.IsNullOrEmpty(primaryConfigFile)) { errorDetails = "Failed to parse primaryConfigFile"; return(false); } var logsFolder = parts[4]; if (string.IsNullOrEmpty(logsFolder)) { errorDetails = "Failed to parse logsFolder"; return(false); } var engineVersion = parts[5]; if (string.IsNullOrEmpty(engineVersion)) { errorDetails = "Failed to parse engineVersion"; return(false); } var engineBinFolder = parts[6]; if (string.IsNullOrEmpty(engineBinFolder)) { errorDetails = "Failed to parse engineBinFolder"; return(false); } var engineCommitId = parts[7]; if (string.IsNullOrEmpty(engineCommitId)) { errorDetails = "Failed to parse engineCommitId"; return(false); } invocation = new Invocation( lineVersion, sessionId, buildStartTimeUtc.ToUniversalTime(), primaryConfigFile, logsFolder, engineVersion, engineBinFolder, engineCommitId ); errorDetails = null; return(true); default: // Unsupported line format version errorDetails = "Unsupported version:" + lineVersion; return(false); } }
public override T Execute <T>(Invocation <T> invocation) { return(execute(invocation, 0)); }