diff --git a/Taskfile.yml b/Taskfile.yml
index 7c24f8c..0466cdf 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -34,24 +34,28 @@ tasks:
       - restore
 
   test:
-    desc: Test the application and produce a coverage report.
-    cmds:
-      - >-
-        dotnet test
-        --configuration {{.CONFIGURATION}}
-        --logger xunit
-        --verbosity normal
-        --no-build
-        --collect:"XPlat Code Coverage"
-      - >-
-        dotnet reportgenerator
-        -reports:src/**/coverage.cobertura.xml
-        -targetdir:.coverage
-        "-reporttypes:Cobertura;lcov;Html"
-        -filefilters:-*.g.cs
+    desc: Run the unit tests.
+    cmd: >-
+      dotnet test
+      --configuration {{.CONFIGURATION}}
+      --logger xunit
+      --verbosity normal
+      --no-build
+      --collect:"XPlat Code Coverage"
     deps:
       - build
 
+  cover:
+    desc: Produce a coverage report for unit tests.
+    cmd: >-
+      dotnet reportgenerator
+      -reports:src/**/coverage.cobertura.xml
+      -targetdir:.coverage
+      "-reporttypes:Cobertura;lcov;Html"
+      -filefilters:-*.g.cs
+    deps:
+      - test
+
   publish:
     desc: Publish the application ready for distribution.
     cmd: >-
diff --git a/src/TotalMixVC.Tests/ConfigConverters/IPAddressConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/IPAddressConverterTests.cs
index 775c843..a809d1a 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/IPAddressConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/IPAddressConverterTests.cs
@@ -14,13 +14,8 @@ public class IPAddressConverterTests
     [InlineData("192.168.0.1")]
     public void Read_Valid_ConvertsWithoutError(string address)
     {
-        // Arrange
         var json = $$"""{"Address": "{{address}}"}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(address, model?.Address.ToString());
     }
 
@@ -31,26 +26,15 @@ public void Read_Valid_ConvertsWithoutError(string address)
     [InlineData("osc.example.com")]
     public void Read_Invalid_ThrowsException(string address)
     {
-        // Arrange
         var json = $$"""{"Address": "{{address}}"}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Fact]
     public void Write_Valid_ConvertsWithoutError()
     {
-        // Arrange
         var model = new Model() { Address = IPAddress.Loopback };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
-
-        // Assert
         /*lang=json,strict*/
         Assert.Equal("""{"Address":"127.0.0.1"}""", json);
     }
diff --git a/src/TotalMixVC.Tests/ConfigConverters/NonNegativeDoubleConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/NonNegativeDoubleConverterTests.cs
index 333d810..cc875b8 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/NonNegativeDoubleConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/NonNegativeDoubleConverterTests.cs
@@ -14,13 +14,8 @@ public class NonNegativeDoubleConverterTests
     [InlineData(10.0)]
     public void Read_Valid_ConvertsWithoutError(double value)
     {
-        // Arrange
         var json = $$"""{"Value": {{value}}}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(value, model?.Value);
     }
 
@@ -31,14 +26,8 @@ public void Read_Valid_ConvertsWithoutError(double value)
     [InlineData(-10.5)]
     public void Read_Invalid_ThrowsException(double value)
     {
-        // Arrange
         var json = $$"""{"Value": {{value}}}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Theory]
@@ -48,13 +37,8 @@ public void Read_Invalid_ThrowsException(double value)
     [InlineData(10.0)]
     public void Write_Valid_ConvertsWithoutError(double value)
     {
-        // Arrange
         var model = new Model() { Value = value };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
-
-        // Assert
         Assert.Equal($$"""{"Value":{{value}}}""", json);
     }
 
@@ -65,14 +49,8 @@ public void Write_Valid_ConvertsWithoutError(double value)
     [InlineData(-10.5)]
     public void Write_Invalid_ThrowsException(double value)
     {
-        // Arrange
         var model = new Model() { Value = value };
-
-        // Act
-        Action action = () => JsonSerializer.Serialize(model);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(model));
     }
 
     internal sealed record Model
diff --git a/src/TotalMixVC.Tests/ConfigConverters/PortIntegerConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/PortIntegerConverterTests.cs
index dea9000..9be1628 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/PortIntegerConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/PortIntegerConverterTests.cs
@@ -15,13 +15,8 @@ public class PortIntegerConverterTests
     [InlineData(7000)]
     public void Read_Valid_ConvertsWithoutError(int port)
     {
-        // Arrange
         var json = $$"""{"Port": {{port}}}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(port, model?.Port);
     }
 
@@ -32,14 +27,8 @@ public void Read_Valid_ConvertsWithoutError(int port)
     [InlineData(-50)]
     public void Read_Invalid_ThrowsException(int port)
     {
-        // Arrange
         var json = $$"""{"Port": {{port}}}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Theory]
