435 $"Collection: [\"a\", null, \"b\", null, \"c\", {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 777 Assert.Equal(message.Replace("$$ELLIPSIS$$", ArgumentFormatter.Ellipsis), ex.Message); 936 "Expected: " + expectedType.PadRight(padding) + $"[EquatableObject {{ {ArgumentFormatter.Ellipsis} }}]" + Environment.NewLine + 937 "Actual: " + actualType.PadRight(padding) + $"[EquatableObject {{ {ArgumentFormatter.Ellipsis} }}]" + Environment.NewLine + 1162 $"Expected: Not {expectedType.PadRight(padding)}[1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 1163 $"Actual: {actualType.PadRight(padding)}[1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]", 1292 "Expected: Not " + expectedType.PadRight(padding) + $"[EquatableObject {{ {ArgumentFormatter.Ellipsis} }}]" + Environment.NewLine + 1293 "Actual: " + actualType.PadRight(padding) + $"[EquatableObject {{ {ArgumentFormatter.Ellipsis} }}]", 1456 $"Collection: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]", 1550 $"Collection: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine +

508 $"Collection: [\"a\", null, \"b\", null, \"c\", {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 843 Environment.NewLine + "Expected: " + expectedType + ArgumentFormatter.Format(expected) + 844 Environment.NewLine + "Actual: " + actualType + ArgumentFormatter.Format(actual); 920 Assert.Equal(message.Replace("$$ELLIPSIS$$", ArgumentFormatter.Ellipsis), ex.Message); 1076 Assert.Equal(message.Replace("$$ELLIPSIS$$", ArgumentFormatter.Ellipsis), ex.Message); 1394 $"Expected: [[a, 1], [be, 2], [c, 3], [d, 4], [e, 5], {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 1395 $"Actual: [[a, 1], [ba, 2], [c, 3], [d, 4], [e, 5], {ArgumentFormatter.Ellipsis}]", 1834 $"Expected: Not int[] [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 1835 $"Actual: List<int> [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]", 2450 $"Collection: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]", 2524 $"Collection: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 2585 $"Collection: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]", 2679 $"Collection: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine +

272 $"Expected: SpyComparable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 273 $"Actual: SpyComparable {{ {ArgumentFormatter.Ellipsis} }}", 307 $"Expected: MultiComparable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 308 $"Actual: MultiComparable {{ {ArgumentFormatter.Ellipsis} }}", 346 $"Expected: MultiComparable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 381 $"Expected: SpyComparable_Generic {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 382 $"Actual: SpyComparable_Generic {{ {ArgumentFormatter.Ellipsis} }}", 442 $"Expected: ComparableBaseClass {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 443 $"Actual: ComparableSubClassA {{ {ArgumentFormatter.Ellipsis} }}", 473 $"Expected: ComparableSubClassA {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 474 $"Actual: ComparableBaseClass {{ {ArgumentFormatter.Ellipsis} }}", 508 $"Expected: ComparableThrower {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 509 $"Actual: ComparableThrower {{ {ArgumentFormatter.Ellipsis} }}", 629 $"Expected: NonComparableObject {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 630 $"Actual: NonComparableObject {{ {ArgumentFormatter.Ellipsis} }}", 666 $"Expected: SpyEquatable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 667 $"Actual: SpyEquatable {{ {ArgumentFormatter.Ellipsis} }}", 697 $"Expected: EquatableSubClassA {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 698 $"Actual: EquatableSubClassB {{ {ArgumentFormatter.Ellipsis} }}", 728 $"Expected: EquatableBaseClass {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 729 $"Actual: EquatableSubClassA {{ {ArgumentFormatter.Ellipsis} }}", 759 $"Expected: EquatableSubClassA {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 760 $"Actual: EquatableBaseClass {{ {ArgumentFormatter.Ellipsis} }}", 853 $"Expected: StructuralStringWrapper {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 854 $"Actual: StructuralStringWrapper {{ {ArgumentFormatter.Ellipsis} }}", 894 $"Actual: Tuple (StringWrapper {{ {ArgumentFormatter.Ellipsis} }})", 921 $"Expected: Tuple (StringWrapper {{ {ArgumentFormatter.Ellipsis} }})" + Environment.NewLine + 1164 $"Expected: UnsafeEnumerable [{ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 1936 $"Expected: [{ArgumentFormatter.Ellipsis}, 2, 3, 4, 5]" + Environment.NewLine + 1937 $"Actual: [{ArgumentFormatter.Ellipsis}, 2, 3, 4, 5, 6]" + Environment.NewLine + 1969 $"Expected: {ArgumentFormatter.Format(expected)}" + Environment.NewLine + 1970 $"Actual: {ArgumentFormatter.Format(actual)}", 2003 $"Expected: {ArgumentFormatter.Format(date1)}" + Environment.NewLine + 2004 $"Actual: {ArgumentFormatter.Format(date2)} (difference {difference} is larger than {precision})", 2014 $"Expected: {ArgumentFormatter.Format(date2)}" + Environment.NewLine + 2015 $"Actual: {ArgumentFormatter.Format(date1)} (difference {difference} is larger than {precision})", 2047 $"Expected: {ArgumentFormatter.Format(expected)}" + Environment.NewLine + 2048 $"Actual: {ArgumentFormatter.Format(actual)}", 2076 $"Expected: {ArgumentFormatter.Format(expected)}" + Environment.NewLine + 2077 $"Actual: {ArgumentFormatter.Format(actual)}", 2110 $"Expected: {ArgumentFormatter.Format(date1)}" + Environment.NewLine + 2111 $"Actual: {ArgumentFormatter.Format(date2)} (difference {difference} is larger than {precision})", 2121 $"Expected: {ArgumentFormatter.Format(date2)}" + Environment.NewLine + 2122 $"Actual: {ArgumentFormatter.Format(date1)} (difference {difference} is larger than {precision})", 2155 $"Expected: {ArgumentFormatter.Format(date1)}" + Environment.NewLine + 2156 $"Actual: {ArgumentFormatter.Format(date2)} (difference {difference} is larger than {precision})", 2166 $"Expected: {ArgumentFormatter.Format(date2)}" + Environment.NewLine + 2167 $"Actual: {ArgumentFormatter.Format(date1)} (difference {difference} is larger than {precision})", 2696 $"Expected: Not SpyComparable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2697 $"Actual: SpyComparable {{ {ArgumentFormatter.Ellipsis} }}", 2730 $"Expected: Not MultiComparable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2731 $"Actual: MultiComparable {{ {ArgumentFormatter.Ellipsis} }}", 2770 $"Expected: Not MultiComparable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2805 $"Expected: Not SpyComparable_Generic {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2806 $"Actual: SpyComparable_Generic {{ {ArgumentFormatter.Ellipsis} }}", 2837 $"Expected: Not ComparableSubClassA {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2838 $"Actual: ComparableSubClassB {{ {ArgumentFormatter.Ellipsis} }}", 2868 $"Expected: Not ComparableBaseClass {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2869 $"Actual: ComparableSubClassA {{ {ArgumentFormatter.Ellipsis} }}", 2899 $"Expected: Not ComparableSubClassA {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2900 $"Actual: ComparableBaseClass {{ {ArgumentFormatter.Ellipsis} }}", 2932 $"Expected: Not ComparableThrower {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 2933 $"Actual: ComparableThrower {{ {ArgumentFormatter.Ellipsis} }}", 3055 $"Expected: Not NonComparableObject {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 3056 $"Actual: NonComparableObject {{ {ArgumentFormatter.Ellipsis} }}", 3089 $"Expected: Not SpyEquatable {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 3090 $"Actual: SpyEquatable {{ {ArgumentFormatter.Ellipsis} }}", 3123 $"Expected: Not EquatableSubClassA {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 3124 $"Actual: EquatableSubClassB {{ {ArgumentFormatter.Ellipsis} }}", 3154 $"Expected: Not EquatableBaseClass {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 3155 $"Actual: EquatableSubClassA {{ {ArgumentFormatter.Ellipsis} }}", 3185 $"Expected: Not EquatableSubClassA {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 3186 $"Actual: EquatableBaseClass {{ {ArgumentFormatter.Ellipsis} }}", 3277 $"Expected: Not StructuralStringWrapper {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 3278 $"Actual: StructuralStringWrapper {{ {ArgumentFormatter.Ellipsis} }}", 4581 $"Expected: Not DerivedClass {{ {ArgumentFormatter.Ellipsis} }}" + Environment.NewLine + 4582 $"Actual: BaseClass {{ {ArgumentFormatter.Ellipsis} }}", 4628 $"Expected: [{ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 4629 $"Actual: [{ArgumentFormatter.Ellipsis}]",

103 "String: \"This is a relatively long string so that we can se\"" + ArgumentFormatter.Ellipsis + Environment.NewLine + 104 "Not found: \"We are looking for something that is actually very\"" + ArgumentFormatter.Ellipsis, 144 "Memory: [1, 2, 3, 4, 5, " + ArgumentFormatter.Ellipsis + "]" + Environment.NewLine + 158 "Memory: [1, 2, 3, 4, 5, " + ArgumentFormatter.Ellipsis + "]" + Environment.NewLine + 296 "String: \"Hello, world from a very long string that will end\"" + ArgumentFormatter.Ellipsis + Environment.NewLine + 311 "String: " + ArgumentFormatter.Ellipsis + "\" string that has 'Hello, world' placed in the midd\"" + ArgumentFormatter.Ellipsis + Environment.NewLine + 326 "String: " + ArgumentFormatter.Ellipsis + "\"om the front truncated, just to say 'Hello, world'\"" + Environment.NewLine + 368 "Memory: [1, 2, 3, 4, 5, " + ArgumentFormatter.Ellipsis + "]" + Environment.NewLine + 383 "Memory: [1, 2, 3, 4, 5, " + ArgumentFormatter.Ellipsis + "]" + Environment.NewLine + 511 "String: " + ArgumentFormatter.Ellipsis + "\"string that we expected to find this ending inside\"" + Environment.NewLine + 512 "Expected end: \"This is a long string that we're looking for at th\"" + ArgumentFormatter.Ellipsis, 626 Environment.NewLine + "Expected: " + ArgumentFormatter.Format(expected) + 627 Environment.NewLine + "Actual: " + ArgumentFormatter.Format(actual); 660 "Expected: \"Why hello there world, you're a long string with s\"" + ArgumentFormatter.Ellipsis + Environment.NewLine + 928 "String: \"This is the long string that we expected to find t\"" + ArgumentFormatter.Ellipsis + Environment.NewLine + 929 "Expected start: \"This is a long string that we're looking for at th\"" + ArgumentFormatter.Ellipsis,

106 $"Actual: Object {{ {ArgumentFormatter.Ellipsis} }}",

12 Assert.Equal("null", ArgumentFormatter.Format(null)); 75 Assert.Equal(expected.Replace("$$ELLIPSIS$$", ArgumentFormatter.Ellipsis), ArgumentFormatter.Format(value)); 116 Assert.Equal(expected, ArgumentFormatter.Format(value)); 124 Assert.Equal(floatPI.ToString("G9"), ArgumentFormatter.Format(floatPI)); 130 Assert.Equal(Math.PI.ToString("G17"), ArgumentFormatter.Format(Math.PI)); 136 Assert.Equal(123.45M.ToString(), ArgumentFormatter.Format(123.45M)); 144 Assert.Equal(now.ToString("o"), ArgumentFormatter.Format(now)); 152 Assert.Equal(now.ToString("o"), ArgumentFormatter.Format(now)); 161 Assert.Equal("Task { Status = RanToCompletion }", ArgumentFormatter.Format(task)); 170 Assert.Equal("Task<int> { Status = Faulted }", ArgumentFormatter.Format(taskCompletionSource.Task)); 201 Assert.Equal(expected, ArgumentFormatter.Format(type)); 221 var actual = ArgumentFormatter.Format(enumValue); 244 var actual = ArgumentFormatter.Format(enumValue); 258 Assert.Equal(expected, ArgumentFormatter.Format(kvp)); 281 Assert.Equal(expected, ArgumentFormatter.Format(collection)); 298 Assert.Equal(expected, ArgumentFormatter.Format(value)); 315 Assert.Equal($"[0, 1, 2, 3, 4, {ArgumentFormatter.Ellipsis}]", ArgumentFormatter.Format(collection)); 325 Assert.Equal($"[42, [42, [42, [{ArgumentFormatter.Ellipsis}]]]]", ArgumentFormatter.Format(looping)); 332 var expected = $"[{ArgumentFormatter.Ellipsis}]"; 339 Assert.Equal(expected, ArgumentFormatter.Format(grouping)); 346 var expected = $"[{ArgumentFormatter.Ellipsis}]"; 353 Assert.Equal(expected, ArgumentFormatter.Format(grouping)); 363 var expected = $"Object {{ {ArgumentFormatter.Ellipsis} }}"; 368 var result = ArgumentFormatter.Format(new object()); 514 var result = ArgumentFormatter.Format(new TypeWithToString()); 542 Assert.Equal(expectedResult, ArgumentFormatter.Format(type)); 551 Assert.Equal("typeof(T)", ArgumentFormatter.Format(parameterType)); 560 Assert.Equal("typeof(TKey)", ArgumentFormatter.Format(parameterTKey)); 563 Assert.Equal("typeof(TValue)", ArgumentFormatter.Format(parameterTValue));

13 var result = tracker.FormatIndexedMismatch(2600, out var pointerIndent, ArgumentFormatter.MaxEnumerableLength + 1); 15 Assert.Equal($"[{ArgumentFormatter.Ellipsis}]", result); 39 Assert.Equal($"[1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]", result); 51 Assert.Equal($"[{ArgumentFormatter.Ellipsis}, 2, 3, 4, 5, 6, {ArgumentFormatter.Ellipsis}]", result); 63 Assert.Equal($"[{ArgumentFormatter.Ellipsis}, 3, 4, 5, 6, 7]", result); 76 var result = CollectionTracker<int>.FormatIndexedMismatch(span, 2600, out var pointerIndent, ArgumentFormatter.MaxEnumerableLength + 1); 78 Assert.Equal($"[{ArgumentFormatter.Ellipsis}]", result); 102 Assert.Equal($"[1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]", result); 114 Assert.Equal($"[{ArgumentFormatter.Ellipsis}, 2, 3, 4, 5, 6, {ArgumentFormatter.Ellipsis}]", result); 126 Assert.Equal($"[{ArgumentFormatter.Ellipsis}, 3, 4, 5, 6, 7]", result); 147 Assert.Equal($"[{ArgumentFormatter.Ellipsis}]", tracker.FormatStart(ArgumentFormatter.MaxEnumerableLength + 1)); 163 Assert.Equal($"[1, {2.3M}, \"Hello, world!\", 42, 2112, {ArgumentFormatter.Ellipsis}]", tracker.FormatStart()); 182 Assert.Equal($"[{ArgumentFormatter.Ellipsis}]", CollectionTracker<object>.FormatStart(collection, ArgumentFormatter.MaxEnumerableLength + 1)); 198 Assert.Equal($"[1, {2.3M}, \"Hello, world!\", 42, 2112, {ArgumentFormatter.Ellipsis}]", CollectionTracker<object>.FormatStart(collection)); 217 Assert.Equal($"[{ArgumentFormatter.Ellipsis}]", CollectionTracker<object>.FormatStart(span, ArgumentFormatter.MaxEnumerableLength + 1)); 233 Assert.Equal($"[1, {2.3M}, \"Hello, world!\", 42, 2112, {ArgumentFormatter.Ellipsis}]", CollectionTracker<object>.FormatStart(span));

103 $"String: \"This is a relatively long string so that we can se\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 144 $"Span: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 158 $"Span: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 296 $"String: \"Hello, world from a very long string that will end\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 311 $"String: {ArgumentFormatter.Ellipsis}\" string that has 'Hello, world' placed in the midd\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 326 $"String: {ArgumentFormatter.Ellipsis}\"om the front truncated, just to say 'Hello, world'\"" + Environment.NewLine + 368 $"Span: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 383 $"Span: [1, 2, 3, 4, 5, {ArgumentFormatter.Ellipsis}]" + Environment.NewLine + 511 "String: " + ArgumentFormatter.Ellipsis + "\"string that we expected to find this ending inside\"" + Environment.NewLine + 512 "Expected end: \"This is a long string that we're looking for at th\"" + ArgumentFormatter.Ellipsis, 626 Environment.NewLine + "Expected: " + ArgumentFormatter.Format(expected) + 627 Environment.NewLine + "Actual: " + ArgumentFormatter.Format(actual); 660 $"Expected: \"Why hello there world, you're a long string with s\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 936 "String: \"This is the long string that we expected to find t\"" + ArgumentFormatter.Ellipsis + Environment.NewLine + 937 "Expected start: \"This is a long string that we're looking for at th\"" + ArgumentFormatter.Ellipsis,

106 $"String: \"This is a relatively long string so that we can se\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 107 $"Not found: \"We are looking for something that is actually very\"{ArgumentFormatter.Ellipsis}", 213 $"String: \"Hello, world from a very long string that will end\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 241 $"String: {ArgumentFormatter.Ellipsis}\" string that has 'Hello, world' placed in the midd\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 269 $"String: {ArgumentFormatter.Ellipsis}\"om the front truncated, just to say 'Hello, world'\"" + Environment.NewLine + 514 "String: " + ArgumentFormatter.Ellipsis + "\"string that we expected to find this ending inside\"" + Environment.NewLine + 515 "Expected end: \"This is a long string that we're looking for at th\"" + ArgumentFormatter.Ellipsis, 636 Environment.NewLine + "Expected: " + ArgumentFormatter.Format(expected) + 637 Environment.NewLine + "Actual: " + ArgumentFormatter.Format(actual); 676 $"Expected: \"Why hello there world, you're a long string with s\"{ArgumentFormatter.Ellipsis}" + Environment.NewLine + 708 $"Expected: {ArgumentFormatter.Ellipsis}\"01234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 709 $"Actual: {ArgumentFormatter.Ellipsis}\"0123456789012345678901234567890123456789\"", 739 $"Expected: {ArgumentFormatter.Ellipsis}\"01234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 740 $"Actual: {ArgumentFormatter.Ellipsis}\"0123456789012345678901234567890123456789\"", 769 $"Expected: {ArgumentFormatter.Ellipsis}\"0123456789012345678901234567890123456789\"" + Environment.NewLine + 770 $"Actual: {ArgumentFormatter.Ellipsis}\"01234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 800 $"Expected: {ArgumentFormatter.Ellipsis}\"23456789012345678901234567890123456789\"" + Environment.NewLine + 801 $"Actual: {ArgumentFormatter.Ellipsis}\"234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 832 $"Expected: {ArgumentFormatter.Ellipsis}\"01234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 833 $"Actual: {ArgumentFormatter.Ellipsis}\"0123456789012345678901234567890123456789_1234\"" + Environment.NewLine + 864 $"Expected: {ArgumentFormatter.Ellipsis}\"01234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 865 $"Actual: {ArgumentFormatter.Ellipsis}\"0123456789012345678901234567890123456789_1234\"" + Environment.NewLine + 896 $"Expected: {ArgumentFormatter.Ellipsis}\"0123456789012345678901234567890123456789_1234\"" + Environment.NewLine + 897 $"Actual: {ArgumentFormatter.Ellipsis}\"01234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 928 $"Expected: {ArgumentFormatter.Ellipsis}\"23456789012345678901234567890123456789_1234\"" + Environment.NewLine + 929 $"Actual: {ArgumentFormatter.Ellipsis}\"234567890123456789012345678901234567890123456789\"" + Environment.NewLine + 1150 "String: \"This is the long string that we expected to find t\"" + ArgumentFormatter.Ellipsis + Environment.NewLine + 1151 "Expected start: \"This is a long string that we're looking for at th\"" + ArgumentFormatter.Ellipsis,

115 errors.Add(new Tuple<int, string, Exception>(idx, ArgumentFormatter.Format(item), ex)); 214 errors.Add(new Tuple<int, string, Exception>(idx, ArgumentFormatter.Format(item), ex)); 357 throw ContainsException.ForCollectionItemNotFound(ArgumentFormatter.Format(expected), tracker.FormatStart()); 413 throw DistinctException.ForDuplicateItem(ArgumentFormatter.Format(item), tracker.FormatStart()); 476 ArgumentFormatter.Format(expected), 713 GetSingleResult(collection.Cast<object>(), item => object.Equals(item, expected), ArgumentFormatter.Format(expected));

42 ArgumentFormatter.Format(expected), 70 ArgumentFormatter.Format(expected), 166 ArgumentFormatter.Format(expected), 192 ArgumentFormatter.Format(expected),

103 expected as string ?? ArgumentFormatter.Format(expected), 104 actual as string ?? ArgumentFormatter.Format(actual), 186 formattedExpected = expectedTracker?.FormatIndexedMismatch(expectedStartIdx, expectedEndIdx, mismatchedIndex, out expectedPointer) ?? ArgumentFormatter.Format(expected); 190 formattedActual = actualTracker?.FormatIndexedMismatch(actualStartIdx, actualEndIdx, mismatchedIndex, out actualPointer) ?? ArgumentFormatter.Format(actual); 205 formattedExpected = ArgumentFormatter.Format(expected); 206 formattedActual = ArgumentFormatter.Format(actual); 219 var expectedTypeName = expectedType == null ? "" : (AssertHelper.IsCompilerGenerated(expectedType) ? "<generated> " : ArgumentFormatter.FormatTypeName(expectedType) + " "); 220 var actualTypeName = actualType == null ? "" : (AssertHelper.IsCompilerGenerated(actualType) ? "<generated> " : ArgumentFormatter.FormatTypeName(actualType) + " "); 436 ArgumentFormatter.Format(actual) + 439 throw EqualException.ForMismatchedValues(ArgumentFormatter.Format(expected), actualValue); 470 ArgumentFormatter.Format(actual) + 473 throw EqualException.ForMismatchedValues(ArgumentFormatter.Format(expected), actualValue); 554 var formattedExpected = ArgumentFormatter.Format(expected); 555 var formattedActual = ArgumentFormatter.Format(actual); 623 formattedExpected = expectedTracker?.FormatIndexedMismatch(expectedStartIdx, expectedEndIdx, mismatchedIndex, out expectedPointer) ?? ArgumentFormatter.Format(expected); 626 formattedActual = actualTracker?.FormatIndexedMismatch(actualStartIdx, actualEndIdx, mismatchedIndex, out actualPointer) ?? ArgumentFormatter.Format(actual); 641 formattedExpected = ArgumentFormatter.Format(expected); 642 formattedActual = ArgumentFormatter.Format(actual); 655 var expectedTypeName = expectedType == null ? "" : (AssertHelper.IsCompilerGenerated(expectedType) ? "<generated> " : ArgumentFormatter.FormatTypeName(expectedType) + " "); 656 var actualTypeName = actualType == null ? "" : (AssertHelper.IsCompilerGenerated(actualType) ? "<generated> " : ArgumentFormatter.FormatTypeName(actualType) + " ");

36 throw EqualException.ForMismatchedValues(ArgumentFormatter.Format(expected), ArgumentFormatter.Format(actual)); 40 throw EqualException.ForMismatchedValues(ArgumentFormatter.Format(expected), ArgumentFormatter.Format(actual)); 45 ArgumentFormatter.Format(expected.Value.Key), 46 ArgumentFormatter.Format(actual.Value.Key), 53 ArgumentFormatter.Format(expected.Value.Value), 54 ArgumentFormatter.Format(actual.Value.Value), 116 throw NotEqualException.ForEqualValues(ArgumentFormatter.Format(expected.Value), ArgumentFormatter.Format(actual.Value)); 137 ArgumentFormatter.Format(expected), 138 ArgumentFormatter.Format(actual) 160 ArgumentFormatter.Format(expected), 161 ArgumentFormatter.Format(actual)

49 ArgumentFormatter.Format(expected), 50 ArgumentFormatter.Format(actual)

66 if (ArgumentFormatter.MaxStringLength == int.MaxValue) 69 var halfMaxLength = ArgumentFormatter.MaxStringLength / 2; 71 var end = Math.Min(start + ArgumentFormatter.MaxStringLength, value.Length); 72 start = Math.Max(end - ArgumentFormatter.MaxStringLength, 0); 235 printedValue.Append(ArgumentFormatter.Ellipsis); 262 printedValue.Append(ArgumentFormatter.Ellipsis);

444 if (depth > ArgumentFormatter.MaxEnumerableLength) 447 return ArgumentFormatter.EllipsisInBrackets; 503 if (depth > ArgumentFormatter.MaxEnumerableLength) 506 return ArgumentFormatter.EllipsisInBrackets; 511 if (ArgumentFormatter.MaxEnumerableLength == int.MaxValue) 518 startIndex = Math.Max(0, (mismatchedIndex ?? 0) - ArgumentFormatter.MaxEnumerableLength / 2); 519 endIndex = Math.Min(span.Length - 1, startIndex + ArgumentFormatter.MaxEnumerableLength - 1); 520 startIndex = Math.Max(0, endIndex - ArgumentFormatter.MaxEnumerableLength + 1); 553 printedValues.Append(ArgumentFormatter.Ellipsis + ", "); 563 printedValues.Append(ArgumentFormatter.Format(indexer(idx), depth)); 567 printedValues.Append(", " + ArgumentFormatter.Ellipsis); 576 if (depth > ArgumentFormatter.MaxEnumerableLength) 577 return ArgumentFormatter.EllipsisInBrackets; 583 while (enumerator.CurrentIndex <= ArgumentFormatter.MaxEnumerableLength) 602 if (depth > ArgumentFormatter.MaxEnumerableLength) 603 return ArgumentFormatter.EllipsisInBrackets; 610 while (currentIndex <= ArgumentFormatter.MaxEnumerableLength) 632 if (depth > ArgumentFormatter.MaxEnumerableLength) 633 return ArgumentFormatter.EllipsisInBrackets; 640 while (currentIndex <= ArgumentFormatter.MaxEnumerableLength) 658 var printLength = Math.Min(currentIndex + 1, ArgumentFormatter.MaxEnumerableLength); 665 printedValues.Append(ArgumentFormatter.Format(indexer(idx), depth)); 668 if (currentIndex >= ArgumentFormatter.MaxEnumerableLength) 669 printedValues.Append(", " + ArgumentFormatter.Ellipsis); 701 if (ArgumentFormatter.MaxEnumerableLength == int.MaxValue) 708 startIndex = Math.Max(0, (mismatchedIndex ?? 0) - ArgumentFormatter.MaxEnumerableLength / 2); 709 endIndex = startIndex + ArgumentFormatter.MaxEnumerableLength - 1; 719 if (ArgumentFormatter.MaxEnumerableLength != int.MaxValue) 720 startIndex = Math.Max(0, endIndex - ArgumentFormatter.MaxEnumerableLength + 1); 770 ArgumentFormatter.MaxEnumerableLength == int.MaxValue 857 readonly T[] currentItemsRingBuffer = new T[ArgumentFormatter.MaxEnumerableLength]; 868 var itemIndex = Math.Max(0, CurrentIndex - ArgumentFormatter.MaxEnumerableLength + 1); 870 var indexInRingBuffer = (currentItemsLastInsertionIndex - CurrentIndex + itemIndex) % ArgumentFormatter.MaxEnumerableLength; 872 indexInRingBuffer += ArgumentFormatter.MaxEnumerableLength; 879 indexInRingBuffer = (indexInRingBuffer + 1) % ArgumentFormatter.MaxEnumerableLength; 903 if (CurrentIndex <= ArgumentFormatter.MaxEnumerableLength) 908 currentItemsLastInsertionIndex = (currentItemsLastInsertionIndex + 1) % ArgumentFormatter.MaxEnumerableLength; 930 if (index < 0 || index <= CurrentIndex - ArgumentFormatter.MaxEnumerableLength || index > CurrentIndex) 936 var indexInRingBuffer = (currentItemsLastInsertionIndex - CurrentIndex + index) % ArgumentFormatter.MaxEnumerableLength; 938 indexInRingBuffer += ArgumentFormatter.MaxEnumerableLength;

34 var elementTypeX = ArgumentFormatter.GetSetElementType(x.InnerEnumerable); 35 var elementTypeY = ArgumentFormatter.GetSetElementType(y.InnerEnumerable);

108 error = ArgumentFormatter.UnwrapException(error); 266 ForMismatchedValues(ArgumentFormatter.Format(expected), ArgumentFormatter.Format(actual), banner); 308 expected as string ?? ArgumentFormatter.Format(expected), 309 actual as string ?? ArgumentFormatter.Format(actual),

102 ArgumentFormatter.Format(expected), 104 ArgumentFormatter.Format(actual) 161 ArgumentFormatter.Format(expected), 163 ArgumentFormatter.Format(actual) 191 ArgumentFormatter.Format(expected), 193 ArgumentFormatter.Format(actual) 226 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)), 228 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actualLeftovers), actualLeftovers)), 229 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual)) 254 ArgumentFormatter.FormatTypeName(Assert.GuardArgumentNotNull(nameof(expectedType), expectedType), fullTypeName: true), 256 ArgumentFormatter.FormatTypeName(Assert.GuardArgumentNotNull(nameof(actualType), actualType), fullTypeName: true)

43 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(low), low)), 44 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(high), high)), 46 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual))

49 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)), 51 ArgumentFormatter.Format(actual?.GetType())

