Update PolyfillTests_MicroNanosecond.cs

Author: SimonCropp

src/Tests/PolyfillTests_MicroNanosecond.cs

@@ -35,39 +35,39 @@ public async Task Microsecond()
 #endif
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_CreatesCorrectTimeSpan()
+    public async Task TimeSpan_FromMilliseconds_Long_CreatesCorrectTimeSpan()
     {
         // Arrange & Act
         var timeSpan = TimeSpan.FromMilliseconds(5000L);
 
         // Assert
-        Assert.AreEqual(5, timeSpan.TotalSeconds);
-        Assert.AreEqual(5000, timeSpan.TotalMilliseconds);
+        await Assert.That(timeSpan.TotalSeconds).IsEqualTo(5);
+        await Assert.That(timeSpan.TotalMilliseconds).IsEqualTo(5000);
     }
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_Zero()
+    public async Task TimeSpan_FromMilliseconds_Long_Zero()
     {
         // Arrange & Act
         var timeSpan = TimeSpan.FromMilliseconds(0L);
 
         // Assert
-        Assert.AreEqual(TimeSpan.Zero, timeSpan);
+        await Assert.That(timeSpan).IsEqualTo(TimeSpan.Zero);
     }
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_Negative()
+    public async Task TimeSpan_FromMilliseconds_Long_Negative()
     {
         // Arrange & Act
         var timeSpan = TimeSpan.FromMilliseconds(-1000L);
 
         // Assert
-        Assert.AreEqual(-1, timeSpan.TotalSeconds);
-        Assert.AreEqual(-1000, timeSpan.TotalMilliseconds);
+        await Assert.That(timeSpan.TotalSeconds).IsEqualTo(-1);
+        await Assert.That(timeSpan.TotalMilliseconds).IsEqualTo(-1000);
     }
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_LargeValue()
+    public async Task TimeSpan_FromMilliseconds_Long_LargeValue()
     {
         // Arrange - 1 hour in milliseconds
         var oneHourMs = 3600000L;
@@ -76,61 +76,61 @@ public void TimeSpan_FromMilliseconds_Long_LargeValue()
         var timeSpan = TimeSpan.FromMilliseconds(oneHourMs);
 
         // Assert
-        Assert.AreEqual(1, timeSpan.TotalHours);
-        Assert.AreEqual(60, timeSpan.TotalMinutes);
+        await Assert.That(timeSpan.TotalHours).IsEqualTo(1);
+        await Assert.That(timeSpan.TotalMinutes).IsEqualTo(60);
     }
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_MaxValue_ThrowsOverflowException()
+    public async Task TimeSpan_FromMilliseconds_Long_MaxValue_ThrowsOverflowException()
     {
         // Arrange - value that would overflow
         var tooLarge = long.MaxValue;
 
         // Act & Assert - Native .NET 10+ throws ArgumentOutOfRangeException, polyfill throws OverflowException
 #if NET10_0_OR_GREATER
-        Assert.Throws<ArgumentOutOfRangeException>(() => TimeSpan.FromMilliseconds(tooLarge));
+        await Assert.That(() => TimeSpan.FromMilliseconds(tooLarge)).Throws<ArgumentOutOfRangeException>();
 #else
-        Assert.Throws<OverflowException>(() => TimeSpan.FromMilliseconds(tooLarge));
+        await Assert.That(() => TimeSpan.FromMilliseconds(tooLarge)).Throws<OverflowException>();
 #endif
     }
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_MinValue_ThrowsOverflowException()
+    public async Task TimeSpan_FromMilliseconds_Long_MinValue_ThrowsOverflowException()
     {
         // Arrange - value that would overflow
         var tooSmall = long.MinValue;
 
         // Act & Assert - Native .NET 10+ throws ArgumentOutOfRangeException, polyfill throws OverflowException
 #if NET10_0_OR_GREATER
-        Assert.Throws<ArgumentOutOfRangeException>(() => TimeSpan.FromMilliseconds(tooSmall));
+        await Assert.That(() => TimeSpan.FromMilliseconds(tooSmall)).Throws<ArgumentOutOfRangeException>();
 #else
-        Assert.Throws<OverflowException>(() => TimeSpan.FromMilliseconds(tooSmall));
+        await Assert.That(() => TimeSpan.FromMilliseconds(tooSmall)).Throws<OverflowException>();
 #endif
     }
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_NearMaxValue()
+    public async Task TimeSpan_FromMilliseconds_Long_NearMaxValue()
     {
         // Arrange - near max safe milliseconds value
-        const long nearMaxMilliseconds = (long.MaxValue / 10000) - 1;
+        const long nearMaxMilliseconds = long.MaxValue / 10000 - 1;
 
         // Act
         var timeSpan = TimeSpan.FromMilliseconds(nearMaxMilliseconds);
 
         // Assert
-        Assert.AreEqual(nearMaxMilliseconds, (long)timeSpan.TotalMilliseconds);
+        await Assert.That((long)timeSpan.TotalMilliseconds).IsEqualTo(nearMaxMilliseconds);
     }
 
     [Test]
-    public void TimeSpan_FromMilliseconds_Long_NearMinValue()
+    public async Task TimeSpan_FromMilliseconds_Long_NearMinValue()
     {
         // Arrange - near min safe milliseconds value
-        const long nearMinMilliseconds = (long.MinValue / 10000) + 1;
+        const long nearMinMilliseconds = long.MinValue / 10000 + 1;
 
         // Act
         var timeSpan = TimeSpan.FromMilliseconds(nearMinMilliseconds);
 
         // Assert
-        Assert.AreEqual(nearMinMilliseconds, (long)timeSpan.TotalMilliseconds);
+        await Assert.That((long)timeSpan.TotalMilliseconds).IsEqualTo(nearMinMilliseconds);
     }
 }