@@ -49,13 +38,8 @@ public void Read_Invalid_ThrowsException(int port)
     [InlineData(7000)]
     public void Write_Valid_ConvertsWithoutError(int port)
     {
-        // Arrange
         var model = new Model() { Port = port };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
-
-        // Assert
         Assert.Equal($$"""{"Port":{{port}}}""", json);
     }
 
@@ -66,14 +50,8 @@ public void Write_Valid_ConvertsWithoutError(int port)
     [InlineData(-50)]
     public void Write_Invalid_ThrowsException(int port)
     {
-        // Arrange
         var model = new Model() { Port = port };
-
-        // Act
-        Action action = () => JsonSerializer.Serialize(model);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(model));
     }
 
     internal sealed record Model
diff --git a/src/TotalMixVC.Tests/ConfigConverters/PositiveDoubleConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/PositiveDoubleConverterTests.cs
index 2c1a0e2..32bd2f7 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/PositiveDoubleConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/PositiveDoubleConverterTests.cs
@@ -14,13 +14,8 @@ public class PositiveDoubleConverterTests
     [InlineData(10.0)]
     public void Read_Valid_ConvertsWithoutError(double value)
     {
-        // Arrange
         var json = $$"""{"Value": {{value}}}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(value, model?.Value);
     }
 
@@ -31,14 +26,8 @@ public void Read_Valid_ConvertsWithoutError(double value)
     [InlineData(-10.5)]
     public void Read_Invalid_ThrowsException(double value)
     {
-        // Arrange
         var json = $$"""{"Value": {{value}}}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Theory]
@@ -48,13 +37,8 @@ public void Read_Invalid_ThrowsException(double value)
     [InlineData(10.0)]
     public void Write_Valid_ConvertsWithoutError(double value)
     {
-        // Arrange
         var model = new Model() { Value = value };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
-
-        // Assert
         Assert.Equal($$"""{"Value":{{value}}}""", json);
     }
 
@@ -65,14 +49,8 @@ public void Write_Valid_ConvertsWithoutError(double value)
     [InlineData(-10.5)]
     public void Write_Invalid_ThrowsException(double value)
     {
-        // Arrange
         var model = new Model() { Value = value };
-
-        // Act
-        Action action = () => JsonSerializer.Serialize(model);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(model));
     }
 
     internal sealed record Model
diff --git a/src/TotalMixVC.Tests/ConfigConverters/SolidColorBrushConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/SolidColorBrushConverterTests.cs
index bd32f9b..50a10c5 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/SolidColorBrushConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/SolidColorBrushConverterTests.cs
@@ -17,13 +17,8 @@ public class SolidColorBrushConverterTests
     [InlineData("BLUE", "#FF0000FF")]
     public void Read_Valid_ConvertsWithoutError(string color, string expected)
     {
-        // Arrange
         var json = $$"""{"Color": "{{color}}"}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(expected, model?.Color.ToString(CultureInfo.InvariantCulture));
     }
 
@@ -33,14 +28,8 @@ public void Read_Valid_ConvertsWithoutError(string color, string expected)
     [InlineData("#yyxxzz")]
     public void Read_Invalid_ThrowsException(string color)
     {
-        // Arrange
         var json = $$"""{"Color": "{{color}}"}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Theory]
@@ -49,14 +38,10 @@ public void Read_Invalid_ThrowsException(string color)
     [InlineData("#fff", "#ffffff")]
     public void Write_Valid_ConvertsWithoutError(string color, string expected)
     {
-        // Arrange
         var converter = new BrushConverter();
         var model = new Model() { Color = (SolidColorBrush)converter.ConvertFromString(color)! };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
 
-        // Assert
         Assert.Equal($$"""{"Color":"{{expected}}"}""", json);
     }
 
diff --git a/src/TotalMixVC.Tests/ConfigConverters/VolumeFineIncrementFloatConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/VolumeFineIncrementFloatConverterTests.cs
index fa792f0..1caae04 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/VolumeFineIncrementFloatConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/VolumeFineIncrementFloatConverterTests.cs
@@ -13,13 +13,8 @@ public class VolumeFineIncrementFloatConverterTests
     [InlineData(0.05)]
     public void Read_Valid_ConvertsWithoutError(float volumeFineIncrement)
     {
-        // Arrange
         var json = $$"""{"VolumeFineIncrement": {{volumeFineIncrement}}}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(volumeFineIncrement, model?.VolumeFineIncrement);
     }
 
@@ -30,14 +25,8 @@ public void Read_Valid_ConvertsWithoutError(float volumeFineIncrement)
     [InlineData(-1.0)]
     public void Read_Invalid_ThrowsException(float volumeFineIncrement)
     {
-        // Arrange
         var json = $$"""{"VolumeFineIncrement": {{volumeFineIncrement}}}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Theory]
