Updating deprecated test functions

Changed deprecated Assert functions to current versions of those functions.

Enabled Skipped Ctor_NullStream_ThrowsArgumentNullException test as it now is passing with correct exception being thrown.

Enabled Dispose_BufferContentThenDisposeContent_BufferedStreamGetsDisposed test as it also is passing.

Author: mizady

Tests/HttpUnitTests/HttpContentTest.cs

@@ -18,27 +18,22 @@ public class HttpContentTest
         [TestMethod]
         public void Dispose_BufferContentThenDisposeContent_BufferedStreamGetsDisposed()
         {
-            Assert.SkipTest("Skipping test because of issue in Test Framework");
-
-            // TODO
-            // test is being reported as failing, despite it's successful, issue lyes in the TestFramework
-
             MockContent content = new MockContent();
             content.LoadIntoBuffer();
 
             Type type = typeof(HttpContent);
 
             FieldInfo bufferedContentField = type.GetField("_buffer", BindingFlags.Instance | BindingFlags.NonPublic);
 
-            Assert.NotNull(bufferedContentField, "_buffer field shouldn't be null");
+            Assert.IsNotNull(bufferedContentField, "_buffer field shouldn't be null");
 
             MemoryStream bufferedContentStream = bufferedContentField.GetValue(content) as MemoryStream;
-            Assert.NotNull(bufferedContentStream, "bufferedContentStream field shouldn't be null");
+            Assert.IsNotNull(bufferedContentStream, "bufferedContentStream field shouldn't be null");
 
             content.Dispose();
 
             // The following line will throw an ObjectDisposedException if the buffered-stream was correctly disposed.
-            Assert.Throws(typeof(ObjectDisposedException),
+            Assert.ThrowsException(typeof(ObjectDisposedException),
                 () =>
                 {
                     _ = bufferedContentStream.Length.ToString();
@@ -65,9 +60,9 @@ public void LoadIntoBuffer_ContentLengthSmallerThanActualData_ActualDataLargerTh
 
             foreach (var testConfig in bufferTests)
             {
-                Assert.True((testConfig.MaxSize >= 1 && testConfig.MaxSize <= (testConfig.NumberOfWrites * testConfig.SizeOfEachWrite) - 1), "Config values out of range.");
+                Assert.IsTrue((testConfig.MaxSize >= 1 && testConfig.MaxSize <= (testConfig.NumberOfWrites * testConfig.SizeOfEachWrite) - 1), "Config values out of range.");
 
-                Assert.Throws(typeof(HttpRequestException),
+                Assert.ThrowsException(typeof(HttpRequestException),
                     () =>
                     {
                         LieAboutLengthContent c = new(

Tests/HttpUnitTests/StreamContentTest.cs

@@ -14,27 +14,24 @@ namespace HttpUnitTests
     [TestClass]
     public class StreamContentTest
     {
-        // TODO need to fix processing of exception
-        //[TestMethod]
-        //public void Ctor_NullStream_ThrowsArgumentNullException()
-        //{
-        //    Assert.SkipTest("Test disabled because of failure in StreamContent");
-        //
-        //    Assert.Throws(typeof(ArgumentNullException),
-        //        () => new StreamContent(null));
-        //}
+        [TestMethod]
+        public void Ctor_NullStream_ThrowsArgumentNullException()
+        {
+            Assert.ThrowsException(typeof(ArgumentNullException),
+                () => new StreamContent(null));
+        }
 
         [TestMethod]
         public void Ctor_ZeroBufferSize_ThrowsArgumentOutOfRangeException()
         {
-            Assert.Throws(typeof(ArgumentOutOfRangeException),
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException),
                 () => new StreamContent(new MemoryStream(), 0));
         }
 
         [TestMethod]
         public void Ctor_NullStreamAndZeroBufferSize_ThrowsArgumentNullException()
         {
-            Assert.Throws(typeof(ArgumentNullException),
+            Assert.ThrowsException(typeof(ArgumentNullException),
                 () => new StreamContent(null, 0));
         }
 
@@ -44,7 +41,7 @@ public void ContentLength_SetStreamSupportingSeeking_StreamLengthMatchesHeaderVa
             var source = new MockStream(new byte[10], true, true);
             var content = new StreamContent(source);
 
-            Assert.Equal(source.Length, content.Headers.ContentLength);
+            Assert.AreEqual(source.Length, content.Headers.ContentLength);
         }
 
         [TestMethod]
@@ -55,7 +52,7 @@ public void ContentLength_SetStreamSupportingSeekingPartiallyConsumed_StreamLeng
             source.Read(new byte[consumed], 0, consumed);
             var content = new StreamContent(source);
 
-            Assert.Equal(source.Length - consumed, content.Headers.ContentLength);
+            Assert.AreEqual(source.Length - consumed, content.Headers.ContentLength);
         }
 
         [TestMethod]
@@ -65,15 +62,15 @@ public void Dispose_UseMockStreamSourceAndDisposeContent_MockStreamGotDisposed()
             var content = new StreamContent(source);
             content.Dispose();
 
-            Assert.Equal(1, source.DisposeCount);
+            Assert.AreEqual(1, source.DisposeCount);
         }
 
         [TestMethod]
         public void CopyToAsync_NullDestination_ThrowsArgumentnullException()
         {
             var source = new MockStream(new byte[10]);
             var content = new StreamContent(source);
-            Assert.Throws(typeof(ArgumentNullException),
+            Assert.ThrowsException(typeof(ArgumentNullException),
                 () =>
                 {
                     content.CopyTo(null);
@@ -89,11 +86,11 @@ public void CopyTo_CallMultipleTimesWithStreamSupportingSeeking_ContentIsSeriali
 
             var destination1 = new MemoryStream();
             content.CopyTo(destination1);
-            Assert.Equal(source.Length, destination1.Length);
+            Assert.AreEqual(source.Length, destination1.Length);
 
             var destination2 = new MemoryStream();
             content.CopyTo(destination2);
-            Assert.Equal(source.Length, destination2.Length);
+            Assert.AreEqual(source.Length, destination2.Length);
         }
 
         [TestMethod]
@@ -106,11 +103,11 @@ public void CopyTo_CallMultipleTimesWithStreamSupportingSeekingPartiallyConsumed
 
             var destination1 = new MemoryStream();
             content.CopyTo(destination1);
-            Assert.Equal(source.Length - consumed, destination1.Length);
+            Assert.AreEqual(source.Length - consumed, destination1.Length);
 
             var destination2 = new MemoryStream();
             content.CopyTo(destination2);
-            Assert.Equal(source.Length - consumed, destination2.Length);
+            Assert.AreEqual(source.Length - consumed, destination2.Length);
         }
 
         [TestMethod]
@@ -123,11 +120,11 @@ public void CopyTo_CallMultipleTimesWithStreamNotSupportingSeeking_ThrowsInvalid
             content.CopyTo(destination1);
 
             // Use hardcoded expected length, since source.Length would throw (source stream gets disposed if non-seekable).
-            Assert.Equal(10, destination1.Length);
+            Assert.AreEqual(10, destination1.Length);
 
             // Note that the InvalidOperationException is thrown in CopyToAsync(). It is not thrown inside the task.
             var destination2 = new MemoryStream();
-            Assert.Throws(typeof(InvalidOperationException),
+            Assert.ThrowsException(typeof(InvalidOperationException),
                 () =>
                 {
                     content.CopyTo(destination2);
@@ -147,11 +144,11 @@ public void CopyTo_CallMultipleTimesWithStreamNotSupportingSeekingButBufferedStr
             var destination1 = new MemoryStream();
             content.CopyTo(destination1);
             // Use hardcoded expected length, since source.Length would throw (source stream gets disposed if non-seekable)
-            Assert.Equal(10, destination1.Length);
+            Assert.AreEqual(10, destination1.Length);
 
             var destination2 = new MemoryStream();
             content.CopyTo(destination2);
-            Assert.Equal(10, destination2.Length);
+            Assert.AreEqual(10, destination2.Length);
         }
 
         [TestMethod]
@@ -169,11 +166,11 @@ public void CopyTo_CallMultipleTimesWithStreamNotSupportingSeekingButBufferedStr
             var destination1 = new MemoryStream();
             content.CopyTo(destination1);
             // Use hardcoded expected length, since source.Length would throw (source stream gets disposed if non-seekable).
-            Assert.Equal(10 - consumed, destination1.Length);
+            Assert.AreEqual(10 - consumed, destination1.Length);
 
             var destination2 = new MemoryStream();
             content.CopyTo(destination2);
-            Assert.Equal(10 - consumed, destination2.Length);
+            Assert.AreEqual(10 - consumed, destination2.Length);
         }
 
         [TestMethod]
@@ -242,10 +239,10 @@ public void ContentReadStream_GetProperty_ReturnOriginalStream()
             var content = new StreamContent(source);
 
             Stream stream = content.ReadAsStream();
-            Assert.False(stream.CanWrite);
-            Assert.Equal(source.Length, stream.Length);
-            Assert.Equal(0, source.ReadCount);
-            Assert.NotSame(source, stream);
+            Assert.IsFalse(stream.CanWrite);
+            Assert.AreEqual(source.Length, stream.Length);
+            Assert.AreEqual(0, source.ReadCount);
+            Assert.AreNotSame(source, stream);
         }
 
         [TestMethod]
@@ -271,11 +268,11 @@ public void ContentReadStream_GetPropertyPartiallyConsumed_ReturnOriginalStream(
             var content = new StreamContent(source);
 
             Stream stream = content.ReadAsStream();
-            Assert.False(stream.CanWrite);
-            Assert.Equal(source.Length, stream.Length);
-            Assert.Equal(1, source.ReadCount);
-            Assert.Equal(consumed, stream.Position);
-            Assert.NotSame(source, stream);
+            Assert.IsFalse(stream.CanWrite);
+            Assert.AreEqual(source.Length, stream.Length);
+            Assert.AreEqual(1, source.ReadCount);
+            Assert.AreEqual(consumed, stream.Position);
+            Assert.AreNotSame(source, stream);
         }
 
         [TestMethod]
@@ -296,56 +293,56 @@ public void ContentReadStream_CheckResultProperties_ValuesRepresentReadOnlyStrea
             // The following checks verify that the stream returned passes all read-related properties to the
             // underlying MockStream and throws when using write-related members.
 
-            Assert.False(contentReadStream.CanWrite);
-            Assert.True(contentReadStream.CanRead);
-            Assert.Equal(source.Length, contentReadStream.Length);
+            Assert.IsFalse(contentReadStream.CanWrite);
+            Assert.IsTrue(contentReadStream.CanRead);
+            Assert.AreEqual(source.Length, contentReadStream.Length);
 
-            Assert.Equal(1, source.CanSeekCount);
+            Assert.AreEqual(1, source.CanSeekCount);
             OutputHelper.WriteLine(contentReadStream.CanSeek.ToString());
-            Assert.Equal(2, source.CanSeekCount);
+            Assert.AreEqual(2, source.CanSeekCount);
 
             contentReadStream.Position = 3; // No exception.
-            Assert.Equal(3, contentReadStream.Position);
+            Assert.AreEqual(3, contentReadStream.Position);
 
             byte byteOnIndex3 = (byte)contentReadStream.ReadByte();
-            Assert.Equal(data[3], byteOnIndex3);
+            Assert.AreEqual(data[3], byteOnIndex3);
 
             byte[] byteOnIndex4 = new byte[1];
             int result = contentReadStream.Read(byteOnIndex4, 0, 1);
-            Assert.Equal(1, result);
+            Assert.AreEqual(1, result);
 
-            Assert.Equal(data[4], byteOnIndex4[0]);
+            Assert.AreEqual(data[4], byteOnIndex4[0]);
 
             byte[] byteOnIndex5 = new byte[1];
-            Assert.Equal(1, contentReadStream.Read(byteOnIndex5, 0, 1));
-            Assert.Equal(data[5], byteOnIndex5[0]);
+            Assert.AreEqual(1, contentReadStream.Read(byteOnIndex5, 0, 1));
+            Assert.AreEqual(data[5], byteOnIndex5[0]);
 
             byte[] byteOnIndex6 = new byte[1];
-            Assert.Equal(1, contentReadStream.Read(new SpanByte(byteOnIndex6, 0, 1)));
-            Assert.Equal(data[6], byteOnIndex6[0]);
+            Assert.AreEqual(1, contentReadStream.Read(new SpanByte(byteOnIndex6, 0, 1)));
+            Assert.AreEqual(data[6], byteOnIndex6[0]);
 
             contentReadStream.ReadTimeout = 123;
-            Assert.Equal(123, source.ReadTimeout);
-            Assert.Equal(123, contentReadStream.ReadTimeout);
+            Assert.AreEqual(123, source.ReadTimeout);
+            Assert.AreEqual(123, contentReadStream.ReadTimeout);
 
-            Assert.Equal(0, source.CanTimeoutCount);
+            Assert.AreEqual(0, source.CanTimeoutCount);
             OutputHelper.WriteLine(contentReadStream.CanTimeout.ToString());
-            Assert.Equal(1, source.CanTimeoutCount);
+            Assert.AreEqual(1, source.CanTimeoutCount);
 
-            Assert.Equal(0, source.SeekCount);
+            Assert.AreEqual(0, source.SeekCount);
             contentReadStream.Seek(0, SeekOrigin.Begin);
-            Assert.Equal(1, source.SeekCount);
+            Assert.AreEqual(1, source.SeekCount);
 
-            Assert.Throws(typeof(NotSupportedException), () => { contentReadStream.WriteTimeout = 5; });
-            Assert.Throws(typeof(NotSupportedException), () => contentReadStream.WriteTimeout.ToString());
-            Assert.Throws(typeof(NotSupportedException), () => contentReadStream.Flush());
-            Assert.Throws(typeof(NotSupportedException), () => contentReadStream.SetLength(1));
-            Assert.Throws(typeof(NotSupportedException), () => contentReadStream.Write(null, 0, 0));
-            Assert.Throws(typeof(NotSupportedException), () => contentReadStream.WriteByte(1));
+            Assert.ThrowsException(typeof(NotSupportedException), () => { contentReadStream.WriteTimeout = 5; });
+            Assert.ThrowsException(typeof(NotSupportedException), () => contentReadStream.WriteTimeout.ToString());
+            Assert.ThrowsException(typeof(NotSupportedException), () => contentReadStream.Flush());
+            Assert.ThrowsException(typeof(NotSupportedException), () => contentReadStream.SetLength(1));
+            Assert.ThrowsException(typeof(NotSupportedException), () => contentReadStream.Write(null, 0, 0));
+            Assert.ThrowsException(typeof(NotSupportedException), () => contentReadStream.WriteByte(1));
 
-            Assert.Equal(0, source.DisposeCount);
+            Assert.AreEqual(0, source.DisposeCount);
             contentReadStream.Dispose();
-            Assert.Equal(1, source.DisposeCount);
+            Assert.AreEqual(1, source.DisposeCount);
         }
 
         #region Helper methods