public string GetInvalidArgumentValueFailureMessage(IArrangement arrangement, IInvocation invocation) { var compareLogic = new CompareLogic(); var arrangementMethod = (IArrangementMethod)arrangement; var arrangementArguments = arrangementMethod.ArrangementArguments; IArrangementArgument arrangementArgument = null; for (var index = 0; index < arrangementArguments.Length; index++) { var arrangementArgumentValue = arrangementArguments[index].ArgumentValue; var invocationArgumentValue = invocation.Arguments[index]; var comparisonResult = compareLogic.Compare(arrangementArgumentValue, invocationArgumentValue); if (comparisonResult.AreEqual) { continue; } arrangementArgument = arrangementArguments[index]; break; } var ordinalPosition = arrangementArgument?.OrdinalPosition; var argumentName = arrangementArgument?.ArgumentName; var failureMessage = $"{arrangementMethod.MethodName} was not called with arranged argument " + $"for the {ordinalPosition} argument {{{argumentName}}}."; return(failureMessage); }
private void UpdateArrangementCount(IArrangement arrangement, long proxyIdentifier, int metadataToken) { if (_arrangementCallsMade.ContainsKey(proxyIdentifier)) { if (_arrangementCallsMade[proxyIdentifier].ContainsKey(metadataToken)) { var isPropertyArrangement = arrangement is IArrangementProperty; if (!isPropertyArrangement) { _arrangementCallsMade[proxyIdentifier][metadataToken]++; } } else { _arrangementCallsMade[proxyIdentifier].Add(metadataToken, 1); } } else { _arrangementCallsMade.Add(proxyIdentifier, new Dictionary <int, int> { { metadataToken, 1 } }); } }
public void Clone(IArrangement arrangement) { Vendor = arrangement.Vendor; StartTime = arrangement.StartTime; EndTime = arrangement.EndTime; Status = arrangement.Status; Id = arrangement.Id; }
public void AddArrangement(IArrangement arrangement) { var proxy = arrangement.Proxy; var proxyIdentifier = GetProxyIdentifier(proxy); var metadataToken = arrangement.MetadataToken; AddArrangement(arrangement, proxyIdentifier, metadataToken); UpdateArrangementCount(arrangement, proxyIdentifier, metadataToken); }
/// <summary> /// Arrange <see cref="Fetcher"/>'s members if possible, if it is an <see cref="IRawArrangedLayout"/>. /// </summary> /// <param name="arrangement">arangement to use, can be null</param> /// <param name="converters">converters to consider, can be null</param> /// <param name="fetcher">fetches an object from a logging event</param> /// <param name="renderer">serializes the object</param> /// <param name="decorators">decorates the object before serialization</param> public virtual void SetUp(IArrangement arrangement, IEnumerable <ConverterInfo> converters, IRawLayout fetcher, IObjectRenderer renderer, IEnumerable <IDecorator> decorators) { var decoratorsArray = decorators == null ? null : Enumerable.ToArray(decorators); Fetcher = fetcher ?? Fetcher ?? CreateFetcher(); Decorators = decoratorsArray ?? Decorators ?? CreateDecorators(); Renderer = renderer ?? Renderer ?? CreateRenderer(); Arrange(arrangement, converters); }
/// <summary> /// Arrange members /// </summary> /// <param name="arrangement">by arrangement</param> /// <param name="converters">with converters</param> protected virtual void Arrange(IArrangement arrangement, IEnumerable <ConverterInfo> converters) { var convertersArray = converters == null ? null : Enumerable.ToArray(converters); var arrangedFetcher = Fetcher as IRawArrangedLayout; if (arrangedFetcher != null && arrangement != null) { arrangement.Arrange(arrangedFetcher.Members, convertersArray); } }
public string GetGenericTypeArgumentFailureMessage(IArrangement arrangement, IInvocation invocation) { var arrangementMethod = (IArrangementMethod)arrangement; var memberName = arrangementMethod.MethodName; var arrangementMethodGenericArguments = arrangementMethod.GenericArguments; var arrangementFriendlyArguments = arrangementMethodGenericArguments.Select(type => type.GetFriendlyTypeName()); var arrangementFriendlyArgumentsCommaSeparated = $"<{string.Join(", ", arrangementFriendlyArguments)}>"; var invocationGenericArguments = invocation.GenericArguments; var invocationFriendlyArguments = invocationGenericArguments.Select(type => type.GetFriendlyTypeName()); var invocationFriendlyArgumentsSeparated = $"<{string.Join(", ", invocationFriendlyArguments)}>"; var failureMessage = $"{memberName} was arranged with generic type(s) {arrangementFriendlyArgumentsCommaSeparated}, " + $"but was called with the generic type(s) {invocationFriendlyArgumentsSeparated}."; return(failureMessage); }
public void TestArrangementCRUD() { IArrangement a = CreateArrangement(); var ap = new ArrangementProcessor(a); var save = ap.Create().Result; Assert.IsTrue(save.Data != null && save.Data.Id != Guid.Empty, "Arrangement save failed."); var one = ap.FetchById().Result; Assert.IsTrue(one.Data != null, "Arrangement fetch failed."); var delete = ap.Delete().Result; one = ap.FetchById().Result; Assert.IsTrue(one.Data == null, "Arrangement delete failed."); }
internal static string GetFriendlyMemberName(this IArrangement arrangement) { string memberName; switch (arrangement) { case IArrangementProperty arrangementProperty: memberName = arrangementProperty.PropertyName; break; case IArrangementMethod arrangementMethod: memberName = arrangementMethod.MethodName; break; default: return(null); } return(memberName); }
private void AddArrangement(IArrangement arrangement, long proxyIdentifier, int metadataToken) { if (_arrangementQueue.ContainsKey(proxyIdentifier)) { if (_arrangementQueue[proxyIdentifier].ContainsKey(metadataToken)) { _arrangementQueue[proxyIdentifier][metadataToken].Enqueue(arrangement); } else { _arrangementQueue[proxyIdentifier].Add(metadataToken, new Queue <IArrangement>(new[] { arrangement })); } } else { _arrangementQueue.Add(proxyIdentifier, new Dictionary <int, Queue <IArrangement> > { { metadataToken, new Queue <IArrangement>(new[] { arrangement }) } }); } }
public void VerifyArgumentValues(IArrangement arrangement, IInvocation invocation) { object[] arrangementArguments; object[] invocationArguments; switch (arrangement) { case IArrangementProperty arrangementProperty: var arguments = new[] { arrangementProperty.ReturnValue }; arrangementArguments = arguments; invocationArguments = arguments; break; case IArrangementMethod arrangementMethod: arrangementArguments = arrangementMethod.ArrangementArguments .Select(arrangementArgument => arrangementArgument.ArgumentValue) .ToArray(); invocationArguments = invocation.Arguments; break; default: throw new ArgumentOutOfRangeException(arrangement.GetType().Name); } var comparisonResult = _compareLogic.Compare(arrangementArguments, invocationArguments); if (comparisonResult.AreEqual) { return; } var mockExceptionMessage = _mockFailureMessageFactory.GetInvalidArgumentValueFailureMessage(arrangement, invocation); throw new MockException(mockExceptionMessage); }
public void VerifyGenericTypeArguments(IArrangement arrangement, IInvocation invocation) { var arrangementMethod = arrangement as IArrangementMethod; var arrangementHasNoGenericTypeArguments = arrangementMethod == null; if (arrangementHasNoGenericTypeArguments) { return; } var arrangementGenericArguments = arrangementMethod.GenericArguments; var invocationGenericArguments = invocation.GenericArguments ?? new Type[0]; var comparisonResult = _compareLogic.Compare(arrangementGenericArguments, invocationGenericArguments); if (comparisonResult.AreEqual) { return; } var mockExceptionMessage = _mockFailureMessageFactory.GetGenericTypeArgumentFailureMessage(arrangement, invocation); throw new MockException(mockExceptionMessage); }
/// <summary> /// Add <see cref="PatternConverter.Properties"/> or make use of <see cref="ISerializingPatternConverter.SetUp"/>, /// call <see cref="IOptionHandler.ActivateOptions"/> /// </summary> /// <param name="conv">serializer to be set up, see also <seealso cref="ISerializingPatternConverter"/></param> /// <param name="converters">converters to be used collected from parent class</param> /// <param name="arrangement">arrangement to be used collected from parent class</param> /// <param name="fetcher">fetcher to use</param> /// <param name="renderer">renderer to use</param> /// <param name="decorators">decorators to use</param> /// <remarks> /// <para> /// Please note that properties are only supported with log4net 1.2.11 and above. /// </para> /// </remarks> protected virtual void SetUpSerializingConverter(PatternConverter conv, ConverterInfo[] converters, IArrangement arrangement, IRawLayout fetcher, IObjectRenderer renderer, IDecorator[] decorators) { var serializedConv = conv as ISerializingPatternConverter; if (serializedConv != null) { serializedConv.SetUp(arrangement, converters, fetcher, renderer, decorators); } #if !LOG4NET_1_2_10_COMPATIBLE else { LogLog.Warn(GetType(), String.Format("Converter is not a ISerializingPatternConverter: {0}. Passing fetcher, renderer, decorators, arrangement and converters as properties.", conv)); conv.Properties["arrangement"] = arrangement; conv.Properties["converters"] = converters; conv.Properties["fetcher"] = fetcher; conv.Properties["renderer"] = renderer; conv.Properties["decorators"] = decorators; }
/// <summary> /// Add an arbitrary <see cref="IArrangement"/>. /// This method will be most useful for XML configuration. /// </summary> /// <param name="value">the arrangement</param> public virtual void AddArrangement(IArrangement value) { m_arrangement.AddArrangement(value); }
/// <summary> /// Add <see cref="PatternConverter.Properties"/>, /// call <see cref="IOptionHandler.ActivateOptions"/> /// </summary> /// <param name="conv">serializer to be set up</param> /// <param name="converters">converters to be used collected from parent class</param> /// <param name="arrangement">arrangement to be used collected from parent class</param> /// <param name="fetcher">fetcher to use</param> /// <param name="renderer">renderer to use</param> /// <param name="decorators">decorators to use</param> /// <remarks> /// <para> /// Please note that properties are only supported with log4net 1.2.11 and above. /// </para> /// </remarks> protected virtual void SetUpSerializingConverter(PatternConverter conv, ConverterInfo[] converters, IArrangement arrangement, IRawLayout fetcher, IObjectRenderer renderer, IDecorator[] decorators) { conv.Properties["arrangement"] = arrangement; conv.Properties["converters"] = converters; conv.Properties["fetcher"] = fetcher; conv.Properties["renderer"] = renderer; conv.Properties["decorators"] = decorators; IOptionHandler optionHandler = conv as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } }
public static void Return(this IArrangement arrangement, object value) { arrangement.SetReturnValue(value); MockInvocationCache.Add(arrangement); }
public static void Add(IArrangement arrangement) { MockInvocationAuditor.AddArrangement(arrangement); }
/// <summary> /// Well, add an arrangement /// </summary> /// <param name="arrangement">Arrangement to add</param> public virtual void AddArrangement(IArrangement arrangement) { Arrangements.Add(arrangement); }
/// <inheritdoc cref="IArrangementCollection" /> public void Add(IArrangement arrangement) { Ensures.NotNull(arrangement, nameof(arrangement)); Arrangements.Add(arrangement); }