@@ -46,13 +35,8 @@ public void Read_Invalid_ThrowsException(float volumeFineIncrement)
     [InlineData(0.05)]
     public void Write_Valid_ConvertsWithoutError(float volumeFineIncrement)
     {
-        // Arrange
         var model = new Model() { VolumeFineIncrement = volumeFineIncrement };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
-
-        // Assert
         Assert.Equal($$"""{"VolumeFineIncrement":{{volumeFineIncrement}}}""", json);
     }
 
@@ -63,14 +47,8 @@ public void Write_Valid_ConvertsWithoutError(float volumeFineIncrement)
     [InlineData(-1.0)]
     public void Write_Invalid_ThrowsException(float volumeFineIncrement)
     {
-        // Arrange
         var model = new Model() { VolumeFineIncrement = volumeFineIncrement };
-
-        // Act
-        Action action = () => JsonSerializer.Serialize(model);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(model));
     }
 
     internal sealed record Model
diff --git a/src/TotalMixVC.Tests/ConfigConverters/VolumeIncrementFloatConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/VolumeIncrementFloatConverterTests.cs
index ee96c27..c865e23 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/VolumeIncrementFloatConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/VolumeIncrementFloatConverterTests.cs
@@ -14,13 +14,8 @@ public class VolumeIncrementFloatConverterTests
     [InlineData(0.10)]
     public void Read_Valid_ConvertsWithoutError(float volumeIncrement)
     {
-        // Arrange
         var json = $$"""{"VolumeIncrement": {{volumeIncrement}}}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(volumeIncrement, model?.VolumeIncrement);
     }
 
@@ -31,14 +26,8 @@ public void Read_Valid_ConvertsWithoutError(float volumeIncrement)
     [InlineData(-1.0)]
     public void Read_Invalid_ThrowsException(float volumeIncrement)
     {
-        // Arrange
         var json = $$"""{"VolumeIncrement": {{volumeIncrement}}}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Theory]
@@ -48,13 +37,8 @@ public void Read_Invalid_ThrowsException(float volumeIncrement)
     [InlineData(0.10)]
     public void Write_Valid_ConvertsWithoutError(float volumeIncrement)
     {
-        // Arrange
         var model = new Model() { VolumeIncrement = volumeIncrement };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
-
-        // Assert
         Assert.Equal($$"""{"VolumeIncrement":{{volumeIncrement}}}""", json);
     }
 
@@ -65,14 +49,8 @@ public void Write_Valid_ConvertsWithoutError(float volumeIncrement)
     [InlineData(-1.0)]
     public void Write_Invalid_ThrowsException(float volumeIncrement)
     {
-        // Arrange
         var model = new Model() { VolumeIncrement = volumeIncrement };
-
-        // Act
-        Action action = () => JsonSerializer.Serialize(model);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(model));
     }
 
     internal sealed record Model
diff --git a/src/TotalMixVC.Tests/ConfigConverters/VolumeMaxFloatConverterTests.cs b/src/TotalMixVC.Tests/ConfigConverters/VolumeMaxFloatConverterTests.cs
index 20c2abe..aa0669e 100644
--- a/src/TotalMixVC.Tests/ConfigConverters/VolumeMaxFloatConverterTests.cs
+++ b/src/TotalMixVC.Tests/ConfigConverters/VolumeMaxFloatConverterTests.cs
@@ -14,13 +14,8 @@ public class VolumeMaxFloatConverterTests
     [InlineData(1.00)]
     public void Read_Valid_ConvertsWithoutError(float volumeMax)
     {
-        // Arrange
         var json = $$"""{"VolumeMax": {{volumeMax}}}""";
-
-        // Act
         var model = JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
         Assert.Equal(volumeMax, model?.VolumeMax);
     }
 
@@ -31,14 +26,8 @@ public void Read_Valid_ConvertsWithoutError(float volumeMax)
     [InlineData(-10.0)]
     public void Read_Invalid_ThrowsException(float volumeMax)
     {
-        // Arrange
         var json = $$"""{"VolumeMax": {{volumeMax}}}""";
-
-        // Act
-        Action action = () => JsonSerializer.Deserialize<Model>(json);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Model>(json));
     }
 
     [Theory]
