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, 101 insertions, 171 deletions

diff --git a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
index b09d3340..20bfef9e 100644
--- a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs
@@ -39,12 +39,10 @@ using System.Collections.Generic;
 using System.IO;

 using Google.ProtocolBuffers.Descriptors;

 using Google.ProtocolBuffers.TestProtos;

-using Microsoft.VisualStudio.TestTools.UnitTesting;

-using System.Diagnostics;

+using Xunit;

 

 namespace Google.ProtocolBuffers

 {

-    [TestClass]

     public class CodedInputStreamTest

     {

         /// <summary>

@@ -68,21 +66,21 @@ namespace Google.ProtocolBuffers
         private static void AssertReadVarint(byte[] data, ulong value)

         {

             CodedInputStream input = CodedInputStream.CreateInstance(data);

-            Assert.AreEqual((uint) value, input.ReadRawVarint32());

+            Assert.Equal((uint) value, input.ReadRawVarint32());

 

             input = CodedInputStream.CreateInstance(data);

-            Assert.AreEqual(value, input.ReadRawVarint64());

-            Assert.IsTrue(input.IsAtEnd);

+            Assert.Equal(value, input.ReadRawVarint64());

+            Assert.True(input.IsAtEnd);

 

             // Try different block sizes.

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

             {

                 input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize));

-                Assert.AreEqual((uint) value, input.ReadRawVarint32());

+                Assert.Equal((uint) value, input.ReadRawVarint32());

 

                 input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize));

-                Assert.AreEqual(value, input.ReadRawVarint64());

-                Assert.IsTrue(input.IsAtEnd);

+                Assert.Equal(value, input.ReadRawVarint64());

+                Assert.True(input.IsAtEnd);

             }

 

             // Try reading directly from a MemoryStream. We want to verify that it

@@ -92,8 +90,8 @@ namespace Google.ProtocolBuffers
             memoryStream.Write(data, 0, data.Length);

             memoryStream.WriteByte(0);

             memoryStream.Position = 0;

-            Assert.AreEqual((uint) value, CodedInputStream.ReadRawVarint32(memoryStream));

-            Assert.AreEqual(data.Length, memoryStream.Position);

+            Assert.Equal((uint) value, CodedInputStream.ReadRawVarint32(memoryStream));

+            Assert.Equal(data.Length, memoryStream.Position);

         }

 

         /// <summary>

@@ -104,40 +102,19 @@ namespace Google.ProtocolBuffers
         private static void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data)

         {

             CodedInputStream input = CodedInputStream.CreateInstance(data);

-            try

-            {

-                input.ReadRawVarint32();

-                Assert.Fail("Should have thrown an exception.");

-            }

-            catch (InvalidProtocolBufferException e)

-            {

-                Assert.AreEqual(expected.Message, e.Message);

-            }

+            var exception = Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawVarint32());

+            Assert.Equal(expected.Message, exception.Message);

 

             input = CodedInputStream.CreateInstance(data);

-            try

-            {

-                input.ReadRawVarint64();

-                Assert.Fail("Should have thrown an exception.");

-            }

-            catch (InvalidProtocolBufferException e)

-            {

-                Assert.AreEqual(expected.Message, e.Message);

-            }

+            exception = Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawVarint64());

+            Assert.Equal(expected.Message, exception.Message);

 

             // Make sure we get the same error when reading directly from a Stream.

-            try

-            {

-                CodedInputStream.ReadRawVarint32(new MemoryStream(data));

-                Assert.Fail("Should have thrown an exception.");

-            }

-            catch (InvalidProtocolBufferException e)

-            {

-                Assert.AreEqual(expected.Message, e.Message);

-            }

+            exception = Assert.Throws<InvalidProtocolBufferException>(() => CodedInputStream.ReadRawVarint32(new MemoryStream(data)));

+            Assert.Equal(expected.Message, exception.Message);

         }

 

-        [TestMethod]

