Assignment9+10 multithreading

Assignment/Assignment.Tests/Assignment.Tests.csproj → Assignment.Tests/Assignment.Tests.csproj

@@ -1,19 +1,20 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
-    <PackageReference Include="MSTest.TestAdapter" Version="4.0.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="4.0.2" />
-    <PackageReference Include="coverlet.collector" Version="6.0.4">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <ProjectReference Include="..\Assignment\Assignment.csproj" />
-	  <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
-  </ItemGroup>
-
-</Project>
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+	  <ParallelizeTestCollections>false</ParallelizeTestCollections>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageReference Include="MSTest.TestAdapter" Version="4.0.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="4.0.2" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <ProjectReference Include="..\Assignment\Assignment.csproj" />
+	  <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+  </ItemGroup>
+
+</Project>

Assignment.Tests/FakePingProcess.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+
+namespace Assignment.Tests;
+
+internal sealed class FakePingProcess : PingProcess
+{
+    readonly string _pingOutputTemplate = @"
+Pinging * with 32 bytes of data:
+Reply from ::1: time<1ms
+Reply from ::1: time<1ms
+Reply from ::1: time<1ms
+Reply from ::1: time<1ms
+
+Ping statistics for ::1:
+    Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
+Approximate round trip times in milli-seconds:
+    Minimum = 0ms, Maximum = 0ms, Average = 0ms".Trim();
+
+    protected override int RunProcessInternal(
+        ProcessStartInfo startInfo,
+        Action<string?>? progressOutput,
+        Action<string?>? progressError,
+        CancellationToken token)
+    {
+        Task.Delay(500, token).Wait(token);
+
+        string host = startInfo.Arguments;
+
+        if (host == "badaddress")
+        {
+            string msg =
+                "Ping request could not find host badaddress. Please check the name and try again.";
+
+            progressOutput?.Invoke(msg);
+            progressOutput?.Invoke(null);
+            progressError?.Invoke(null);
+
+            return 1;
+        }
+
+        foreach (string line in GetLinesForHost(host))
+        {
+            progressOutput?.Invoke(line);
+        }
+
+        progressOutput?.Invoke(null);
+        progressError?.Invoke(null);
+
+        return 0;
+    }
+
+    private string[] GetLinesForHost(string host)
+    {
+        string[] lines = _pingOutputTemplate.Split(
+            Environment.NewLine, StringSplitOptions.None);
+
+        if (lines.Length > 0)
+        {
+            string first = lines[0];
+            if (first.Contains('*'))
+            {
+                lines[0] = first.Replace("*", host);
+            }
+        }
+
+        return lines;
+    }
+}

Assignment.Tests/PingProcessTests.cs