@@ -48,13 +37,8 @@ public void Read_Invalid_ThrowsException(float volumeMax)
     [InlineData(1.00)]
     public void Write_Valid_ConvertsWithoutError(float volumeMax)
     {
-        // Arrange
         var model = new Model() { VolumeMax = volumeMax };
-
-        // Act
         var json = JsonSerializer.Serialize(model);
-
-        // Assert
         Assert.Equal($$"""{"VolumeMax":{{volumeMax}}}""", json);
     }
 
@@ -65,14 +49,8 @@ public void Write_Valid_ConvertsWithoutError(float volumeMax)
     [InlineData(-10.0)]
     public void Write_Invalid_ThrowsException(float volumeMax)
     {
-        // Arrange
         var model = new Model() { VolumeMax = volumeMax };
-
-        // Act
-        Action action = () => JsonSerializer.Serialize(model);
-
-        // Assert
-        Assert.Throws<JsonException>(action);
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(model));
     }
 
     internal sealed record Model
diff --git a/src/TotalMixVC.Tests/TaskExtensionsTests.cs b/src/TotalMixVC.Tests/TaskExtensionsTests.cs
index b5215d8..0e0767d 100644
--- a/src/TotalMixVC.Tests/TaskExtensionsTests.cs
+++ b/src/TotalMixVC.Tests/TaskExtensionsTests.cs
@@ -7,7 +7,6 @@ public class TaskExtensionsTests
     [Fact]
     public async Task TimeoutAfter_Completes_DoesNotThrowException_Async()
     {
-        // Arrange
         var completed = false;
         Func<Task> task = async () =>
         {
@@ -15,17 +14,14 @@ public async Task TimeoutAfter_Completes_DoesNotThrowException_Async()
             completed = true;
         };
 
-        // Act
         await Task.Run(task).TimeoutAfter(1000);
 
-        // Assert
         Assert.True(completed);
     }
 
     [Fact]
     public async Task TimeoutAfter_TimesOut_ThrowsException_Async()
     {
-        // Arrange
         var completed = false;
         Func<Task> task = async () =>
         {
@@ -33,10 +29,8 @@ public async Task TimeoutAfter_TimesOut_ThrowsException_Async()
             completed = true;
         };
 
-        // Act
         Func<Task> timeoutTask = () => Task.Run(task).TimeoutAfter(1);
 
-        // Assert
         await Assert.ThrowsAsync<TimeoutException>(timeoutTask);
         Assert.False(completed);
     }
@@ -44,7 +38,6 @@ public async Task TimeoutAfter_TimesOut_ThrowsException_Async()
     [Fact]
     public async Task TimeoutAfter_Cancellation_ThrowsException_Async()
     {
-        // Arrange
         using var cancellationTokenSource = new CancellationTokenSource();
 
         var completed = false;
@@ -54,14 +47,12 @@ public async Task TimeoutAfter_Cancellation_ThrowsException_Async()
             completed = true;
         };
 
-        // Act
         var cancelTask = Task.Run(async () =>
         {
             await Task.Delay(100);
             await cancellationTokenSource.CancelAsync();
         });
 
-        // Assert
         await Assert.ThrowsAsync<OperationCanceledException>(
             async () => await Task.Run(task).TimeoutAfter(1000, cancellationTokenSource)
         );
