Update MSTest to 4.0.2 (#1584)

Youssef1313 · web-flow · commit 876987856aa4 · 2025-12-03T06:24:57.000-08:00
* Update MSTest to 4.0.2

* Delete test/Microsoft.ComponentDetection.TestsUtilities/Attributes/SkipTestOnWindowsAttribute.cs

* Delete test/Microsoft.ComponentDetection.TestsUtilities/Attributes/SkipTestIfNotWindowsAttribute.cs

* Remove expected exception usages

* Suppress

* OSCondition

* OSCondition

* OSCondition

* Update GoComponentTests.cs

* Update CommandLineInvocationServiceTests.cs

* Update DockerServiceTests.cs

* Update SafeFileEnumerableTests.cs
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -23,6 +23,9 @@
     <PackageReleaseNotes>https://github.com/microsoft/component-detection/releases</PackageReleaseNotes>
     <!-- https://github.com/NuGet/Home/issues/11822#issuecomment-1218230674 -->
     <NoWarn>$(NoWarn);NU1507</NoWarn>
+
+    <!-- MSTest analyzer for enabling parallelization. To be addressed later. -->
+    <NoWarn>$(NoWarn);MSTEST0001</NoWarn>
   </PropertyGroup>
 
   <ItemGroup Label="Package References">
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -21,9 +21,9 @@
     <PackageVersion Include="MinVer" Version="6.0.0" />
     <PackageVersion Include="Moq" Version="4.18.4" />
     <PackageVersion Include="morelinq" Version="4.4.0" />
-    <PackageVersion Include="MSTest.TestFramework" Version="3.11.1" />
-    <PackageVersion Include="MSTest.Analyzers" Version="3.11.1" />
-    <PackageVersion Include="MSTest.TestAdapter" Version="3.11.1" />
+    <PackageVersion Include="MSTest.TestFramework" Version="4.0.2" />
+    <PackageVersion Include="MSTest.Analyzers" Version="4.0.2" />
+    <PackageVersion Include="MSTest.TestAdapter" Version="4.0.2" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
     <PackageVersion Include="Newtonsoft.Json.Schema" Version="4.0.1" />
diff --git a/test/Microsoft.ComponentDetection.Common.Tests/CommandLineInvocationServiceTests.cs b/test/Microsoft.ComponentDetection.Common.Tests/CommandLineInvocationServiceTests.cs
@@ -6,7 +6,6 @@ namespace Microsoft.ComponentDetection.Common.Tests;
 using System.Text;
 using System.Threading.Tasks;
 using AwesomeAssertions;
-using Microsoft.ComponentDetection.TestsUtilities;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 [TestClass]
@@ -22,28 +21,32 @@ public void TestInitialize()
         this.commandLineService = new CommandLineInvocationService();
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task ShowsCmdExeAsExecutableAsync()
     {
         var result = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");
         result.Should().BeTrue();
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task FallbackWorksIfBadCommandsAreFirstAsync()
     {
         var result = await this.commandLineService.CanCommandBeLocatedAsync("57AB44A4-885A-47F4-866C-41417133B983", ["fakecommandexecutable.exe", "cmd.exe"], "/C");
         result.Should().BeTrue();
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task ReturnsFalseIfNoValidCommandIsFoundAsync()
     {
         var result = await this.commandLineService.CanCommandBeLocatedAsync("57AB44A4-885A-47F4-866C-41417133B983", ["fakecommandexecutable.exe"], "/C");
         result.Should().BeFalse();
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task ReturnsStandardOutputAsync()
     {
         var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");
@@ -54,7 +57,8 @@ public async Task ReturnsStandardOutputAsync()
         taskResult.StdOut.Replace(Environment.NewLine, string.Empty).Should().Be("Expected Output");
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task ExecutesCommandEvenWithLargeStdOutAsync()
     {
         var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");
@@ -76,7 +80,8 @@ public async Task ExecutesCommandEvenWithLargeStdOutAsync()
                 taskResult.StdOut.Length < 100 ? $"Stdout was '{taskResult.StdOut}', which is shorter than 8100 chars" : $"Length was {taskResult.StdOut.Length}, which is less than 8100");
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task ExecutesCommandCapturingErrorOutputAsync()
     {
         var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");
@@ -95,7 +100,8 @@ public async Task ExecutesCommandCapturingErrorOutputAsync()
         taskResult.StdOut.Should().BeEmpty();
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task ExecutesInAWorkingDirectoryAsync()
     {
         var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");
@@ -108,7 +114,8 @@ public async Task ExecutesInAWorkingDirectoryAsync()
         taskResult.StdOut.Should().Contain(tempDirectoryPath);
     }
 
-    [SkipTestIfNotWindows]
+    [TestMethod]
+    [OSCondition(OperatingSystems.Windows)]
     public async Task ThrowsIfWorkingDirectoryDoesNotExistAsync()
     {
         var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");
diff --git a/test/Microsoft.ComponentDetection.Common.Tests/DockerServiceTests.cs b/test/Microsoft.ComponentDetection.Common.Tests/DockerServiceTests.cs
@@ -5,7 +5,6 @@ namespace Microsoft.ComponentDetection.Common.Tests;
 using System.Threading.Tasks;
 using AwesomeAssertions;
 using Docker.DotNet.Models;
-using Microsoft.ComponentDetection.TestsUtilities;
 using Microsoft.Extensions.Logging;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
@@ -31,21 +30,24 @@ public async Task DockerService_CanPingDockerAsync()
         canPingDocker.Should().BeTrue();
     }
 
-    [SkipTestOnWindows]
+    [TestMethod]
+    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]
     public async Task DockerService_CanRunLinuxContainersAsync()
     {
         var isLinuxContainerModeEnabled = await this.dockerService.CanRunLinuxContainersAsync();
         isLinuxContainerModeEnabled.Should().BeTrue();
     }
 
-    [SkipTestOnWindows]
+    [TestMethod]
+    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]
     public async Task DockerService_CanPullImageAsync()
     {
         Func<Task> action = async () => await this.dockerService.TryPullImageAsync(TestImage);
         await action.Should().NotThrowAsync();
     }
 
-    [SkipTestOnWindows]
+    [TestMethod]
+    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]
     public async Task DockerService_CanInspectImageAsync()
     {
         await this.dockerService.TryPullImageAsync(TestImage);
@@ -54,7 +56,8 @@ public async Task DockerService_CanInspectImageAsync()
         details.Tags.Should().Contain("governancecontainerregistry.azurecr.io/testcontainers/hello-world:latest");
     }
 
-    [SkipTestOnWindows]
+    [TestMethod]
+    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]
     public async Task DockerService_PopulatesBaseImageAndLayerDetailsAsync()
     {
         await this.dockerService.TryPullImageAsync(TestImageWithBaseDetails);
@@ -74,7 +77,8 @@ public async Task DockerService_PopulatesBaseImageAndLayerDetailsAsync()
         details.Layers.Should().ContainSingle();
     }
 
-    [SkipTestOnWindows]
+    [TestMethod]
+    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]
     public async Task DockerService_CanCreateAndRunImageAsync()
     {
         var (stdout, stderr) = await this.dockerService.CreateAndRunContainerAsync(TestImage, []);
diff --git a/test/Microsoft.ComponentDetection.Common.Tests/SafeFileEnumerableTests.cs b/test/Microsoft.ComponentDetection.Common.Tests/SafeFileEnumerableTests.cs
@@ -6,7 +6,6 @@ namespace Microsoft.ComponentDetection.Common.Tests;
 using System.IO;
 using AwesomeAssertions;
 using Microsoft.ComponentDetection.Contracts;
-using Microsoft.ComponentDetection.TestsUtilities;
 using Microsoft.Extensions.Logging;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
@@ -93,7 +92,7 @@ public void GetEnumerator_IgnoresSubDirectories()
     }
 
     [TestMethod]
-    [SkipTestOnWindows]
+    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]
     public void GetEnumerator_CallsSymlinkCode()
     {
         var subDir = Directory.CreateSymbolicLink(Path.Combine(this.temporaryDirectory, "SubDir"), this.temporaryDirectory);
@@ -115,7 +114,7 @@ public void GetEnumerator_CallsSymlinkCode()
     }
 
     [TestMethod]