41 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)), 43 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual).GetType())

41 ArgumentFormatter.Format(expectedType), 43 ArgumentFormatter.Format(actualType)

45 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expectedRegexPattern), expectedRegexPattern)), 47 ArgumentFormatter.Format(actual)

85 error = ArgumentFormatter.UnwrapException(error);

43 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(low), low)), 44 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(high), high)), 46 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual))

37 ArgumentFormatter.FormatTypeName(Assert.GuardArgumentNotNull(nameof(type), type)) 51 ArgumentFormatter.FormatTypeName(Assert.GuardArgumentNotNull(nameof(type), type))

45 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(unexpected), unexpected)),

40 ArgumentFormatter.FormatTypeName(Assert.GuardArgumentNotNull(nameof(type), type)) 58 ArgumentFormatter.FormatTypeName(Assert.GuardArgumentNotNull(nameof(type), type)), 61 ArgumentFormatter.Format(actual) 77 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual))

38 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)),

41 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)), 43 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual)) 65 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)),

50 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)), 52 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual).GetType()) 83 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected))

50 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)), 52 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(actual), actual).GetType()) 78 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected)), 80 ArgumentFormatter.Format(expectedParamName), 82 ArgumentFormatter.Format(actualParamName) 112 ArgumentFormatter.Format(Assert.GuardArgumentNotNull(nameof(expected), expected))

34 ArgumentFormatter.Format(expected), 57 ArgumentFormatter.Format(expected), 127 ArgumentFormatter.Format(expected), 149 ArgumentFormatter.Format(expected),

289 expectedTypeFormatted = ArgumentFormatter.FormatTypeName(expectedType); 290 actualTypeFormatted = ArgumentFormatter.FormatTypeName(actualType); 320 expectedTypeFormatted = ArgumentFormatter.FormatTypeName(expectedType); 321 actualTypeFormatted = ArgumentFormatter.FormatTypeName(actualType);

262 throw IsTypeException.ForMismatchedType(ArgumentFormatter.Format(expectedType), null); 264 throw IsTypeException.ForIncompatibleType(ArgumentFormatter.Format(expectedType), null); 275 var expectedTypeName = ArgumentFormatter.Format(expectedType); 276 var actualTypeName = ArgumentFormatter.Format(actualType);