Change to using xUnit for all unit tests, and fetch that via NuGet.

This includes fetching the VS unit test runner package, so that tests can be run from Visual Studio's Test Explorer.

1 files changed, 111 insertions, 112 deletions

diff --git a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
index 8e4e9090..d9f53d74 100644
--- a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
@@ -38,11 +38,10 @@ using System;
 using System.Collections.Generic;

 using System.IO;

 using Google.ProtocolBuffers.TestProtos;

-using Microsoft.VisualStudio.TestTools.UnitTesting;

+using Xunit;

 

 namespace Google.ProtocolBuffers

 {

-    [TestClass]

     public class CodedOutputStreamTest

     {

         /// <summary>

@@ -58,9 +57,9 @@ namespace Google.ProtocolBuffers
                 CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);

                 output.WriteRawVarint32((uint) value);

                 output.Flush();

-                TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+                Assert.Equal(data, rawOutput.ToArray());

                 // Also try computing size.

-                Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value));

+                Assert.Equal(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value));

             }

 

             {

@@ -68,10 +67,10 @@ namespace Google.ProtocolBuffers
                 CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);

                 output.WriteRawVarint64(value);

                 output.Flush();

-                TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+                Assert.Equal(data, rawOutput.ToArray());

 

                 // Also try computing size.

-                Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value));

+                Assert.Equal(data.Length, CodedOutputStream.ComputeRawVarint64Size(value));

             }

 

             // Try different buffer sizes.

@@ -85,7 +84,7 @@ namespace Google.ProtocolBuffers
                         CodedOutputStream.CreateInstance(rawOutput, bufferSize);

                     output.WriteRawVarint32((uint) value);

                     output.Flush();

-                    TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+                    Assert.Equal(data, rawOutput.ToArray());

                 }

 

                 {

@@ -93,7 +92,7 @@ namespace Google.ProtocolBuffers
                     CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);

                     output.WriteRawVarint64(value);

                     output.Flush();

-                    TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+                    Assert.Equal(data, rawOutput.ToArray());

                 }

             }

         }

@@ -101,7 +100,7 @@ namespace Google.ProtocolBuffers
         /// <summary>

         /// Tests WriteRawVarint32() and WriteRawVarint64()

         /// </summary>

-        [TestMethod]

+        [Fact]

         public void WriteVarint()

         {

             AssertWriteVarint(new byte[] {0x00}, 0);

@@ -143,7 +142,7 @@ namespace Google.ProtocolBuffers
             CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);

             output.WriteRawLittleEndian32(value);

             output.Flush();

-            TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+            Assert.Equal(data, rawOutput.ToArray());

 

             // Try different buffer sizes.

             for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2)

@@ -152,7 +151,7 @@ namespace Google.ProtocolBuffers
                 output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);

                 output.WriteRawLittleEndian32(value);

                 output.Flush();

-                TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+                Assert.Equal(data, rawOutput.ToArray());

             }

         }

 

@@ -166,7 +165,7 @@ namespace Google.ProtocolBuffers
             CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);

             output.WriteRawLittleEndian64(value);

             output.Flush();

-            TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+            Assert.Equal(data, rawOutput.ToArray());

 

             // Try different block sizes.

             for (int blockSize = 1; blockSize <= 16; blockSize *= 2)

@@ -175,14 +174,14 @@ namespace Google.ProtocolBuffers
                 output = CodedOutputStream.CreateInstance(rawOutput, blockSize);

                 output.WriteRawLittleEndian64(value);

                 output.Flush();

-                TestUtil.AssertBytesEqual(data, rawOutput.ToArray());

+                Assert.Equal(data, rawOutput.ToArray());

             }

         }

 

         /// <summary>

         /// Tests writeRawLittleEndian32() and writeRawLittleEndian64().

         /// </summary>

-        [TestMethod]

+        [Fact]

         public void WriteLittleEndian()

         {

             AssertWriteLittleEndian32(new byte[] {0x78, 0x56, 0x34, 0x12}, 0x12345678);

@@ -196,7 +195,7 @@ namespace Google.ProtocolBuffers
                 0x9abcdef012345678UL);

         }

 

-        [TestMethod]

+        [Fact]

         public void WriteWholeMessage()

         {

             TestAllTypes message = TestUtil.GetAllSet();

@@ -220,7 +219,7 @@ namespace Google.ProtocolBuffers
         /// Tests writing a whole message with every packed field type. Ensures the

         /// wire format of packed fields is compatible with C++.

         /// </summary>

-        [TestMethod]

+        [Fact]

         public void WriteWholePackedFieldsMessage()

         {

             TestPackedTypes message = TestUtil.GetPackedSet();

@@ -230,97 +229,97 @@ namespace Google.ProtocolBuffers
                                       rawBytes);

         }

 

