Convert back to using NUnit, which is now loaded via NuGet.

This includes the NUnit test adapter which allows NUnit tests to be run under VS without any extra plugins.
Unfortunate the compatibility tests using the abstract test fixture class show up as "external" tests, and aren't well presented - but they do run.

1 files changed, 53 insertions, 53 deletions

diff --git a/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs b/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs
index 5caa2e23..da0d9eef 100644
--- a/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs
+++ b/csharp/src/ProtocolBuffers.Test/TestMimeMessageFormats.cs
@@ -5,7 +5,7 @@ using System.Text;
 using Google.ProtocolBuffers.Serialization;

 using Google.ProtocolBuffers.Serialization.Http;

 using Google.ProtocolBuffers.TestProtos;

-using Xunit;

+using NUnit.Framework;

 

 namespace Google.ProtocolBuffers

 {

@@ -16,91 +16,91 @@ namespace Google.ProtocolBuffers
         readonly IEnumerable<string> XmlTypes = new string[] { "text/xml", "application/xml" };

         readonly IEnumerable<string> ProtobufTypes = new string[] { "application/binary", "application/x-protobuf", "application/vnd.google.protobuf" };

 

-        [Fact]

+        [Test]

         public void TestReadJsonMimeTypes()

         {

             foreach (string type in JsonTypes)

             {

-                Assert.True(

+                Assert.IsTrue(

                     MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null)

                     is JsonFormatReader);

             }

-            Assert.True(

+            Assert.IsTrue(

                 MessageFormatFactory.CreateInputStream(new MessageFormatOptions() { DefaultContentType = "application/json" }, null, Stream.Null)

                 is JsonFormatReader);

         }

 

-        [Fact]

+        [Test]

         public void TestWriteJsonMimeTypes()

         {

             foreach (string type in JsonTypes)

             {

-                Assert.True(

+                Assert.IsTrue(

                     MessageFormatFactory.CreateOutputStream(new MessageFormatOptions(), type, Stream.Null)

                     is JsonFormatWriter);

             }

-            Assert.True(

+            Assert.IsTrue(

                 MessageFormatFactory.CreateOutputStream(new MessageFormatOptions() { DefaultContentType = "application/json" }, null, Stream.Null)

                 is JsonFormatWriter);

         }

 

-        [Fact]

+        [Test]

         public void TestReadXmlMimeTypes()

         {

             foreach (string type in XmlTypes)

             {

-                Assert.True(

+                Assert.IsTrue(

                     MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null)

                     is XmlFormatReader);

             }

-            Assert.True(

+            Assert.IsTrue(

                 MessageFormatFactory.CreateInputStream(new MessageFormatOptions() { DefaultContentType = "application/xml" }, null, Stream.Null)

                 is XmlFormatReader);

         }

 

-        [Fact]

+        [Test]

         public void TestWriteXmlMimeTypes()

         {

             foreach (string type in XmlTypes)

             {

-                Assert.True(

+                Assert.IsTrue(

                     MessageFormatFactory.CreateOutputStream(new MessageFormatOptions(), type, Stream.Null)

                     is XmlFormatWriter);

             }

-            Assert.True(

+            Assert.IsTrue(

                 MessageFormatFactory.CreateOutputStream(new MessageFormatOptions() { DefaultContentType = "application/xml" }, null, Stream.Null)

                 is XmlFormatWriter);

         }

 

-        [Fact]

+        [Test]

         public void TestReadProtoMimeTypes()

         {

             foreach (string type in ProtobufTypes)

             {

-                Assert.True(

+                Assert.IsTrue(

                     MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null)

                     is CodedInputStream);

             }

-            Assert.True(

+            Assert.IsTrue(

                 MessageFormatFactory.CreateInputStream(new MessageFormatOptions() { DefaultContentType = "application/vnd.google.protobuf" }, null, Stream.Null)

                 is CodedInputStream);

         }

 

-        [Fact]

+        [Test]

         public void TestWriteProtoMimeTypes()

         {

             foreach (string type in ProtobufTypes)

             {

-                Assert.True(

+                Assert.IsTrue(

                     MessageFormatFactory.CreateOutputStream(new MessageFormatOptions(), type, Stream.Null)

                     is CodedOutputStream);

             }

-            Assert.True(

+            Assert.IsTrue(

                 MessageFormatFactory.CreateOutputStream(new MessageFormatOptions() { DefaultContentType = "application/vnd.google.protobuf" }, null, Stream.Null)

                 is CodedOutputStream);

         }

 

-        [Fact]

+        [Test]

         public void TestMergeFromJsonType()

         {

             TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(),

@@ -108,11 +108,11 @@ namespace Google.ProtocolBuffers
                     Extensions.ToJson(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build())

                     )))

                 .Build();

-            Assert.Equal("a", msg.Text);

-            Assert.Equal(1, msg.Number);

+            Assert.AreEqual("a", msg.Text);

+            Assert.AreEqual(1, msg.Number);

         }

 

-        [Fact]

+        [Test]

         public void TestMergeFromXmlType()

         {

             TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(),

@@ -120,10 +120,10 @@ namespace Google.ProtocolBuffers
                     Extensions.ToXml(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build())

                     )))

                 .Build();

-            Assert.Equal("a", msg.Text);

-            Assert.Equal(1, msg.Number);

+            Assert.AreEqual("a", msg.Text);

+            Assert.AreEqual(1, msg.Number);

         }

-        [Fact]

+        [Test]

         public void TestMergeFromProtoType()

         {

             TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(),

@@ -131,30 +131,30 @@ namespace Google.ProtocolBuffers
                     TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build().ToByteArray()

                     ))

                 .Build();

-            Assert.Equal("a", msg.Text);

-            Assert.Equal(1, msg.Number);

+            Assert.AreEqual("a", msg.Text);

+            Assert.AreEqual(1, msg.Number);

         }

 

-        [Fact]

+        [Test]

         public void TestWriteToJsonType()

         {

             MemoryStream ms = new MemoryStream();

             Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(),

                 new MessageFormatOptions(), "application/json", ms);

 

-            Assert.Equal(@"{""text"":""a"",""number"":1}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

+            Assert.AreEqual(@"{""text"":""a"",""number"":1}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

         }

 

-        [Fact]

+        [Test]

         public void TestWriteToXmlType()

         {

             MemoryStream ms = new MemoryStream();

             Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(),

                 new MessageFormatOptions(), "application/xml", ms);

 

-            Assert.Equal("<root><text>a</text><number>1</number></root>", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

+            Assert.AreEqual("<root><text>a</text><number>1</number></root>", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

         }

-        [Fact]

+        [Test]

         public void TestWriteToProtoType()

         {

             MemoryStream ms = new MemoryStream();

@@ -162,10 +162,10 @@ namespace Google.ProtocolBuffers
                 new MessageFormatOptions(), "application/vnd.google.protobuf", ms);

 

             byte[] bytes = TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build().ToByteArray();

-            Assert.Equal(bytes, ms.ToArray());

+            Assert.AreEqual(bytes, ms.ToArray());

         }

 

-        [Fact]

+        [Test]

         public void TestXmlReaderOptions()

         {

             MemoryStream ms = new MemoryStream();

@@ -184,13 +184,13 @@ namespace Google.ProtocolBuffers
                 options, "application/xml", ms)

                 .Build();

 

-            Assert.Equal("a", msg.Text);

-            Assert.Equal(1, msg.NumbersList[0]);

-            Assert.Equal(2, msg.NumbersList[1]);

+            Assert.AreEqual("a", msg.Text);

+            Assert.AreEqual(1, msg.NumbersList[0]);

+            Assert.AreEqual(2, msg.NumbersList[1]);

 

         }

 

-        [Fact]

+        [Test]

         public void TestXmlWriterOptions()

         {

             TestXmlMessage message = TestXmlMessage.CreateBuilder().SetText("a").AddNumbers(1).AddNumbers(2).Build();

@@ -209,32 +209,32 @@ namespace Google.ProtocolBuffers
                 .SetOptions(XmlReaderOptions.ReadNestedArrays)

                 .Merge("root-node", builder);

 

-            Assert.Equal("a", builder.Text);

-            Assert.Equal(1, builder.NumbersList[0]);

-            Assert.Equal(2, builder.NumbersList[1]);

+            Assert.AreEqual("a", builder.Text);

+            Assert.AreEqual(1, builder.NumbersList[0]);

+            Assert.AreEqual(2, builder.NumbersList[1]);

         }

 

-        [Fact]

+        [Test]

         public void TestJsonFormatted()

         {

             MemoryStream ms = new MemoryStream();

             Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(),

                 new MessageFormatOptions() { FormattedOutput = true }, "application/json", ms);

 

-            Assert.Equal("{\r\n    \"text\": \"a\",\r\n    \"number\": 1\r\n}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

+            Assert.AreEqual("{\r\n    \"text\": \"a\",\r\n    \"number\": 1\r\n}", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

         }

 

-        [Fact]

+        [Test]

         public void TestXmlFormatted()

         {

             MemoryStream ms = new MemoryStream();

             Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(),

                 new MessageFormatOptions() { FormattedOutput = true }, "application/xml", ms);

 

-            Assert.Equal("<root>\r\n    <text>a</text>\r\n    <number>1</number>\r\n</root>", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

+            Assert.AreEqual("<root>\r\n    <text>a</text>\r\n    <number>1</number>\r\n</root>", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

         }

 

-        [Fact]

+        [Test]

         public void TestReadCustomMimeTypes()

         {

             var options = new MessageFormatOptions();

@@ -242,7 +242,7 @@ namespace Google.ProtocolBuffers
             options.MimeInputTypes.Clear();

             //Add our own

             options.MimeInputTypes.Add("-custom-XML-mime-type-", XmlFormatReader.CreateInstance);

-            Assert.Equal(1, options.MimeInputTypes.Count);

+            Assert.AreEqual(1, options.MimeInputTypes.Count);

 

             Stream xmlStream = new MemoryStream(Encoding.UTF8.GetBytes(

                 Extensions.ToXml(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build())

@@ -251,11 +251,11 @@ namespace Google.ProtocolBuffers
             TestXmlMessage msg = Extensions.MergeFrom(new TestXmlMessage.Builder(),

                 options, "-custom-XML-mime-type-", xmlStream)

                 .Build();

-            Assert.Equal("a", msg.Text);

-            Assert.Equal(1, msg.Number);

+            Assert.AreEqual("a", msg.Text);

+            Assert.AreEqual(1, msg.Number);

         }

 

-        [Fact]

+        [Test]

         public void TestWriteToCustomType()

         {

             var options = new MessageFormatOptions();

@@ -264,13 +264,13 @@ namespace Google.ProtocolBuffers
             //Add our own

             options.MimeOutputTypes.Add("-custom-XML-mime-type-", XmlFormatWriter.CreateInstance);

             

-            Assert.Equal(1, options.MimeOutputTypes.Count);

+            Assert.AreEqual(1, options.MimeOutputTypes.Count);

 

             MemoryStream ms = new MemoryStream();

             Extensions.WriteTo(TestXmlMessage.CreateBuilder().SetText("a").SetNumber(1).Build(),

                 options, "-custom-XML-mime-type-", ms);

 

-            Assert.Equal("<root><text>a</text><number>1</number></root>", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

+            Assert.AreEqual("<root><text>a</text><number>1</number></root>", Encoding.UTF8.GetString(ms.ToArray(), 0, (int)ms.Length));

         }

     }

 }
\ No newline at end of file