fluentassertions · dennisdoomen · Apr 19, 2021 · Jan 16, 2021 · Feb 8, 2021 · Feb 8, 2021
diff --git a/Src/FluentAssertions/AssertionOptions.cs b/Src/FluentAssertions/AssertionOptions.cs
@@ -1,6 +1,7 @@
 using System;
 using FluentAssertions.Common;
 using FluentAssertions.Equivalency;
+using FluentAssertions.Formatting;
 
 namespace FluentAssertions
 {
@@ -48,5 +49,10 @@ public static void AssertEquivalencyUsing(
         /// is structurally equivalent to another (collection of) object(s).
         /// </summary>
         public static EquivalencyStepCollection EquivalencySteps { get; }
+
+        /// <summary>
+        /// Gets the default formatting options used by the formatters in Fluent Assertions.
+        /// </summary>
+        public static FormattingOptions FormattingOptions { get; } = new();
     }
 }
diff --git a/Src/FluentAssertions/CallerIdentifier.cs b/Src/FluentAssertions/CallerIdentifier.cs
@@ -131,7 +131,7 @@ internal static bool OnlyOneFluentAssertionScopeOnCallStack()
             int startOfSecondFluentAssertionsScopeStackFrameIndex = Array.FindIndex(
                 allStackFrames,
                 startIndex: firstNonFluentAssertionsStackFrameIndex + 1,
-                frame => IsCurrentAssembly(frame));
+                IsCurrentAssembly);
 
             return startOfSecondFluentAssertionsScopeStackFrameIndex < 0;
         }
@@ -148,7 +148,7 @@ private static bool IsDynamic(StackFrame frame)
 
         private static bool IsCurrentAssembly(StackFrame frame)
         {
-            return frame.GetMethod().DeclaringType.Assembly == typeof(CallerIdentifier).Assembly;
+            return frame.GetMethod().DeclaringType?.Assembly == typeof(CallerIdentifier).Assembly;
         }
 
         private static bool IsDotNet(StackFrame frame)
@@ -162,7 +162,7 @@ private static bool IsDotNet(StackFrame frame)
 
         private static bool IsCompilerServices(StackFrame frame)
         {
-            return frame.GetMethod().DeclaringType.Namespace == "System.Runtime.CompilerServices";
+            return frame.GetMethod().DeclaringType?.Namespace == "System.Runtime.CompilerServices";
         }
 
         private static string ExtractVariableNameFrom(StackFrame frame)

diff --git a/Src/FluentAssertions/Common/Iterator.cs b/Src/FluentAssertions/Common/Iterator.cs
@@ -0,0 +1,145 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace FluentAssertions.Common
+{
+    /// <summary>
+    /// A smarter enumerator that can provide information about the relative location (current, first, last)
+    /// of the current item within the collection without unnecessarily iterating the collection.
+    /// </summary>
+    internal class Iterator<T> : IEnumerator<T>
+    {
+        private const int InitialIndex = -1;
+        private readonly IEnumerable<T> enumerable;
+        private readonly int? maxItems;
+        private IEnumerator<T> enumerator;
+        private T current;
+        private T next;
+
+        private bool hasNext;
+        private bool hasCurrent;
+
+        private bool hasCompleted;
+
+        public Iterator(IEnumerable<T> enumerable, int maxItems = int.MaxValue)
+        {
+            this.enumerable = enumerable;
+            this.maxItems = maxItems;
+
+            Reset();
+        }
+
+        public void Reset()
+        {
+            Index = InitialIndex;
+
+            enumerator = enumerable.GetEnumerator();
+            hasCurrent = false;
+            hasNext = false;
+            hasCompleted = false;
+            current = default;
+            next = default;
+        }
+
+        public int Index { get; private set; }
+
+        public bool IsFirst => Index == 0;
+
+        public bool IsLast => (hasCurrent && !hasNext) || HasReachedMaxItems;
+
+        object IEnumerator.Current => Current;
+
+        public T Current
+        {
+            get
+            {
+                if (!hasCurrent)
+                {
+                    throw new InvalidOperationException($"Please call {nameof(MoveNext)} first");
+                }
+
+                return current;
+            }
+
+            private set
+            {
+                current = value;
+                hasCurrent = true;
+            }
+        }
+
+        public bool MoveNext()
+        {
+            if (!hasCompleted)
+            {
+                if (FetchCurrent())
+                {
+                    PrefetchNext();
+                    return true;
+                }
+            }
+
+            hasCompleted = true;
+            return false;
+        }
+
+        private bool FetchCurrent()
+        {
+            if (hasNext && !HasReachedMaxItems)
+            {
+                Current = next;
+                Index++;
+
+                return true;
+            }
+
+            if (enumerator.MoveNext() && !HasReachedMaxItems)
+            {
+                Current = enumerator.Current;
+                Index++;
+
+                return true;
+            }
+            else
+            {
+                hasCompleted = true;
+                return false;
+            }
+        }
+
+        public bool HasReachedMaxItems => Index == maxItems;
+
+        private void PrefetchNext()
+        {
+            if (enumerator.MoveNext())
+            {
+                next = enumerator.Current;
+                hasNext = true;
+            }
+            else
+            {
+                next = default;
+                hasNext = false;
+            }
+        }
+
+        public bool IsEmpty
+        {
+            get
+            {
+                if (!hasCurrent && !hasCompleted)
+                {
+                    throw new InvalidOperationException($"Please call {nameof(MoveNext)} first");
+                }
+
+                return Index == InitialIndex;
+            }
+        }
+
+        public void Dispose()
+        {
+            enumerator.Dispose();
+        }
+    }
+}
diff --git a/Src/FluentAssertions/Execution/AssertionScope.cs b/Src/FluentAssertions/Execution/AssertionScope.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Threading;
 using FluentAssertions.Common;