@@ -0,0 +1,238 @@
+using IntelliTect.TestTools;
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Assignment.Tests;
+
+[TestClass]
+[DoNotParallelize]
+public class PingProcessTests
+{
+    private FakePingProcess Sut { get; set; } = new();
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        Sut = new FakePingProcess();
+    }
+
+    [TestMethod]
+    public void Start_PingProcess_Success()
+    {
+        var psi = OperatingSystem.IsWindows()
+            ? new ProcessStartInfo("ping", "127.0.0.1 -n 1")
+            : new ProcessStartInfo("ping", "127.0.0.1 -c 1");
+
+        using Process process = Process.Start(psi)!;
+        process.WaitForExit();
+        Assert.AreEqual(0, process.ExitCode);
+    }
+
+    [TestMethod]
+    public void Run_InvalidAddressOutput_Success()
+    {
+        var result = Sut.Run("badaddress");
+
+        Assert.IsFalse(string.IsNullOrWhiteSpace(result.StdOutput));
+
+        string normalized = result.StdOutput!.Trim().ToLowerInvariant();
+
+        // Accept common OS ping error messages
+        bool matches = normalized.Contains("temporary failure")
+                       || normalized.Contains("name or service not known")
+                       || normalized.Contains("could not find host");
+
+        Assert.IsTrue(matches, $"Unexpected output: {result.StdOutput}");
+        Assert.AreNotEqual(0, result.ExitCode);
+    }
+
+    [TestMethod]
+    public void Run_CaptureStdOutput_Success()
+    {
+        var result = Sut.Run("localhost");
+        ValidatePingSuccess(result);
+    }
+
+    [TestMethod]
+    public void RunTaskAsync_Success()
+    {
+        var result = Sut.RunTaskAsync("localhost").Result;
+        ValidatePingSuccess(result);
+    }
+
+    [TestMethod]
+    public void RunAsync_UsingTaskReturn_Success()
+    {
+        var result = Sut.RunAsync("localhost").Result;
+        ValidatePingSuccess(result);
+    }
+
+    [TestMethod]
+    public async Task RunAsync_MultipleHostAddresses_True()
+    {
+        string[] hosts = { "localhost", "127.0.0.1" };
+        var result = await Sut.RunAsync(hosts);
+        ValidatePingSuccess(result);
+    }
+
+    [TestMethod]
+    async public Task RunAsync_UsingTpl_Success()
+    {
+        var result = await Sut.RunAsync("localhost");
+        ValidatePingSuccess(result);
+    }
+
+    [TestMethod]
+    public void RunAsync_UsingTplWithCancellation_CatchAggregateExceptionWrapping()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        var task = Sut.RunAsync("localhost", cts.Token);
+        try
+        {
+            task.Wait();
+            Assert.Fail("Expected AggregateException was not thrown.");
+        }
+        catch (AggregateException ex)
+        {
+            Assert.IsInstanceOfType<AggregateException>(ex);
+        }
+    }
+
+    [TestMethod]
+    public void RunAsync_UsingTplWithCancellation_CatchAggregateExceptionWrappingTaskCanceledException()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        var task = Sut.RunAsync("localhost", cts.Token);
+        try
+        {
+            task.Wait();
+            Assert.Fail("Expected AggregateException was not thrown.");
+        }
+        catch (AggregateException ex)
+        {
+            Assert.IsInstanceOfType<TaskCanceledException>(ex.InnerException);
+        }
+    }
+
+    [TestMethod]
+    public void StringBuilderAppendLine_InParallel_DemonstratesNonThreadSafeBehavior()
+    {
+        var numbers = Enumerable.Range(0, 1000);
+        var stringBuilder = new StringBuilder();
+        Exception? capturedException = null;
+
+        try
+        {
+            numbers.AsParallel().ForAll(i => stringBuilder.AppendLine("X"));
+        }
+        catch (Exception ex)
+        {
+            capturedException = ex;
+        }
+
+        int expectedLength = numbers.Count() * ("X" + Environment.NewLine).Length;
+        Assert.IsTrue(
+            capturedException != null || stringBuilder.Length != expectedLength,
+            "StringBuilder is not thread-safe: either an exception occurs or the content is corrupted."
+        );
+    }
+
+    [TestMethod]
+    public async Task RunLongRunningAsync_ValidPing_ReturnsZero()
+    {
+        var psi = OperatingSystem.IsWindows()
+            ? new ProcessStartInfo("ping", "127.0.0.1 -n 1")
+            : new ProcessStartInfo("ping", "127.0.0.1 -c 1");
+
+        int result = await Sut.RunLongRunningAsync(
+            psi,
+            progressOutput: _ => { },
+            progressError: _ => { },
+            token: CancellationToken.None);
+
+        Assert.AreEqual(0, result);
+    }
+
+    [TestMethod]
+    public async Task RunLongRunningAsync_OutputProduced_ProgressOutputInvoked()
+    {
+        int count = 0;
+        void output(string? line) { if (line != null) count++; }
+
+        var psi = OperatingSystem.IsWindows()
+            ? new ProcessStartInfo("ping", "127.0.0.1 -n 1")
+            : new ProcessStartInfo("ping", "127.0.0.1 -c 1");
+
+        await Sut.RunLongRunningAsync(
+            psi,
+            progressOutput: output,
+            progressError: _ => { },
+            token: CancellationToken.None);
+
+        Assert.IsGreaterThan(0, count, "Expected progressOutput to be invoked at least once.");
+    }
+
+    [TestMethod]
+    public void RunLongRunningAsync_Cancelled_ThrowsAggregateException()
+    {
+        var psi = OperatingSystem.IsWindows()
+            ? new ProcessStartInfo("ping", "127.0.0.1 -n 1")
+            : new ProcessStartInfo("ping", "127.0.0.1 -c 1");
+
+        using var cts = new CancellationTokenSource();
+
+        var task = Sut.RunLongRunningAsync(
+            psi,
+            progressOutput: _ => { },
+            progressError: _ => { },
+            token: cts.Token);
+
+        cts.Cancel();
+
+        try
+        {
+            task.Wait();
+            Assert.Fail("Expected AggregateException was not thrown.");
+        }
+        catch (AggregateException ex)
+        {
+            Assert.IsInstanceOfType<TaskCanceledException>(ex.InnerException);
+        }
+    }
+
+    [TestMethod]
+    public async Task RunAsync_WithProgress_CapturesOutputAsItOccurs()
+    {
+        StringBuilder outputBuilder = new();
+        void ProgressHandler(string? line)
+        {
+            if (line != null)
+            {
+                outputBuilder.AppendLine(line);
+            }
+        }
+
+        var result = await Sut.RunAsync("localhost", new Progress<string?>(ProgressHandler), CancellationToken.None);
+        ValidatePingSuccess(result);
+    }
+
+    // --- Helper for validating ping success across OSes ---
+    private static void ValidatePingSuccess(PingResult result)
+    {
+        Assert.IsNotNull(result.StdOutput);
+        Assert.IsGreaterThan(0, result.StdOutput!.Length, "Output should not be empty.");
+        Assert.AreEqual(0, result.ExitCode);
+
+        string[] successMarkers = { "Reply from", "bytes from" };
+        bool containsMarker = successMarkers.Any(marker =>
+            result.StdOutput.Contains(marker, StringComparison.OrdinalIgnoreCase));
+
+        Assert.IsTrue(containsMarker, $"Output did not contain expected markers. Actual output:\n{result.StdOutput}");
+    }
+}