-        [TestMethod]

+        [Fact]

         public void EncodeZigZag32()

         {

-            Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag32(0));

-            Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag32(-1));

-            Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag32(1));

-            Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag32(-2));

-            Assert.AreEqual(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));

-            Assert.AreEqual(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000)));

-            Assert.AreEqual(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));

-            Assert.AreEqual(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000)));

+            Assert.Equal(0u, CodedOutputStream.EncodeZigZag32(0));

+            Assert.Equal(1u, CodedOutputStream.EncodeZigZag32(-1));

+            Assert.Equal(2u, CodedOutputStream.EncodeZigZag32(1));

+            Assert.Equal(3u, CodedOutputStream.EncodeZigZag32(-2));

+            Assert.Equal(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));

+            Assert.Equal(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000)));

+            Assert.Equal(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));

+            Assert.Equal(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000)));

         }

 

-        [TestMethod]

+        [Fact]

         public void EncodeZigZag64()

         {

-            Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag64(0));

-            Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag64(-1));

-            Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag64(1));

-            Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag64(-2));

-            Assert.AreEqual(0x000000007FFFFFFEuL,

+            Assert.Equal(0u, CodedOutputStream.EncodeZigZag64(0));

+            Assert.Equal(1u, CodedOutputStream.EncodeZigZag64(-1));

+            Assert.Equal(2u, CodedOutputStream.EncodeZigZag64(1));

+            Assert.Equal(3u, CodedOutputStream.EncodeZigZag64(-2));

+            Assert.Equal(0x000000007FFFFFFEuL,

                             CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL)));

-            Assert.AreEqual(0x000000007FFFFFFFuL,

+            Assert.Equal(0x000000007FFFFFFFuL,

                             CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL)));

-            Assert.AreEqual(0x00000000FFFFFFFEuL,

+            Assert.Equal(0x00000000FFFFFFFEuL,

                             CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL)));

-            Assert.AreEqual(0x00000000FFFFFFFFuL,

+            Assert.Equal(0x00000000FFFFFFFFuL,

                             CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL)));

-            Assert.AreEqual(0xFFFFFFFFFFFFFFFEL,

+            Assert.Equal(0xFFFFFFFFFFFFFFFEL,

                             CodedOutputStream.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL)));

-            Assert.AreEqual(0xFFFFFFFFFFFFFFFFL,

+            Assert.Equal(0xFFFFFFFFFFFFFFFFL,

                             CodedOutputStream.EncodeZigZag64(unchecked((long) 0x8000000000000000UL)));

         }

 

-        [TestMethod]

+        [Fact]

         public void RoundTripZigZag32()

         {

             // Some easier-to-verify round-trip tests.  The inputs (other than 0, 1, -1)

             // were chosen semi-randomly via keyboard bashing.

-            Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0)));

-            Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1)));

-            Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1)));

-            Assert.AreEqual(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927)));

-            Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612)));

+            Assert.Equal(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0)));

+            Assert.Equal(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1)));

+            Assert.Equal(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1)));

+            Assert.Equal(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927)));

+            Assert.Equal(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612)));

         }

 

-        [TestMethod]

+        [Fact]

         public void RoundTripZigZag64()

         {

-            Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0)));

-            Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1)));

-            Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1)));

-            Assert.AreEqual(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927)));

-            Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612)));

+            Assert.Equal(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0)));

+            Assert.Equal(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1)));

+            Assert.Equal(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1)));

+            Assert.Equal(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927)));

+            Assert.Equal(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612)));

 

-            Assert.AreEqual(856912304801416L,

+            Assert.Equal(856912304801416L,

                             CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L)));

-            Assert.AreEqual(-75123905439571256L,

+            Assert.Equal(-75123905439571256L,

                             CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L)));

         }

 

-        [TestMethod]

+        [Fact]

         public void TestNegativeEnumNoTag()

         {

-            Assert.AreEqual(10, CodedOutputStream.ComputeInt32SizeNoTag(-2));

-            Assert.AreEqual(10, CodedOutputStream.ComputeEnumSizeNoTag(-2));

+            Assert.Equal(10, CodedOutputStream.ComputeInt32SizeNoTag(-2));

+            Assert.Equal(10, CodedOutputStream.ComputeEnumSizeNoTag(-2));

 

             byte[] bytes = new byte[10];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

             output.WriteEnumNoTag(-2);

 

-            Assert.AreEqual(0, output.SpaceLeft);

-            Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));

+            Assert.Equal(0, output.SpaceLeft);

+            Assert.Equal("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));

         }

 

-        [TestMethod]