-    [SkipTestOnWindows]
+    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]
     public void GetEnumerator_DuplicatePathIgnored()
     {
         var subDir = Directory.CreateDirectory(Path.Combine(this.temporaryDirectory, "SubDir"));
diff --git a/test/Microsoft.ComponentDetection.Detectors.Tests/GoComponentTests.cs b/test/Microsoft.ComponentDetection.Detectors.Tests/GoComponentTests.cs
@@ -31,19 +31,17 @@ public void ConstructorTest_NameVersion()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]
     public void ConstructorTest_NameVersion_NullVersion()
     {
-        var goComponent = new GoComponent(TestName, null);
+        var action = () => new GoComponent(TestName, null);
+        action.Should().ThrowExactly<ArgumentNullException>();
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]
     public void ConstructorTest_NameVersion_NullName()
     {
-        var goComponent = new GoComponent(null, TestVersion);
+        var action = () => new GoComponent(null, TestVersion);
+        action.Should().ThrowExactly<ArgumentNullException>();
     }
 
     [TestMethod]
@@ -57,27 +55,24 @@ public void ConstructorTest_NameVersionHash()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]
     public void ConstructorTest_NameVersionHash_NullVersion()
     {
-        var goComponent = new GoComponent(TestName, null, TestHash);
+        var action = () => new GoComponent(TestName, null, TestHash);
+        action.Should().ThrowExactly<ArgumentNullException>();
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]
     public void ConstructorTest_NameVersionHash_NullName()
     {
-        var goComponent = new GoComponent(null, TestVersion, TestHash);
+        var action = () => new GoComponent(null, TestVersion, TestHash);
+        action.Should().ThrowExactly<ArgumentNullException>();
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentNullException))]
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]
     public void ConstructorTest_NameVersionHash_NullHash()
     {
-        var goComponent = new GoComponent(TestName, TestVersion, null);
+        var action = () => new GoComponent(TestName, TestVersion, null);
+        action.Should().ThrowExactly<ArgumentNullException>();
     }
 
     [TestMethod]
