Add support for configuring maximum print lengths in assertion messages

xunit · Jan 24, 2025 · c676360 · c676360
1 parent c157d6f
commit c676360
Show file tree

Hide file tree

Showing 3 changed files with 138 additions and 2 deletions.
diff --git a/Versions.props b/Versions.props
@@ -10,9 +10,9 @@
     <NerdbankGitVersioningVersion>3.7.115</NerdbankGitVersioningVersion>
     <NSubstituteVersion>5.3.0</NSubstituteVersion>
     <TunnelVisionLabsReferenceAssemblyAnnotatorVersion>1.0.0-alpha.160</TunnelVisionLabsReferenceAssemblyAnnotatorVersion>
-    <XunitAnalyzersVersion>1.19.0</XunitAnalyzersVersion>
+    <XunitAnalyzersVersion>1.20.0-pre.4</XunitAnalyzersVersion>
     <XunitV2Version>2.9.3</XunitV2Version>
-    <XunitV3Version>1.0.2-pre.4</XunitV3Version>
+    <XunitV3Version>1.1.0-pre.3</XunitV3Version>
   </PropertyGroup>
 
 </Project>
diff --git a/src/xunit.runner.visualstudio/Utility/RunSettings.cs b/src/xunit.runner.visualstudio/Utility/RunSettings.cs
@@ -9,6 +9,7 @@ namespace Xunit.Runner.VisualStudio;
 internal class RunSettings
 {
 	public AppDomainSupport? AppDomain { get; set; }
+	public int? AssertEquivalentMaxDepth { get; set; }
 	public string? Culture { get; set; }
 	public bool DesignMode { get; set; } = false;
 	public bool? DiagnosticMessages { get; set; }
@@ -25,6 +26,10 @@ internal class RunSettings
 	public bool? ParallelizeAssembly { get; set; }
 	public bool? ParallelizeTestCollections { get; set; }
 	public bool? PreEnumerateTheories { get; set; }
+	public int? PrintMaxEnumerableLength { get; set; }
+	public int? PrintMaxObjectDepth { get; set; }
+	public int? PrintMaxObjectMemberCount { get; set; }
+	public int? PrintMaxStringLength { get; set; }
 	public string? ReporterSwitch { get; set; }
 	public int? Seed { get; set; }
 	public bool? ShadowCopy { get; set; }
@@ -36,6 +41,8 @@ public void CopyTo(TestAssemblyConfiguration configuration)
 	{
 		if (AppDomain.HasValue)
 			configuration.AppDomain = AppDomain;
+		if (AssertEquivalentMaxDepth.HasValue)
+			configuration.AssertEquivalentMaxDepth = AssertEquivalentMaxDepth;
 		if (Culture is not null)
 			configuration.Culture = Culture.ToUpperInvariant() switch
 			{
@@ -69,6 +76,14 @@ public void CopyTo(TestAssemblyConfiguration configuration)
 			configuration.ParallelizeTestCollections = ParallelizeTestCollections;
 		if (PreEnumerateTheories.HasValue)
 			configuration.PreEnumerateTheories = PreEnumerateTheories;
+		if (PrintMaxEnumerableLength.HasValue)
+			configuration.PrintMaxEnumerableLength = PrintMaxEnumerableLength;
+		if (PrintMaxObjectDepth.HasValue)
+			configuration.PrintMaxObjectDepth = PrintMaxObjectDepth;
+		if (PrintMaxObjectMemberCount.HasValue)
+			configuration.PrintMaxObjectMemberCount = PrintMaxObjectMemberCount;
+		if (PrintMaxStringLength.HasValue)
+			configuration.PrintMaxStringLength = PrintMaxStringLength;
 		if (Seed.HasValue)
 			configuration.Seed = Seed;
 		if (ShadowCopy.HasValue)
@@ -99,6 +114,10 @@ public static RunSettings Parse(string? settingsXml)
 						if (Enum.TryParse<AppDomainSupport>(appDomainString, ignoreCase: true, out var appDomain))
 							result.AppDomain = appDomain;
 
+						var assertEquivalentMaxDepthString = xunitElement.Element(Constants.Xunit.AssertEquivalentMaxDepth)?.Value;
+						if (int.TryParse(assertEquivalentMaxDepthString, out var assertEquivalentMaxDepth) && assertEquivalentMaxDepth >= 1)
+							result.AssertEquivalentMaxDepth = assertEquivalentMaxDepth;
+
 						result.Culture = xunitElement.Element(Constants.Xunit.Culture)?.Value;
 
 						var diagnosticMessagesString = xunitElement.Element(Constants.Xunit.DiagnosticMessages)?.Value;
@@ -177,6 +196,22 @@ public static RunSettings Parse(string? settingsXml)
 						if (bool.TryParse(preEnumerateTheoriesString, out var preEnumerateTheories))
 							result.PreEnumerateTheories = preEnumerateTheories;
 
+						var printMaxEnumerableLengthString = xunitElement.Element(Constants.Xunit.PrintMaxEnumerableLength)?.Value;
+						if (int.TryParse(printMaxEnumerableLengthString, out var printMaxEnumerableLength) && printMaxEnumerableLength >= 0)
+							result.PrintMaxEnumerableLength = printMaxEnumerableLength;
+
+						var printMaxObjectDepthString = xunitElement.Element(Constants.Xunit.PrintMaxObjectDepth)?.Value;
+						if (int.TryParse(printMaxObjectDepthString, out var printMaxObjectDepth) && printMaxObjectDepth >= 0)
+							result.PrintMaxObjectDepth = printMaxObjectDepth;
+
+						var printMaxObjectMemberCountString = xunitElement.Element(Constants.Xunit.PrintMaxObjectMemberCount)?.Value;
+						if (int.TryParse(printMaxObjectMemberCountString, out var printMaxObjectMemberCount) && printMaxObjectMemberCount >= 0)
+							result.PrintMaxObjectMemberCount = printMaxObjectMemberCount;
+
+						var printMaxStringLengthString = xunitElement.Element(Constants.Xunit.PrintMaxStringLength)?.Value;
+						if (int.TryParse(printMaxStringLengthString, out var printMaxStringLength) && printMaxStringLength >= 0)
+							result.PrintMaxStringLength = printMaxStringLength;
+
 						var reporterSwitchString = xunitElement.Element(Constants.Xunit.ReporterSwitch)?.Value;
 						if (reporterSwitchString is not null)
 							result.ReporterSwitch = reporterSwitchString;
@@ -263,6 +298,7 @@ public static class RunConfiguration
 		public static class Xunit
 		{
 			public const string AppDomain = nameof(AppDomain);
+			public const string AssertEquivalentMaxDepth = nameof(AssertEquivalentMaxDepth);
 			public const string Culture = nameof(Culture);
 			public const string DiagnosticMessages = nameof(DiagnosticMessages);
 			public const string Explicit = nameof(Explicit);
@@ -278,6 +314,10 @@ public static class Xunit
 			public const string ParallelizeAssembly = nameof(ParallelizeAssembly);
 			public const string ParallelizeTestCollections = nameof(ParallelizeTestCollections);
 			public const string PreEnumerateTheories = nameof(PreEnumerateTheories);
+			public const string PrintMaxEnumerableLength = nameof(PrintMaxEnumerableLength);
+			public const string PrintMaxObjectDepth = nameof(PrintMaxObjectDepth);
+			public const string PrintMaxObjectMemberCount = nameof(PrintMaxObjectMemberCount);
+			public const string PrintMaxStringLength = nameof(PrintMaxStringLength);
 			public const string Seed = nameof(Seed);
 			public const string ReporterSwitch = nameof(ReporterSwitch);
 			public const string ShadowCopy = nameof(ShadowCopy);

diff --git a/test/test.xunit.runner.visualstudio/RunSettingsTests.cs b/test/test.xunit.runner.visualstudio/RunSettingsTests.cs
@@ -1,6 +1,7 @@
 extern alias VSTestAdapter;
 
 using System;
+using System.Collections.Generic;
 using Xunit;
 using Xunit.Runner.Common;
 using Xunit.Sdk;
@@ -11,6 +12,7 @@ public class RunSettingsTests
 	void AssertDefaultValues(RunSettings runSettings)
 	{
 		Assert.Null(runSettings.AppDomain);
+		Assert.Null(runSettings.AssertEquivalentMaxDepth);
 		Assert.False(runSettings.DesignMode);
 		Assert.Null(runSettings.DiagnosticMessages);
 		Assert.Null(runSettings.FailSkips);
@@ -24,6 +26,10 @@ void AssertDefaultValues(RunSettings runSettings)
 		Assert.Null(runSettings.ParallelizeAssembly);
 		Assert.Null(runSettings.ParallelizeTestCollections);
 		Assert.Null(runSettings.PreEnumerateTheories);
+		Assert.Null(runSettings.PrintMaxEnumerableLength);
+		Assert.Null(runSettings.PrintMaxObjectDepth);
+		Assert.Null(runSettings.PrintMaxObjectMemberCount);
+		Assert.Null(runSettings.PrintMaxStringLength);
 		Assert.Null(runSettings.ReporterSwitch);
 		Assert.Null(runSettings.ShadowCopy);
 		Assert.Null(runSettings.ShowLiveOutput);
@@ -169,6 +175,26 @@ public void AppDomain(string value, AppDomainSupport? expected)
 		Assert.Equal(expected, runSettings.AppDomain);
 	}
 
+	[Theory]
+	[InlineData("blarch", null)]
+	[InlineData("0", null)]
+	[InlineData("1", 1)]
+	[InlineData("42", 42)]
+	public void AssertEquivalentMaxDepth(string value, int? expected)
+	{
+		string settingsXml =
+$@"<?xml version=""1.0"" encoding=""utf-8""?>
+<RunSettings>
+	<xUnit>
+		<AssertEquivalentMaxDepth>{value}</AssertEquivalentMaxDepth>
+	</xUnit>
+</RunSettings>";
+
+		var runSettings = RunSettings.Parse(settingsXml);
+
+		Assert.Equal(expected, runSettings.AssertEquivalentMaxDepth);
+	}
+
 	[Theory]
 	[InlineData(0, null)]
 	[InlineData(1, 1)]
@@ -260,6 +286,76 @@ public void MethodDisplayOptions(string value, TestMethodDisplayOptions? expecte
 		Assert.Equal(expected, runSettings.MethodDisplayOptions);
 	}
 
+	public static IEnumerable<TheoryDataRow<string, int?>> ZeroOrMore = [("blarch", null), ("-1", null), ("0", 0), ("42", 42)];
+
+	[Theory]
+	[MemberData(nameof(ZeroOrMore))]
+	public void PrintMaxEnumerableLength(string value, int? expected)
+	{
+		string settingsXml =
+$@"<?xml version=""1.0"" encoding=""utf-8""?>
+<RunSettings>
+	<xUnit>
+		<PrintMaxEnumerableLength>{value}</PrintMaxEnumerableLength>
+	</xUnit>
+</RunSettings>";
+
+		var runSettings = RunSettings.Parse(settingsXml);
+
+		Assert.Equal(expected, runSettings.PrintMaxEnumerableLength);
+	}
+
+	[Theory]
+	[MemberData(nameof(ZeroOrMore))]
+	public void PrintMaxObjectDepth(string value, int? expected)
+	{
+		string settingsXml =
+$@"<?xml version=""1.0"" encoding=""utf-8""?>
+<RunSettings>
+	<xUnit>
+		<PrintMaxObjectDepth>{value}</PrintMaxObjectDepth>
+	</xUnit>
+</RunSettings>";
+
+		var runSettings = RunSettings.Parse(settingsXml);
+
+		Assert.Equal(expected, runSettings.PrintMaxObjectDepth);
+	}
+
+	[Theory]
+	[MemberData(nameof(ZeroOrMore))]
+	public void PrintMaxObjectMemberCount(string value, int? expected)
+	{
+		string settingsXml =
+$@"<?xml version=""1.0"" encoding=""utf-8""?>
+<RunSettings>
+	<xUnit>
+		<PrintMaxObjectMemberCount>{value}</PrintMaxObjectMemberCount>
+	</xUnit>
+</RunSettings>";
+
+		var runSettings = RunSettings.Parse(settingsXml);
+
+		Assert.Equal(expected, runSettings.PrintMaxObjectMemberCount);
+	}
+
+	[Theory]
+	[MemberData(nameof(ZeroOrMore))]
+	public void PrintMaxStringLength(string value, int? expected)
+	{
+		string settingsXml =
+$@"<?xml version=""1.0"" encoding=""utf-8""?>
+<RunSettings>
+	<xUnit>
+		<PrintMaxStringLength>{value}</PrintMaxStringLength>
+	</xUnit>
+</RunSettings>";
+
+		var runSettings = RunSettings.Parse(settingsXml);
+
+		Assert.Equal(expected, runSettings.PrintMaxStringLength);
+	}
+
 	[Theory]
 	[InlineData(false)]
 	[InlineData(true)]