+        [Fact]

         public void ReadVarint()

         {

             AssertReadVarint(Bytes(0x00), 0);

@@ -182,16 +159,16 @@ namespace Google.ProtocolBuffers
         private static void AssertReadLittleEndian32(byte[] data, uint value)

         {

             CodedInputStream input = CodedInputStream.CreateInstance(data);

-            Assert.AreEqual(value, input.ReadRawLittleEndian32());

-            Assert.IsTrue(input.IsAtEnd);

+            Assert.Equal(value, input.ReadRawLittleEndian32());

+            Assert.True(input.IsAtEnd);

 

             // Try different block sizes.

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

             {

                 input = CodedInputStream.CreateInstance(

                     new SmallBlockInputStream(data, blockSize));

-                Assert.AreEqual(value, input.ReadRawLittleEndian32());

-                Assert.IsTrue(input.IsAtEnd);

+                Assert.Equal(value, input.ReadRawLittleEndian32());

+                Assert.True(input.IsAtEnd);

             }

         }

 

@@ -202,20 +179,20 @@ namespace Google.ProtocolBuffers
         private static void AssertReadLittleEndian64(byte[] data, ulong value)

         {

             CodedInputStream input = CodedInputStream.CreateInstance(data);

-            Assert.AreEqual(value, input.ReadRawLittleEndian64());

-            Assert.IsTrue(input.IsAtEnd);

+            Assert.Equal(value, input.ReadRawLittleEndian64());

+            Assert.True(input.IsAtEnd);

 

             // Try different block sizes.

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

             {

                 input = CodedInputStream.CreateInstance(

                     new SmallBlockInputStream(data, blockSize));

-                Assert.AreEqual(value, input.ReadRawLittleEndian64());

-                Assert.IsTrue(input.IsAtEnd);

+                Assert.Equal(value, input.ReadRawLittleEndian64());

+                Assert.True(input.IsAtEnd);

             }

         }

 

-        [TestMethod]

+        [Fact]

         public void ReadLittleEndian()

         {

             AssertReadLittleEndian32(Bytes(0x78, 0x56, 0x34, 0x12), 0x12345678);

@@ -227,41 +204,41 @@ namespace Google.ProtocolBuffers
                 Bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef012345678UL);

         }

 

-        [TestMethod]

+        [Fact]

         public void DecodeZigZag32()

         {

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

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

-            Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(2));

-            Assert.AreEqual(-2, CodedInputStream.DecodeZigZag32(3));

-            Assert.AreEqual(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE));

-            Assert.AreEqual(unchecked((int) 0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF));

-            Assert.AreEqual(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE));

-            Assert.AreEqual(unchecked((int) 0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF));

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

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

+            Assert.Equal(1, CodedInputStream.DecodeZigZag32(2));

+            Assert.Equal(-2, CodedInputStream.DecodeZigZag32(3));

+            Assert.Equal(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE));

+            Assert.Equal(unchecked((int) 0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF));

+            Assert.Equal(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE));

+            Assert.Equal(unchecked((int) 0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF));

         }

 

-        [TestMethod]

+        [Fact]

         public void DecodeZigZag64()

         {

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

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

-            Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(2));

-            Assert.AreEqual(-2, CodedInputStream.DecodeZigZag64(3));

-            Assert.AreEqual(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL));

-            Assert.AreEqual(unchecked((long) 0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL));

-            Assert.AreEqual(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL));

-            Assert.AreEqual(unchecked((long) 0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL));

-            Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL));

-            Assert.AreEqual(unchecked((long) 0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL));

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

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

+            Assert.Equal(1, CodedInputStream.DecodeZigZag64(2));

+            Assert.Equal(-2, CodedInputStream.DecodeZigZag64(3));

+            Assert.Equal(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL));

+            Assert.Equal(unchecked((long) 0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL));

+            Assert.Equal(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL));

+            Assert.Equal(unchecked((long) 0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL));

+            Assert.Equal(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL));

+            Assert.Equal(unchecked((long) 0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL));

         }

 

-        [TestMethod]

+        [Fact]

         public void ReadWholeMessage()

         {

             TestAllTypes message = TestUtil.GetAllSet();

 

             byte[] rawBytes = message.ToByteArray();

-            Assert.AreEqual(rawBytes.Length, message.SerializedSize);

+            Assert.Equal(rawBytes.Length, message.SerializedSize);

             TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);

             TestUtil.AssertAllFieldsSet(message2);

 

@@ -273,7 +250,7 @@ namespace Google.ProtocolBuffers
             }

         }

 

-        [TestMethod]

