diff --git a/Versions.props b/Versions.props index 3134aa4..9fda936 100644 --- a/Versions.props +++ b/Versions.props @@ -10,9 +10,9 @@ 3.7.115 5.3.0 1.0.0-alpha.160 - 1.19.0 + 1.20.0-pre.4 2.9.3 - 1.0.2-pre.4 + 1.1.0-pre.3 diff --git a/src/xunit.runner.visualstudio/Utility/RunSettings.cs b/src/xunit.runner.visualstudio/Utility/RunSettings.cs index 3edbd91..52e9e0f 100644 --- 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(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 index 7e12409..0def5cb 100644 --- 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 = +$@" + + + {value} + +"; + + 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> ZeroOrMore = [("blarch", null), ("-1", null), ("0", 0), ("42", 42)]; + + [Theory] + [MemberData(nameof(ZeroOrMore))] + public void PrintMaxEnumerableLength(string value, int? expected) + { + string settingsXml = +$@" + + + {value} + +"; + + var runSettings = RunSettings.Parse(settingsXml); + + Assert.Equal(expected, runSettings.PrintMaxEnumerableLength); + } + + [Theory] + [MemberData(nameof(ZeroOrMore))] + public void PrintMaxObjectDepth(string value, int? expected) + { + string settingsXml = +$@" + + + {value} + +"; + + var runSettings = RunSettings.Parse(settingsXml); + + Assert.Equal(expected, runSettings.PrintMaxObjectDepth); + } + + [Theory] + [MemberData(nameof(ZeroOrMore))] + public void PrintMaxObjectMemberCount(string value, int? expected) + { + string settingsXml = +$@" + + + {value} + +"; + + var runSettings = RunSettings.Parse(settingsXml); + + Assert.Equal(expected, runSettings.PrintMaxObjectMemberCount); + } + + [Theory] + [MemberData(nameof(ZeroOrMore))] + public void PrintMaxStringLength(string value, int? expected) + { + string settingsXml = +$@" + + + {value} + +"; + + var runSettings = RunSettings.Parse(settingsXml); + + Assert.Equal(expected, runSettings.PrintMaxStringLength); + } + [Theory] [InlineData(false)] [InlineData(true)]