+        [Fact]

         public void TestNegativeEnumWithTag()

         {

-            Assert.AreEqual(11, CodedOutputStream.ComputeInt32Size(8, -2));

-            Assert.AreEqual(11, CodedOutputStream.ComputeEnumSize(8, -2));

+            Assert.Equal(11, CodedOutputStream.ComputeInt32Size(8, -2));

+            Assert.Equal(11, CodedOutputStream.ComputeEnumSize(8, -2));

 

             byte[] bytes = new byte[11];

             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

             output.WriteEnum(8, "", -2, -2);

 

-            Assert.AreEqual(0, output.SpaceLeft);

+            Assert.Equal(0, output.SpaceLeft);

             //fyi, 0x40 == 0x08 << 3 + 0, field num + wire format shift

-            Assert.AreEqual("40-FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));

+            Assert.Equal("40-FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));

         }

 

-        [TestMethod]

+        [Fact]

         public void TestNegativeEnumArrayPacked()

         {

             int arraySize = 1 + (10 * 5);

@@ -329,22 +328,22 @@ namespace Google.ProtocolBuffers
             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

             output.WritePackedEnumArray(8, "", arraySize, new int[] { 0, -1, -2, -3, -4, -5 });

 

-            Assert.AreEqual(0, output.SpaceLeft);

+            Assert.Equal(0, output.SpaceLeft);

 

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

             uint tag;

             string name;

-            Assert.IsTrue(input.ReadTag(out tag, out name));

+            Assert.True(input.ReadTag(out tag, out name));

 

             List<int> values = new List<int>();

             input.ReadInt32Array(tag, name, values);

 

-            Assert.AreEqual(6, values.Count);

+            Assert.Equal(6, values.Count);

             for (int i = 0; i > -6; i--)

-                Assert.AreEqual(i, values[Math.Abs(i)]);

+                Assert.Equal(i, values[Math.Abs(i)]);

         }

 

-        [TestMethod]

+        [Fact]

         public void TestNegativeEnumArray()

         {

             int arraySize = 1 + 1 + (11 * 5);

@@ -353,22 +352,22 @@ namespace Google.ProtocolBuffers
             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

             output.WriteEnumArray(8, "", new int[] { 0, -1, -2, -3, -4, -5 });

 

-            Assert.AreEqual(0, output.SpaceLeft);

+            Assert.Equal(0, output.SpaceLeft);

 

             CodedInputStream input = CodedInputStream.CreateInstance(bytes);

             uint tag;

             string name;

-            Assert.IsTrue(input.ReadTag(out tag, out name));

+            Assert.True(input.ReadTag(out tag, out name));

 

             List<int> values = new List<int>();

             input.ReadInt32Array(tag, name, values);

 

-            Assert.AreEqual(6, values.Count);

+            Assert.Equal(6, values.Count);

             for (int i = 0; i > -6; i--)

-                Assert.AreEqual(i, values[Math.Abs(i)]);

+                Assert.Equal(i, values[Math.Abs(i)]);

         }

 

-        [TestMethod]

+        [Fact]

         public void TestCodedInputOutputPosition()

         {

             byte[] content = new byte[110];

@@ -381,19 +380,19 @@ namespace Google.ProtocolBuffers
                 CodedOutputStream cout = CodedOutputStream.CreateInstance(ms, 20);

                 // Field 11: numeric value: 500

                 cout.WriteTag(11, WireFormat.WireType.Varint);

-                Assert.AreEqual(1, cout.Position);

+                Assert.Equal(1, cout.Position);

                 cout.WriteInt32NoTag(500);

-                Assert.AreEqual(3, cout.Position);

+                Assert.Equal(3, cout.Position);

                 //Field 12: length delimited 120 bytes

                 cout.WriteTag(12, WireFormat.WireType.LengthDelimited);

-                Assert.AreEqual(4, cout.Position);

+                Assert.Equal(4, cout.Position);

                 cout.WriteBytesNoTag(ByteString.CopyFrom(content));

-                Assert.AreEqual(115, cout.Position);

+                Assert.Equal(115, cout.Position);

                 // Field 13: fixed numeric value: 501

                 cout.WriteTag(13, WireFormat.WireType.Fixed32);

-                Assert.AreEqual(116, cout.Position);

+                Assert.Equal(116, cout.Position);

                 cout.WriteSFixed32NoTag(501);

-                Assert.AreEqual(120, cout.Position);

+                Assert.Equal(120, cout.Position);

                 cout.Flush();

             }

 

@@ -402,19 +401,19 @@ namespace Google.ProtocolBuffers
                 CodedOutputStream cout = CodedOutputStream.CreateInstance(bytes);

                 // Field 1: numeric value: 500

                 cout.WriteTag(1, WireFormat.WireType.Varint);

-                Assert.AreEqual(1, cout.Position);

+                Assert.Equal(1, cout.Position);

                 cout.WriteInt32NoTag(500);

-                Assert.AreEqual(3, cout.Position);

+                Assert.Equal(3, cout.Position);

                 //Field 2: length delimited 120 bytes

                 cout.WriteTag(2, WireFormat.WireType.LengthDelimited);

-                Assert.AreEqual(4, cout.Position);

+                Assert.Equal(4, cout.Position);

                 cout.WriteBytesNoTag(ByteString.CopyFrom(child));

-                Assert.AreEqual(125, cout.Position);

+                Assert.Equal(125, cout.Position);

                 // Field 3: fixed numeric value: 500

                 cout.WriteTag(3, WireFormat.WireType.Fixed32);

-                Assert.AreEqual(126, cout.Position);

+                Assert.Equal(126, cout.Position);

                 cout.WriteSFixed32NoTag(501);

-                Assert.AreEqual(130, cout.Position);

+                Assert.Equal(130, cout.Position);

                 cout.Flush();

             }

             //Now test Input stream:

@@ -423,49 +422,49 @@ namespace Google.ProtocolBuffers
                 uint tag;

                 int intValue = 0;

                 string ignore;

-                Assert.AreEqual(0, cin.Position);

+                Assert.Equal(0, cin.Position);

                 // Field 1:

-                Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 1);