+        [Fact]

         public void SkipWholeMessage()

         {

             TestAllTypes message = TestUtil.GetAllSet();

@@ -290,8 +267,8 @@ namespace Google.ProtocolBuffers
             while (input1.ReadTag(out tag, out name))

             {

                 uint tag2;

-                Assert.IsTrue(input2.ReadTag(out tag2, out name));

-                Assert.AreEqual(tag, tag2);

+                Assert.True(input2.ReadTag(out tag2, out name));

+                Assert.Equal(tag, tag2);

 

                 unknownFields.MergeFieldFrom(tag, input1);

                 input2.SkipField();

@@ -302,7 +279,7 @@ namespace Google.ProtocolBuffers
         /// Test that a bug in SkipRawBytes has been fixed: if the skip

         /// skips exactly up to a limit, this should bnot break things

         /// </summary>

-        [TestMethod]

+        [Fact]

         public void SkipRawBytesBug()

         {

             byte[] rawBytes = new byte[] {1, 2};

@@ -311,7 +288,7 @@ namespace Google.ProtocolBuffers
             int limit = input.PushLimit(1);

             input.SkipRawBytes(1);

             input.PopLimit(limit);

-            Assert.AreEqual(2, input.ReadRawByte());

+            Assert.Equal(2, input.ReadRawByte());

         }

 

         public void ReadHugeBlob()

@@ -334,7 +311,7 @@ namespace Google.ProtocolBuffers
             // reading.

             TestAllTypes message2 = TestAllTypes.ParseFrom(message.ToByteString().CreateCodedInput());

 

-            Assert.AreEqual(message.OptionalBytes, message2.OptionalBytes);

+            Assert.Equal(message.OptionalBytes, message2.OptionalBytes);

 

             // Make sure all the other fields were parsed correctly.

             TestAllTypes message3 = TestAllTypes.CreateBuilder(message2)

@@ -343,7 +320,7 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertAllFieldsSet(message3);

         }

 

-        [TestMethod]

+        [Fact]

         public void ReadMaliciouslyLargeBlob()

         {

             MemoryStream ms = new MemoryStream();

@@ -359,19 +336,12 @@ namespace Google.ProtocolBuffers
             CodedInputStream input = CodedInputStream.CreateInstance(ms);

             uint testtag;

             string ignore;

-            Assert.IsTrue(input.ReadTag(out testtag, out ignore));

-            Assert.AreEqual(tag, testtag);

+            Assert.True(input.ReadTag(out testtag, out ignore));

+            Assert.Equal(tag, testtag);

 

-            try

-            {

-                ByteString bytes = null;

-                input.ReadBytes(ref bytes);

-                Assert.Fail("Should have thrown an exception!");

-            }

-            catch (InvalidProtocolBufferException)

-            {

-                // success.

-            }

+            ByteString bytes = null;

+            // TODO(jonskeet): Should this be ArgumentNullException instead?

+            Assert.Throws<InvalidProtocolBufferException>(() => input.ReadBytes(ref bytes));

         }

 

         private static TestRecursiveMessage MakeRecursiveMessage(int depth)

@@ -391,17 +361,17 @@ namespace Google.ProtocolBuffers
         {

             if (depth == 0)

             {

-                Assert.IsFalse(message.HasA);

-                Assert.AreEqual(5, message.I);

+                Assert.False(message.HasA);

+                Assert.Equal(5, message.I);

             }

             else

             {

-                Assert.IsTrue(message.HasA);

+                Assert.True(message.HasA);

                 AssertMessageDepth(message.A, depth - 1);

             }

         }

 

-        [TestMethod]

+        [Fact]

         public void MaliciousRecursion()

         {

             ByteString data64 = MakeRecursiveMessage(64).ToByteString();

@@ -409,30 +379,14 @@ namespace Google.ProtocolBuffers
 

             AssertMessageDepth(TestRecursiveMessage.ParseFrom(data64), 64);

 

-            try

-            {

-                TestRecursiveMessage.ParseFrom(data65);

-                Assert.Fail("Should have thrown an exception!");

-            }

-            catch (InvalidProtocolBufferException)

-            {

-                // success.

-            }

+            Assert.Throws<InvalidProtocolBufferException>(() => TestRecursiveMessage.ParseFrom(data65));

 

             CodedInputStream input = data64.CreateCodedInput();

             input.SetRecursionLimit(8);

-            try

-            {

-                TestRecursiveMessage.ParseFrom(input);

-                Assert.Fail("Should have thrown an exception!");

-            }

-            catch (InvalidProtocolBufferException)

-            {

-                // success.

-            }

+            Assert.Throws<InvalidProtocolBufferException>(() => TestRecursiveMessage.ParseFrom(input));

         }

 

-        [TestMethod]

+        [Fact]

         public void SizeLimit()

         {

             // Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't

@@ -441,18 +395,10 @@ namespace Google.ProtocolBuffers
             CodedInputStream input = CodedInputStream.CreateInstance(ms);

             input.SetSizeLimit(16);

 

-            try

-            {

-                TestAllTypes.ParseFrom(input);

-                Assert.Fail("Should have thrown an exception!");

-            }

-            catch (InvalidProtocolBufferException)

-            {

-                // success.

-            }

+            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.ParseFrom(input));

         }

 

-        [TestMethod]

+        [Fact]

         public void ResetSizeCounter()

         {

             CodedInputStream input = CodedInputStream.CreateInstance(

@@ -460,28 +406,12 @@ namespace Google.ProtocolBuffers
             input.SetSizeLimit(16);

             input.ReadRawBytes(16);

 

-            try

-            {

-                input.ReadRawByte();

-                Assert.Fail("Should have thrown an exception!");

-            }

-            catch (InvalidProtocolBufferException)

-            {

-                // Success.

-            }

+            Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawByte());

 

             input.ResetSizeCounter();

             input.ReadRawByte(); // No exception thrown.

 

-            try

-            {

-                input.ReadRawBytes(16); // Hits limit again.

-                Assert.Fail("Should have thrown an exception!");

-            }

-            catch (InvalidProtocolBufferException)

-            {

-                // Success.

-            }

+            Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawBytes(16));

         }

 

         /// <summary>