+using FluentAssertions.Formatting;
 
 namespace FluentAssertions.Execution
 {
@@ -17,11 +18,11 @@ public sealed class AssertionScope : IAssertionScope
     {
         #region Private Definitions
 
+        private readonly FormattingOptions formattingOptions = AssertionOptions.FormattingOptions.Clone();
         private readonly IAssertionStrategy assertionStrategy;
         private readonly ContextDataItems contextData = new();
 
         private Func<string> reason;
-        private bool useLineBreaks;
 
         private static readonly AsyncLocal<AssertionScope> CurrentScope = new();
         private AssertionScope parent;
@@ -121,16 +122,27 @@ public static AssertionScope Current
             private set => SetCurrentAssertionScope(value);
         }
 
+        /// <summary>
+        /// Forces the formatters that support it to add the necessary line breaks.
+        /// </summary>
+        /// <remarks>
+        /// This is just shorthand for modifying the <see cref="FormattingOptions"/> property.
+        /// </remarks>
         public AssertionScope UsingLineBreaks
         {
             get
             {
-                useLineBreaks = true;
+                formattingOptions.UseLineBreaks = true;
                 return this;
             }
         }
 
-        public bool Succeeded
+        /// <summary>
+        /// Exposes the options the scope will use for formatting objects in case an assertion fails.
+        /// </summary>
+        public FormattingOptions FormattingOptions => formattingOptions;
+
+        internal bool Succeeded
         {
             get => succeeded == true;
         }
@@ -184,7 +196,7 @@ public AssertionScope WithExpectation(string message, params object[] args)
             Func<string> localReason = reason;
             expectation = () =>
             {
-                var messageBuilder = new MessageBuilder(useLineBreaks);
+                var messageBuilder = new MessageBuilder(formattingOptions);
                 string reason = localReason?.Invoke() ?? string.Empty;
                 string identifier = GetIdentifier();
 
@@ -240,7 +252,7 @@ public Continuation FailWith(Func<FailReason> failReasonFunc)
             return FailWith(() =>
             {
                 string localReason = reason?.Invoke() ?? string.Empty;
-                var messageBuilder = new MessageBuilder(useLineBreaks);
+                var messageBuilder = new MessageBuilder(formattingOptions);
                 string identifier = GetIdentifier();
                 FailReason failReason = failReasonFunc();
                 string result = messageBuilder.Build(failReason.Message, failReason.Args, localReason, contextData, identifier, fallbackIdentifier);

diff --git a/Src/FluentAssertions/Execution/MessageBuilder.cs b/Src/FluentAssertions/Execution/MessageBuilder.cs
@@ -16,17 +16,17 @@ namespace FluentAssertions.Execution
     /// </summary>
     internal class MessageBuilder
     {
-        #region Private Definitions
+        private readonly FormattingOptions formattingOptions;
 
-        private readonly bool useLineBreaks;
+        #region Private Definitions
 
         private readonly char[] blanks = { '\r', '\n', ' ', '\t' };
 
         #endregion
 
-        public MessageBuilder(bool useLineBreaks)
+        public MessageBuilder(FormattingOptions formattingOptions)
         {
-            this.useLineBreaks = useLineBreaks;
+            this.formattingOptions = formattingOptions;
         }
 
         // SMELL: Too many parameters.
@@ -89,10 +89,9 @@ private static string SubstituteContextualTags(string message, ContextDataItems
 
         private string FormatArgumentPlaceholders(string failureMessage, object[] failureArgs)
         {
-            string[] values = failureArgs.Select(a => Formatter.ToString(a, useLineBreaks)).ToArray();
-            string formattedMessage = string.Format(CultureInfo.InvariantCulture, failureMessage, values);
+            string[] values = failureArgs.Select(a => Formatter.ToString(a, formattingOptions)).ToArray();
 
-            return formattedMessage;
+            return string.Format(CultureInfo.InvariantCulture, failureMessage, values);
         }
 
         private string SanitizeReason(string reason)

diff --git a/Src/FluentAssertions/Formatting/AggregateExceptionValueFormatter.cs b/Src/FluentAssertions/Formatting/AggregateExceptionValueFormatter.cs
@@ -1,6 +1,5 @@
 using System;
-using System.Globalization;
-using System.Text;
+using static System.FormattableString;
 
 namespace FluentAssertions.Formatting
 {
@@ -18,27 +17,24 @@ public bool CanHandle(object value)
             return value is AggregateException;
         }
 
-        /// <inheritdoc />
-        public string Format(object value, FormattingContext context, FormatChild formatChild)
+        public void Format(object value, FormattedObjectGraph formattedGraph, FormattingContext context, FormatChild formatChild)
         {
             var exception = (AggregateException)value;
             if (exception.InnerExceptions.Count == 1)
             {
-                return "(aggregated) " + formatChild("inner", exception.InnerException);
+                formattedGraph.AddFragment("(aggregated) ");
+
+                formatChild("inner", exception.InnerException, formattedGraph);
             }
             else
             {
-                var builder = new StringBuilder();
-
-                builder.AppendFormat(CultureInfo.InvariantCulture, "{0} (aggregated) exceptions:\n", exception.InnerExceptions.Count);
+                formattedGraph.AddLine(Invariant($"{exception.InnerExceptions.Count} (aggregated) exceptions:"));
 
                 foreach (Exception innerException in exception.InnerExceptions)
                 {
-                    builder.AppendLine();
-                    builder.AppendLine(formatChild("InnerException", innerException));
+                    formattedGraph.AddLine(string.Empty);
+                    formatChild("InnerException", innerException, formattedGraph);
                 }
-
-                return builder.ToString();
             }
         }
     }

diff --git a/Src/FluentAssertions/Formatting/AttributeBasedFormatter.cs b/Src/FluentAssertions/Formatting/AttributeBasedFormatter.cs
@@ -33,14 +33,13 @@ private static bool IsScanningEnabled
             get { return Configuration.Current.ValueFormatterDetectionMode != ValueFormatterDetectionMode.Disabled; }
         }
 
-        /// <inheritdoc />
-        public string Format(object value, FormattingContext context, FormatChild formatChild)
+        public void Format(object value, FormattedObjectGraph formattedGraph, FormattingContext context, FormatChild formatChild)
         {
             MethodInfo method = GetFormatter(value);
 
-            object[] parameters = new[] { value };
+            object[] parameters = new[] { value, formattedGraph };
 
-            return (string)method.Invoke(null, parameters);
+            method.Invoke(null, parameters);
         }
 
         private MethodInfo GetFormatter(object value)
@@ -86,10 +85,11 @@ from type in Services.Reflector.GetAllTypesFromAppDomain(Applicable)
                 where type is not null
                 from method in type.GetMethods(BindingFlags.Static | BindingFlags.Public)
                 where method.IsStatic
-                where method.ReturnType == typeof(string)
+                where method.ReturnType == typeof(void)
                 where method.IsDecoratedWithOrInherit<ValueFormatterAttribute>()
-                where method.GetParameters().Length == 1
-                select new { Type = method.GetParameters().Single().ParameterType, Method = method } into formatter
+                let methodParameters = method.GetParameters()
+                where methodParameters.Length == 2
+                select new { Type = methodParameters.First().ParameterType, Method = method } into formatter
                 group formatter by formatter.Type into formatterGroup
                 select formatterGroup.First();
 

diff --git a/Src/FluentAssertions/Formatting/ByteValueFormatter.cs b/Src/FluentAssertions/Formatting/ByteValueFormatter.cs
@@ -16,10 +16,9 @@ public bool CanHandle(object value)
             return value is byte;
         }
 
-        /// <inheritdoc />
-        public string Format(object value, FormattingContext context, FormatChild formatChild)
+        public void Format(object value, FormattedObjectGraph formattedGraph, FormattingContext context, FormatChild formatChild)
         {
-            return "0x" + ((byte)value).ToString("X2", CultureInfo.InvariantCulture);
+            formattedGraph.AddFragment("0x" + ((byte)value).ToString("X2", CultureInfo.InvariantCulture));
         }
     }
 }