@@ -72,7 +63,6 @@ await Assert.ThrowsAsync<OperationCanceledException>(
     [Fact]
     public async Task TimeoutAfter_CompletesWithReturn_ReturnsValue_Async()
     {
-        // Arrange
         var completed = false;
         Func<Task<string>> task = async () =>
         {
@@ -81,10 +71,8 @@ public async Task TimeoutAfter_CompletesWithReturn_ReturnsValue_Async()
             return "Hello";
         };
 
-        // Act
         var result = await Task.Run(task).TimeoutAfter(1000);
 
-        // Assert
         Assert.True(completed);
         Assert.Equal("Hello", result);
     }
@@ -92,7 +80,6 @@ public async Task TimeoutAfter_CompletesWithReturn_ReturnsValue_Async()
     [Fact]
     public async Task TimeoutAfter_TimesOutWithReturn_ThrowsException_Async()
     {
-        // Arrange
         var completed = false;
         Func<Task<string>> task = async () =>
         {
@@ -101,10 +88,8 @@ public async Task TimeoutAfter_TimesOutWithReturn_ThrowsException_Async()
             return "Hello";
         };
 
-        // Act
         Func<Task<string>> timeoutTask = () => Task.Run(task).TimeoutAfter(1);
 
-        // Assert
         await Assert.ThrowsAsync<TimeoutException>(timeoutTask);
         Assert.False(completed);
     }
@@ -112,7 +97,6 @@ public async Task TimeoutAfter_TimesOutWithReturn_ThrowsException_Async()
     [Fact]
     public async Task TimeoutAfter_CancellationWithReturn_ThrowsException_Async()
     {
-        // Arrange
         using var cancellationTokenSource = new CancellationTokenSource();
 
         var completed = false;
@@ -123,14 +107,12 @@ public async Task TimeoutAfter_CancellationWithReturn_ThrowsException_Async()
             return "Hello";
         };
 
-        // Act
         var cancelTask = Task.Run(async () =>
         {
             await Task.Delay(100);
             await cancellationTokenSource.CancelAsync();
         });
 
-        // Assert
         await Assert.ThrowsAsync<OperationCanceledException>(
             async () => await Task.Run(task).TimeoutAfter(1000, cancellationTokenSource)
         );
diff --git a/src/TotalMixVC.Tests/TotalMixVC.Tests.csproj b/src/TotalMixVC.Tests/TotalMixVC.Tests.csproj
index fe27c2f..c77e8bc 100644
--- a/src/TotalMixVC.Tests/TotalMixVC.Tests.csproj
+++ b/src/TotalMixVC.Tests/TotalMixVC.Tests.csproj
@@ -19,11 +19,11 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="xunit" Version="2.9.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.0">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="xunit.v3" Version="1.0.1" />
     <PackageReference Include="XunitXml.TestLogger" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/src/TotalMixVC.Tests/VolumeManagerTests.cs b/src/TotalMixVC.Tests/VolumeManagerTests.cs
index d7dd664..0438792 100644
--- a/src/TotalMixVC.Tests/VolumeManagerTests.cs
+++ b/src/TotalMixVC.Tests/VolumeManagerTests.cs
@@ -5,125 +5,86 @@
 
 namespace TotalMixVC.Tests;
 
-public static class VolumeManagerTests
+public class VolumeManagerTests
 {
-    [Fact]
-    public static void Constructor_ValidVolumeRegularIncrement_SetsProperty()
+    private readonly ISender _sender = Substitute.For<ISender>();
+
+    private readonly IListener _listener = Substitute.For<IListener>();
+
+    public VolumeManagerTests()
     {
-        // Arrange & Act
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
+        _sender = Substitute.For<ISender>();
+        _listener = Substitute.For<IListener>();
+    }
 
-        using var volumeManager = new VolumeManager(sender, listener)
+    [Fact]
+    public void Constructor_ValidVolumeRegularIncrement_SetsProperty()
+    {
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.03f,
         };
 
-        // Assert
         Assert.Equal(0.03f, volumeManager.VolumeRegularIncrement);
     }
 
     [Theory]
     [InlineData(0.30f)]
     [InlineData(-0.01f)]
-    public static void Constructor_InvalidVolumeRegularIncrement_ThrowsException(
+    public void Constructor_InvalidVolumeRegularIncrement_ThrowsException(
         float volumeRegularIncrement
     )
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
-        Action action = () => volumeManager.VolumeRegularIncrement = volumeRegularIncrement;
-
-        // Assert
-        Assert.Throws<ArgumentOutOfRangeException>(action);
+        using var volumeManager = new VolumeManager(_sender, _listener);
+        Assert.Throws<ArgumentOutOfRangeException>(
+            () => volumeManager.VolumeRegularIncrement = volumeRegularIncrement
+        );
     }
 
     [Fact]
-    public static void Constructor_ValidVolumeFineIncrement_SetsProperty()
+    public void Constructor_ValidVolumeFineIncrement_SetsProperty()
     {
-        // Arrange & Act
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeFineIncrement = 0.01f,
         };
 
-        // Assert
         Assert.Equal(0.01f, volumeManager.VolumeFineIncrement);
     }
 
     [Theory]
     [InlineData(0.10f)]
     [InlineData(-0.03f)]
-    public static void Constructor_InvalidVolumeFineIncrement_ThrowsException(
-        float volumeFineIncrement
-    )
+    public void Constructor_InvalidVolumeFineIncrement_ThrowsException(float volumeFineIncrement)
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
-        Action action = () => volumeManager.VolumeFineIncrement = volumeFineIncrement;
-
-        // Assert
-        Assert.Throws<ArgumentOutOfRangeException>(action);
+        using var volumeManager = new VolumeManager(_sender, _listener);
+        Assert.Throws<ArgumentOutOfRangeException>(
+            () => volumeManager.VolumeFineIncrement = volumeFineIncrement
+        );
     }
 
     [Fact]