-                Assert.AreEqual(1, cin.Position);

-                Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500);

-                Assert.AreEqual(3, cin.Position);

+                Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 1);

+                Assert.Equal(1, cin.Position);

+                Assert.True(cin.ReadInt32(ref intValue) && intValue == 500);

+                Assert.Equal(3, cin.Position);

                 //Field 2:

-                Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 2);

-                Assert.AreEqual(4, cin.Position);

+                Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 2);

+                Assert.Equal(4, cin.Position);

                 uint childlen = cin.ReadRawVarint32();

-                Assert.AreEqual(120u, childlen);

-                Assert.AreEqual(5, cin.Position);

+                Assert.Equal(120u, childlen);

+                Assert.Equal(5, cin.Position);

                 int oldlimit = cin.PushLimit((int)childlen);

-                Assert.AreEqual(5, cin.Position);

+                Assert.Equal(5, cin.Position);

                 // Now we are reading child message

                 {

                     // Field 11: numeric value: 500

-                    Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 11);

-                    Assert.AreEqual(6, cin.Position);

-                    Assert.IsTrue(cin.ReadInt32(ref intValue) && intValue == 500);

-                    Assert.AreEqual(8, cin.Position);

+                    Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 11);

+                    Assert.Equal(6, cin.Position);

+                    Assert.True(cin.ReadInt32(ref intValue) && intValue == 500);

+                    Assert.Equal(8, cin.Position);

                     //Field 12: length delimited 120 bytes

-                    Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 12);

-                    Assert.AreEqual(9, cin.Position);

+                    Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 12);

+                    Assert.Equal(9, cin.Position);

                     ByteString bstr = null;

-                    Assert.IsTrue(cin.ReadBytes(ref bstr) && bstr.Length == 110 && bstr.ToByteArray()[109] == 109);

-                    Assert.AreEqual(120, cin.Position);

+                    Assert.True(cin.ReadBytes(ref bstr) && bstr.Length == 110 && bstr.ToByteArray()[109] == 109);

+                    Assert.Equal(120, cin.Position);

                     // Field 13: fixed numeric value: 501

-                    Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 13);

+                    Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 13);

                     // ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit

-                    Assert.AreEqual(121, cin.Position);

-                    Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501);

-                    Assert.AreEqual(125, cin.Position);

-                    Assert.IsTrue(cin.IsAtEnd);

+                    Assert.Equal(121, cin.Position);

+                    Assert.True(cin.ReadSFixed32(ref intValue) && intValue == 501);

+                    Assert.Equal(125, cin.Position);

+                    Assert.True(cin.IsAtEnd);

                 }

                 cin.PopLimit(oldlimit);

-                Assert.AreEqual(125, cin.Position);

+                Assert.Equal(125, cin.Position);

                 // Field 3: fixed numeric value: 501

-                Assert.IsTrue(cin.ReadTag(out tag, out ignore) && tag >> 3 == 3);

-                Assert.AreEqual(126, cin.Position);

-                Assert.IsTrue(cin.ReadSFixed32(ref intValue) && intValue == 501);

-                Assert.AreEqual(130, cin.Position);

-                Assert.IsTrue(cin.IsAtEnd);

+                Assert.True(cin.ReadTag(out tag, out ignore) && tag >> 3 == 3);

+                Assert.Equal(126, cin.Position);

+                Assert.True(cin.ReadSFixed32(ref intValue) && intValue == 501);

+                Assert.Equal(130, cin.Position);

+                Assert.True(cin.IsAtEnd);

             }

         }

     }