diff --git a/test/Microsoft.ComponentDetection.TestsUtilities/Attributes/SkipTestIfNotWindowsAttribute.cs b/test/Microsoft.ComponentDetection.TestsUtilities/Attributes/SkipTestIfNotWindowsAttribute.cs
diff --git a/test/Microsoft.ComponentDetection.TestsUtilities/Attributes/SkipTestOnWindowsAttribute.cs b/test/Microsoft.ComponentDetection.TestsUtilities/Attributes/SkipTestOnWindowsAttribute.cs

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ namespace Microsoft.ComponentDetection.Common.Tests;`
`6`	`6`	`using System.Text;`
`7`	`7`	`using System.Threading.Tasks;`
`8`	`8`	`using AwesomeAssertions;`
`9`		`-using Microsoft.ComponentDetection.TestsUtilities;`
`10`	`9`	`using Microsoft.VisualStudio.TestTools.UnitTesting;`
`11`	`10`
`12`	`11`	`[TestClass]`
`@@ -22,28 +21,32 @@ public void TestInitialize()`
`22`	`21`	`this.commandLineService = new CommandLineInvocationService();`
`23`	`22`	`}`
`24`	`23`
`25`		`- [SkipTestIfNotWindows]`
	`24`	`+ [TestMethod]`
	`25`	`+ [OSCondition(OperatingSystems.Windows)]`
`26`	`26`	`public async Task ShowsCmdExeAsExecutableAsync()`
`27`	`27`	`{`
`28`	`28`	`var result = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");`
`29`	`29`	`result.Should().BeTrue();`
`30`	`30`	`}`
`31`	`31`
`32`		`- [SkipTestIfNotWindows]`
	`32`	`+ [TestMethod]`
	`33`	`+ [OSCondition(OperatingSystems.Windows)]`
`33`	`34`	`public async Task FallbackWorksIfBadCommandsAreFirstAsync()`
`34`	`35`	`{`
`35`	`36`	`var result = await this.commandLineService.CanCommandBeLocatedAsync("57AB44A4-885A-47F4-866C-41417133B983", ["fakecommandexecutable.exe", "cmd.exe"], "/C");`
`36`	`37`	`result.Should().BeTrue();`
`37`	`38`	`}`
`38`	`39`
`39`		`- [SkipTestIfNotWindows]`
	`40`	`+ [TestMethod]`
	`41`	`+ [OSCondition(OperatingSystems.Windows)]`
`40`	`42`	`public async Task ReturnsFalseIfNoValidCommandIsFoundAsync()`
`41`	`43`	`{`
`42`	`44`	`var result = await this.commandLineService.CanCommandBeLocatedAsync("57AB44A4-885A-47F4-866C-41417133B983", ["fakecommandexecutable.exe"], "/C");`
`43`	`45`	`result.Should().BeFalse();`
`44`	`46`	`}`
`45`	`47`
`46`		`- [SkipTestIfNotWindows]`
	`48`	`+ [TestMethod]`
	`49`	`+ [OSCondition(OperatingSystems.Windows)]`
`47`	`50`	`public async Task ReturnsStandardOutputAsync()`
`48`	`51`	`{`
`49`	`52`	`var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");`
`@@ -54,7 +57,8 @@ public async Task ReturnsStandardOutputAsync()`
`54`	`57`	`taskResult.StdOut.Replace(Environment.NewLine, string.Empty).Should().Be("Expected Output");`
`55`	`58`	`}`
`56`	`59`
`57`		`- [SkipTestIfNotWindows]`
	`60`	`+ [TestMethod]`
	`61`	`+ [OSCondition(OperatingSystems.Windows)]`
`58`	`62`	`public async Task ExecutesCommandEvenWithLargeStdOutAsync()`
`59`	`63`	`{`
`60`	`64`	`var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");`
`@@ -76,7 +80,8 @@ public async Task ExecutesCommandEvenWithLargeStdOutAsync()`
`76`	`80`	`taskResult.StdOut.Length < 100 ? $"Stdout was '{taskResult.StdOut}', which is shorter than 8100 chars" : $"Length was {taskResult.StdOut.Length}, which is less than 8100");`
`77`	`81`	`}`
`78`	`82`
`79`		`- [SkipTestIfNotWindows]`
	`83`	`+ [TestMethod]`
	`84`	`+ [OSCondition(OperatingSystems.Windows)]`
`80`	`85`	`public async Task ExecutesCommandCapturingErrorOutputAsync()`
`81`	`86`	`{`
`82`	`87`	`var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");`
`@@ -95,7 +100,8 @@ public async Task ExecutesCommandCapturingErrorOutputAsync()`
`95`	`100`	`taskResult.StdOut.Should().BeEmpty();`
`96`	`101`	`}`
`97`	`102`
`98`		`- [SkipTestIfNotWindows]`
	`103`	`+ [TestMethod]`
	`104`	`+ [OSCondition(OperatingSystems.Windows)]`
`99`	`105`	`public async Task ExecutesInAWorkingDirectoryAsync()`
`100`	`106`	`{`
`101`	`107`	`var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");`
`@@ -108,7 +114,8 @@ public async Task ExecutesInAWorkingDirectoryAsync()`
`108`	`114`	`taskResult.StdOut.Should().Contain(tempDirectoryPath);`
`109`	`115`	`}`
`110`	`116`
`111`		`- [SkipTestIfNotWindows]`
	`117`	`+ [TestMethod]`
	`118`	`+ [OSCondition(OperatingSystems.Windows)]`
`112`	`119`	`public async Task ThrowsIfWorkingDirectoryDoesNotExistAsync()`
`113`	`120`	`{`
`114`	`121`	`var isLocated = await this.commandLineService.CanCommandBeLocatedAsync("cmd.exe", default, "/C");`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@ namespace Microsoft.ComponentDetection.Common.Tests;`
`5`	`5`	`using System.Threading.Tasks;`
`6`	`6`	`using AwesomeAssertions;`
`7`	`7`	`using Docker.DotNet.Models;`
`8`		`-using Microsoft.ComponentDetection.TestsUtilities;`
`9`	`8`	`using Microsoft.Extensions.Logging;`
`10`	`9`	`using Microsoft.VisualStudio.TestTools.UnitTesting;`
`11`	`10`	`using Moq;`
`@@ -31,21 +30,24 @@ public async Task DockerService_CanPingDockerAsync()`
`31`	`30`	`canPingDocker.Should().BeTrue();`
`32`	`31`	`}`
`33`	`32`
`34`		`- [SkipTestOnWindows]`
	`33`	`+ [TestMethod]`
	`34`	`+ [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]`
`35`	`35`	`public async Task DockerService_CanRunLinuxContainersAsync()`
`36`	`36`	`{`
`37`	`37`	`var isLinuxContainerModeEnabled = await this.dockerService.CanRunLinuxContainersAsync();`
`38`	`38`	`isLinuxContainerModeEnabled.Should().BeTrue();`
`39`	`39`	`}`
`40`	`40`
`41`		`- [SkipTestOnWindows]`
	`41`	`+ [TestMethod]`
	`42`	`+ [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]`
`42`	`43`	`public async Task DockerService_CanPullImageAsync()`
`43`	`44`	`{`
`44`	`45`	`Func<Task> action = async () => await this.dockerService.TryPullImageAsync(TestImage);`
`45`	`46`	`await action.Should().NotThrowAsync();`
`46`	`47`	`}`
`47`	`48`
`48`		`- [SkipTestOnWindows]`
	`49`	`+ [TestMethod]`
	`50`	`+ [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]`
`49`	`51`	`public async Task DockerService_CanInspectImageAsync()`
`50`	`52`	`{`
`51`	`53`	`await this.dockerService.TryPullImageAsync(TestImage);`
`@@ -54,7 +56,8 @@ public async Task DockerService_CanInspectImageAsync()`
`54`	`56`	`details.Tags.Should().Contain("governancecontainerregistry.azurecr.io/testcontainers/hello-world:latest");`
`55`	`57`	`}`
`56`	`58`
`57`		`- [SkipTestOnWindows]`
	`59`	`+ [TestMethod]`
	`60`	`+ [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]`
`58`	`61`	`public async Task DockerService_PopulatesBaseImageAndLayerDetailsAsync()`
`59`	`62`	`{`
`60`	`63`	`await this.dockerService.TryPullImageAsync(TestImageWithBaseDetails);`
`@@ -74,7 +77,8 @@ public async Task DockerService_PopulatesBaseImageAndLayerDetailsAsync()`
`74`	`77`	`details.Layers.Should().ContainSingle();`
`75`	`78`	`}`
`76`	`79`
`77`		`- [SkipTestOnWindows]`
	`80`	`+ [TestMethod]`
	`81`	`+ [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]`
`78`	`82`	`public async Task DockerService_CanCreateAndRunImageAsync()`
`79`	`83`	`{`
`80`	`84`	`var (stdout, stderr) = await this.dockerService.CreateAndRunContainerAsync(TestImage, []);`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ namespace Microsoft.ComponentDetection.Common.Tests;`
`6`	`6`	`using System.IO;`
`7`	`7`	`using AwesomeAssertions;`
`8`	`8`	`using Microsoft.ComponentDetection.Contracts;`
`9`		`-using Microsoft.ComponentDetection.TestsUtilities;`
`10`	`9`	`using Microsoft.Extensions.Logging;`
`11`	`10`	`using Microsoft.VisualStudio.TestTools.UnitTesting;`
`12`	`11`	`using Moq;`
`@@ -93,7 +92,7 @@ public void GetEnumerator_IgnoresSubDirectories()`
`93`	`92`	`}`
`94`	`93`
`95`	`94`	`[TestMethod]`
`96`		`- [SkipTestOnWindows]`
	`95`	`+ [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]`
`97`	`96`	`public void GetEnumerator_CallsSymlinkCode()`
`98`	`97`	`{`
`99`	`98`	`var subDir = Directory.CreateSymbolicLink(Path.Combine(this.temporaryDirectory, "SubDir"), this.temporaryDirectory);`
`@@ -115,7 +114,7 @@ public void GetEnumerator_CallsSymlinkCode()`
`115`	`114`	`}`
`116`	`115`
`117`	`116`	`[TestMethod]`
`118`		`- [SkipTestOnWindows]`
	`117`	`+ [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)]`
`119`	`118`	`public void GetEnumerator_DuplicatePathIgnored()`
`120`	`119`	`{`
`121`	`120`	`var subDir = Directory.CreateDirectory(Path.Combine(this.temporaryDirectory, "SubDir"));`
Original file line number	Diff line number	Diff line change
`@@ -31,19 +31,17 @@ public void ConstructorTest_NameVersion()`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`[TestMethod]`
`34`		`- [ExpectedException(typeof(ArgumentNullException))]`
`35`		`- [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]`
`36`	`34`	`public void ConstructorTest_NameVersion_NullVersion()`
`37`	`35`	`{`
`38`		`- var goComponent = new GoComponent(TestName, null);`
	`36`	`+ var action = () => new GoComponent(TestName, null);`
	`37`	`+ action.Should().ThrowExactly<ArgumentNullException>();`
`39`	`38`	`}`
`40`	`39`
`41`	`40`	`[TestMethod]`
`42`		`- [ExpectedException(typeof(ArgumentNullException))]`
`43`		`- [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]`
`44`	`41`	`public void ConstructorTest_NameVersion_NullName()`
`45`	`42`	`{`
`46`		`- var goComponent = new GoComponent(null, TestVersion);`
	`43`	`+ var action = () => new GoComponent(null, TestVersion);`
	`44`	`+ action.Should().ThrowExactly<ArgumentNullException>();`
`47`	`45`	`}`
`48`	`46`
`49`	`47`	`[TestMethod]`
`@@ -57,27 +55,24 @@ public void ConstructorTest_NameVersionHash()`
`57`	`55`	`}`
`58`	`56`
`59`	`57`	`[TestMethod]`
`60`		`- [ExpectedException(typeof(ArgumentNullException))]`
`61`		`- [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]`
`62`	`58`	`public void ConstructorTest_NameVersionHash_NullVersion()`
`63`	`59`	`{`
`64`		`- var goComponent = new GoComponent(TestName, null, TestHash);`
	`60`	`+ var action = () => new GoComponent(TestName, null, TestHash);`
	`61`	`+ action.Should().ThrowExactly<ArgumentNullException>();`
`65`	`62`	`}`
`66`	`63`
`67`	`64`	`[TestMethod]`
`68`		`- [ExpectedException(typeof(ArgumentNullException))]`
`69`		`- [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]`
`70`	`65`	`public void ConstructorTest_NameVersionHash_NullName()`
`71`	`66`	`{`
`72`		`- var goComponent = new GoComponent(null, TestVersion, TestHash);`
	`67`	`+ var action = () => new GoComponent(null, TestVersion, TestHash);`
	`68`	`+ action.Should().ThrowExactly<ArgumentNullException>();`
`73`	`69`	`}`
`74`	`70`
`75`	`71`	`[TestMethod]`
`76`		`- [ExpectedException(typeof(ArgumentNullException))]`
`77`		`- [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MSTEST0006:Avoid '[ExpectedException]'", Justification = "Single-line test case")]`
`78`	`72`	`public void ConstructorTest_NameVersionHash_NullHash()`
`79`	`73`	`{`
`80`		`- var goComponent = new GoComponent(TestName, TestVersion, null);`
	`74`	`+ var action = () => new GoComponent(TestName, TestVersion, null);`
	`75`	`+ action.Should().ThrowExactly<ArgumentNullException>();`
`81`	`76`	`}`
`82`	`77`
`83`	`78`	`[TestMethod]`