-    public static void Constructor_ValidVolumeMax_SetsProperty()
+    public void Constructor_ValidVolumeMax_SetsProperty()
     {
-        // Arrange & Act
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener) { VolumeMax = 0.90f };
-
-        // Assert
+        using var volumeManager = new VolumeManager(_sender, _listener) { VolumeMax = 0.90f };
         Assert.Equal(0.90f, volumeManager.VolumeMax);
     }
 
     [Theory]
     [InlineData(1.10f)]
     [InlineData(-0.15f)]
-    public static void Constructor_InvalidVolumeMax_ThrowsException(float volumeMax)
+    public void Constructor_InvalidVolumeMax_ThrowsException(float volumeMax)
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
-        Action action = () => volumeManager.VolumeMax = volumeMax;
-
-        // Assert
-        Assert.Throws<ArgumentOutOfRangeException>(action);
+        using var volumeManager = new VolumeManager(_sender, _listener);
+        Assert.Throws<ArgumentOutOfRangeException>(() => volumeManager.VolumeMax = volumeMax);
     }
 
     [Fact]
-    public static async Task RequestVolumeAsync_RegularRequest_RequestsVolume_Async()
+    public async Task RequestVolumeAsync_RegularRequest_RequestsVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         await volumeManager.RequestVolumeAsync();
-
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -133,12 +94,9 @@ await sender
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_ReceivesAllNormal_UpdatesVolume_Async()
+    public async Task ReceiveVolumeAsync_ReceivesAllNormal_UpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -151,12 +109,9 @@ public static async Task ReceiveVolumeAsync_ReceivesAllNormal_UpdatesVolume_Asyn
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var received = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.True(received);
         Assert.Equal(0.20f, volumeManager.Volume);
         Assert.Equal("-38.2 dB", volumeManager.VolumeDecibels);
@@ -165,12 +120,9 @@ public static async Task ReceiveVolumeAsync_ReceivesAllNormal_UpdatesVolume_Asyn
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_ReceivesAllDimmed_UpdatesVolume_Async()
+    public async Task ReceiveVolumeAsync_ReceivesAllDimmed_UpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -183,12 +135,9 @@ public static async Task ReceiveVolumeAsync_ReceivesAllDimmed_UpdatesVolume_Asyn
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var received = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.True(received);
         Assert.Equal(0.20f, volumeManager.Volume);
         Assert.Equal("-38.2 dB", volumeManager.VolumeDecibels);
@@ -197,12 +146,9 @@ public static async Task ReceiveVolumeAsync_ReceivesAllDimmed_UpdatesVolume_Asyn
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_ReceivesInvalidTypes_DoesNotReceiveResult_Async()
+    public async Task ReceiveVolumeAsync_ReceivesInvalidTypes_DoesNotReceiveResult_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -215,23 +161,17 @@ public static async Task ReceiveVolumeAsync_ReceivesInvalidTypes_DoesNotReceiveR
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var received = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.False(received);
         Assert.False(volumeManager.IsVolumeInitialized);
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_ReceivesDecibelsOnly_UpdatesVolume_Async()
+    public async Task ReceiveVolumeAsync_ReceivesDecibelsOnly_UpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -247,13 +187,10 @@ public static async Task ReceiveVolumeAsync_ReceivesDecibelsOnly_UpdatesVolume_A
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var receivedAll = await volumeManager.ReceiveVolumeAsync();
         var receivedDecibelsOnly = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.True(receivedAll);
         Assert.True(receivedDecibelsOnly);
         Assert.Equal(0.20f, volumeManager.Volume);
@@ -262,12 +199,9 @@ public static async Task ReceiveVolumeAsync_ReceivesDecibelsOnly_UpdatesVolume_A
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_ReceivesDecibelsOnlyInvalid_DoesNotReceiveResult_Async()
+    public async Task ReceiveVolumeAsync_ReceivesDecibelsOnlyInvalid_DoesNotReceiveResult_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -275,23 +209,17 @@ public static async Task ReceiveVolumeAsync_ReceivesDecibelsOnlyInvalid_DoesNotR
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var received = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.False(received);
         Assert.False(volumeManager.IsVolumeInitialized);
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_ReceivesOtherVolume_DoesNotReceiveResult_Async()
+    public async Task ReceiveVolumeAsync_ReceivesOtherVolume_DoesNotReceiveResult_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -303,67 +231,49 @@ public static async Task ReceiveVolumeAsync_ReceivesOtherVolume_DoesNotReceiveRe
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var received = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.False(received);
         Assert.False(volumeManager.IsVolumeInitialized);
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_IncorrectPacketType_DoesNotReceiveResult_Async()
+    public async Task ReceiveVolumeAsync_IncorrectPacketType_DoesNotReceiveResult_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(new OscMessage("/1/mastervolume", 0.20f))
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var received = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.False(received);
         Assert.False(volumeManager.IsVolumeInitialized);
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_PacketMalformed_DoesNotReceiveResult_Async()
+    public async Task ReceiveVolumeAsync_PacketMalformed_DoesNotReceiveResult_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromException<OscPacket>(new OscException(OscError.MissingComma, "weov"))
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var received = await volumeManager.ReceiveVolumeAsync();
 