@@ -489,7 +419,7 @@ namespace Google.ProtocolBuffers
         /// is thrown.  Instead, the invalid bytes are replaced with the Unicode

         /// "replacement character" U+FFFD.

         /// </summary>

-        [TestMethod]

+        [Fact]

         public void ReadInvalidUtf8()

         {

             MemoryStream ms = new MemoryStream();

@@ -507,11 +437,11 @@ namespace Google.ProtocolBuffers
             uint testtag;

             string ignored;

 

-            Assert.IsTrue(input.ReadTag(out testtag, out ignored));

-            Assert.AreEqual(tag, testtag);

+            Assert.True(input.ReadTag(out testtag, out ignored));

+            Assert.Equal(tag, testtag);

             string text = null;

             input.ReadString(ref text);

-            Assert.AreEqual('\ufffd', text[0]);

+            Assert.Equal('\ufffd', text[0]);

         }

 

         /// <summary>

@@ -537,7 +467,7 @@ namespace Google.ProtocolBuffers
 

         enum TestNegEnum { None = 0, Value = -2 }

 

-        [TestMethod]

+        [Fact]

         public void TestNegativeEnum()

         {

             byte[] bytes = new byte[10] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };

@@ -545,12 +475,12 @@ namespace Google.ProtocolBuffers
             object unk;

             TestNegEnum val = TestNegEnum.None;

 

-            Assert.IsTrue(input.ReadEnum(ref val, out unk));

-            Assert.IsTrue(input.IsAtEnd);

-            Assert.AreEqual(TestNegEnum.Value, val);

+            Assert.True(input.ReadEnum(ref val, out unk));

+            Assert.True(input.IsAtEnd);

+            Assert.Equal(TestNegEnum.Value, val);

         }

 

-        [TestMethod]

+        [Fact]

         public void TestNegativeEnumPackedArray()

         {

             int arraySize = 1 + (10 * 5);

@@ -559,26 +489,26 @@ namespace Google.ProtocolBuffers
             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

             output.WritePackedInt32Array(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<TestNegEnum> values = new List<TestNegEnum>();

             ICollection<object> unk;

             input.ReadEnumArray(tag, name, values, out unk);

 

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

-            Assert.AreEqual(TestNegEnum.None, values[0]);

-            Assert.AreEqual(TestNegEnum.Value, values[1]);

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

+            Assert.Equal(TestNegEnum.None, values[0]);

+            Assert.Equal(TestNegEnum.Value, values[1]);

 

-            Assert.IsNotNull(unk);

-            Assert.AreEqual(4, unk.Count);

+            Assert.NotNull(unk);

+            Assert.Equal(4, unk.Count);

         }

 

-        [TestMethod]

+        [Fact]

         public void TestNegativeEnumArray()

         {

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

@@ -587,27 +517,27 @@ namespace Google.ProtocolBuffers
             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);

             output.WriteInt32Array(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<TestNegEnum> values = new List<TestNegEnum>();

             ICollection<object> unk;

             input.ReadEnumArray(tag, name, values, out unk);

 

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

-            Assert.AreEqual(TestNegEnum.None, values[0]);

-            Assert.AreEqual(TestNegEnum.Value, values[1]);

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

+            Assert.Equal(TestNegEnum.None, values[0]);

+            Assert.Equal(TestNegEnum.Value, values[1]);

 

-            Assert.IsNotNull(unk);

-            Assert.AreEqual(4, unk.Count);

+            Assert.NotNull(unk);

+            Assert.Equal(4, unk.Count);

         }

 

         //Issue 71:	CodedInputStream.ReadBytes go to slow path unnecessarily

-        [TestMethod]

+        [Fact]

         public void TestSlowPathAvoidance()

         {

             using (var ms = new MemoryStream())

@@ -624,15 +554,15 @@ namespace Google.ProtocolBuffers
                 string ignore;

                 ByteString value;

 

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

-                Assert.AreEqual(1, WireFormat.GetTagFieldNumber(tag));

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

+                Assert.Equal(1, WireFormat.GetTagFieldNumber(tag));

                 value = ByteString.Empty;

-                Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100);

+                Assert.True(input.ReadBytes(ref value) && value.Length == 100);

 

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

-                Assert.AreEqual(2, WireFormat.GetTagFieldNumber(tag));

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

+                Assert.Equal(2, WireFormat.GetTagFieldNumber(tag));

                 value = ByteString.Empty;

-                Assert.IsTrue(input.ReadBytes(ref value) && value.Length == 100);

+                Assert.True(input.ReadBytes(ref value) && value.Length == 100);

             }

         }

     }