-        // Assert
         Assert.False(received);
         Assert.False(volumeManager.IsVolumeInitialized);
     }
 
     [Fact]
-    public static async Task ReceiveVolumeAsync_Timeout_ThrowsExceptionAndResetsVolume_Async()
+    public async Task ReceiveVolumeAsync_Timeout_ThrowsExceptionAndResetsVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -377,48 +287,37 @@ public static async Task ReceiveVolumeAsync_Timeout_ThrowsExceptionAndResetsVolu
                 Task.FromException<OscPacket>(new TimeoutException("weov"))
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
+        using var volumeManager = new VolumeManager(_sender, _listener);
 
-        // Act
         var received = await volumeManager.ReceiveVolumeAsync();
         var initializedAfterVolumeReceived = volumeManager.IsVolumeInitialized;
 
-        Func<Task> task = async () => await volumeManager.ReceiveVolumeAsync();
-
-        // Assert
         Assert.True(received);
         Assert.True(initializedAfterVolumeReceived);
 
-        await Assert.ThrowsAsync<TimeoutException>(task);
+        await Assert.ThrowsAsync<TimeoutException>(
+            async () => await volumeManager.ReceiveVolumeAsync()
+        );
         Assert.False(volumeManager.IsVolumeInitialized);
     }
 
     [Fact]
-    public static async Task IncreaseVolumeAsync_RegularVolumeNotInitialized_DoesNotUpdateVolume_Async()
+    public async Task IncreaseVolumeAsync_RegularVolumeNotInitialized_DoesNotUpdateVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.02f,
         };
 
-        // Act
         var updated = await volumeManager.IncreaseVolumeAsync();
 
-        // Assert
         Assert.False(updated);
     }
 
     [Fact]
-    public static async Task IncreaseVolumeAsync_RegularAfterVolumeInitialized_UpdatesVolume_Async()
+    public async Task IncreaseVolumeAsync_RegularAfterVolumeInitialized_UpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -431,17 +330,15 @@ public static async Task IncreaseVolumeAsync_RegularAfterVolumeInitialized_Updat
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.02f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.IncreaseVolumeAsync();
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -454,12 +351,9 @@ await sender
     }
 
     [Fact]
-    public static async Task IncreaseVolumeAsync_RegularExceedsMax_IsCappedAndUpdatesVolume_Async()
+    public async Task IncreaseVolumeAsync_RegularExceedsMax_IsCappedAndUpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -472,18 +366,16 @@ public static async Task IncreaseVolumeAsync_RegularExceedsMax_IsCappedAndUpdate
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.05f,
             VolumeMax = 0.50f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.IncreaseVolumeAsync();
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -496,12 +388,9 @@ await sender
     }
 
     [Fact]
-    public static async Task IncreaseVolumeAsync_RegularAlreadyMax_DoesNotUpdateVolume_Async()
+    public async Task IncreaseVolumeAsync_RegularAlreadyMax_DoesNotUpdateVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -514,46 +403,35 @@ public static async Task IncreaseVolumeAsync_RegularAlreadyMax_DoesNotUpdateVolu
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.05f,
             VolumeMax = 0.50f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.IncreaseVolumeAsync();
 
-        // Assert
         Assert.False(updated);
     }
 
     [Fact]
-    public static async Task IncreaseVolumeAsync_FineVolumeNotInitialized_DoesNotUpdateVolume_Async()
+    public async Task IncreaseVolumeAsync_FineVolumeNotInitialized_DoesNotUpdateVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeFineIncrement = 0.01f,
         };
 
-        // Act
         var updated = await volumeManager.IncreaseVolumeAsync(fine: true);
 
-        // Assert
         Assert.False(updated);
     }
 
     [Fact]
-    public static async Task FineAfterVolumeInitialized_UpdatesVolume_Async()
+    public async Task FineAfterVolumeInitialized_UpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -566,17 +444,15 @@ public static async Task FineAfterVolumeInitialized_UpdatesVolume_Async()
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeFineIncrement = 0.01f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.IncreaseVolumeAsync(fine: true);
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -589,31 +465,22 @@ await sender
     }
 
     [Fact]
-    public static async Task DecreaseVolumeAsync_RegularVolumeNotInitialized_DoesNotUpdateVolume_Async()
+    public async Task DecreaseVolumeAsync_RegularVolumeNotInitialized_DoesNotUpdateVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.02f,
         };
 
-        // Act
         var updated = await volumeManager.DecreaseVolumeAsync();
 
-        // Assert
         Assert.False(updated);
     }
 
     [Fact]
-    public static async Task DecreaseVolumeAsync_RegularAfterVolumeInitialized_UpdatesVolume_Async()
+    public async Task DecreaseVolumeAsync_RegularAfterVolumeInitialized_UpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -626,17 +493,15 @@ public static async Task DecreaseVolumeAsync_RegularAfterVolumeInitialized_Updat
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.02f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.DecreaseVolumeAsync();
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -649,12 +514,9 @@ await sender
     }
 
     [Fact]
-    public static async Task DecreaseVolumeAsync_RegularBelowSilent_IsSetToSilentAndUpdatesVolume_Async()
+    public async Task DecreaseVolumeAsync_RegularBelowSilent_IsSetToSilentAndUpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -667,17 +529,15 @@ public static async Task DecreaseVolumeAsync_RegularBelowSilent_IsSetToSilentAnd
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.05f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.DecreaseVolumeAsync();
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -690,12 +550,9 @@ await sender
     }
 
     [Fact]
-    public static async Task DecreaseVolumeAsync_RegularAlreadySilent_DoesNotUpdateVolume_Async()
+    public async Task DecreaseVolumeAsync_RegularAlreadySilent_DoesNotUpdateVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -708,46 +565,35 @@ public static async Task DecreaseVolumeAsync_RegularAlreadySilent_DoesNotUpdateV
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeRegularIncrement = 0.05f,
             VolumeMax = 0.50f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.DecreaseVolumeAsync();
 
-        // Assert
         Assert.False(updated);
     }
 
     [Fact]
-    public static async Task DecreaseVolumeAsync_FineVolumeNotInitialized_DoesNotUpdateVolume_Async()
+    public async Task DecreaseVolumeAsync_FineVolumeNotInitialized_DoesNotUpdateVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeFineIncrement = 0.01f,
         };
 
-        // Act
         var updated = await volumeManager.DecreaseVolumeAsync(fine: true);
 
-        // Assert
         Assert.False(updated);
     }
 
     [Fact]
-    public static async Task DecreaseVolumeAsync_FineAfterVolumeInitialized_UpdatesVolume_Async()
+    public async Task DecreaseVolumeAsync_FineAfterVolumeInitialized_UpdatesVolume_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -760,17 +606,15 @@ public static async Task DecreaseVolumeAsync_FineAfterVolumeInitialized_UpdatesV
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener)
+        using var volumeManager = new VolumeManager(_sender, _listener)
         {
             VolumeFineIncrement = 0.01f,
         };
 
-        // Act
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.DecreaseVolumeAsync(fine: true);
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -783,28 +627,17 @@ await sender
     }
 
     [Fact]
-    public static async Task ToggloDimAsync_VolumeNotInitialized_DoesNotUpdateDim_Async()
+    public async Task ToggloDimAsync_VolumeNotInitialized_DoesNotUpdateDim_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         var updated = await volumeManager.ToggloDimAsync();
-
-        // Assert
         Assert.False(updated);
     }
 
     [Fact]
-    public static async Task ToggloDimAsync_AfterVolumeInitialized_EnableDim_Async()
+    public async Task ToggloDimAsync_AfterVolumeInitialized_EnableDim_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -817,14 +650,11 @@ public static async Task ToggloDimAsync_AfterVolumeInitialized_EnableDim_Async()
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.ToggloDimAsync();
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>
@@ -837,12 +667,9 @@ await sender
     }
 
     [Fact]
-    public static async Task ToggloDimAsync_AfterVolumeInitialized_DisableDim_Async()
+    public async Task ToggloDimAsync_AfterVolumeInitialized_DisableDim_Async()
     {
-        // Arrange
-        var sender = Substitute.For<ISender>();
-        var listener = Substitute.For<IListener>();
-        listener
+        _listener
             .ReceiveAsync(default)
             .ReturnsForAnyArgs(
                 Task.FromResult<OscPacket>(
@@ -855,14 +682,11 @@ public static async Task ToggloDimAsync_AfterVolumeInitialized_DisableDim_Async(
                 )
             );
 
-        using var volumeManager = new VolumeManager(sender, listener);
-
-        // Act
+        using var volumeManager = new VolumeManager(_sender, _listener);
         await volumeManager.ReceiveVolumeAsync();
         var updated = await volumeManager.ToggloDimAsync();
 
-        // Assert
-        await sender
+        await _sender
             .Received()
             .SendAsync(
                 Arg.Is<OscMessage>(m =>