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, 61 insertions, 61 deletions

diff --git a/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs b/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
index e0199202..f5932ab3 100644
--- a/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
+++ b/csharp/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
@@ -36,13 +36,13 @@
 

 using System.IO;

 using Google.ProtocolBuffers.TestProtos;

-using Xunit;

+using NUnit.Framework;

 

 namespace Google.ProtocolBuffers

 {

     public class AbstractBuilderLiteTest

     {

-        [Fact]

+        [Test]

         public void TestMergeFromCodedInputStream()

         {

             TestAllTypesLite copy,

@@ -50,7 +50,7 @@ namespace Google.ProtocolBuffers
                                  .SetOptionalUint32(uint.MaxValue).Build();

 

             copy = TestAllTypesLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             using (MemoryStream ms = new MemoryStream(msg.ToByteArray()))

             {

@@ -58,22 +58,22 @@ namespace Google.ProtocolBuffers
                 copy = copy.ToBuilder().MergeFrom(ci).Build();

             }

 

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakClear()

         {

             TestAllTypesLite copy, msg = TestAllTypesLite.DefaultInstance;

 

             copy = msg.ToBuilder().SetOptionalString("Should be removed.").Build();

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakClear().WeakBuild();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestBuilderLiteMergeFromCodedInputStream()

         {

             TestAllTypesLite copy,

@@ -81,14 +81,14 @@ namespace Google.ProtocolBuffers
                                  .SetOptionalString("Should be merged.").Build();

 

             copy = TestAllTypesLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             copy =

                 copy.ToBuilder().MergeFrom(CodedInputStream.CreateInstance(new MemoryStream(msg.ToByteArray()))).Build();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestBuilderLiteMergeDelimitedFrom()

         {

             TestAllTypesLite copy,

@@ -96,15 +96,15 @@ namespace Google.ProtocolBuffers
                                  .SetOptionalString("Should be merged.").Build();

 

             copy = TestAllTypesLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

             Stream s = new MemoryStream();

             msg.WriteDelimitedTo(s);

             s.Position = 0;

             copy = copy.ToBuilder().MergeDelimitedFrom(s).Build();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestBuilderLiteMergeDelimitedFromExtensions()

         {

             TestAllExtensionsLite copy,

@@ -113,7 +113,7 @@ namespace Google.ProtocolBuffers
                                                     "Should be merged.").Build();

 

             copy = TestAllExtensionsLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             Stream s = new MemoryStream();

             msg.WriteDelimitedTo(s);

@@ -123,11 +123,11 @@ namespace Google.ProtocolBuffers
             UnittestLite.RegisterAllExtensions(registry);

 

             copy = copy.ToBuilder().MergeDelimitedFrom(s, registry).Build();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

-            Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));

         }

 

-        [Fact]

+        [Test]

         public void TestBuilderLiteMergeFromStream()

         {

             TestAllTypesLite copy,

@@ -135,15 +135,15 @@ namespace Google.ProtocolBuffers
                                  .SetOptionalString("Should be merged.").Build();

 

             copy = TestAllTypesLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

             Stream s = new MemoryStream();

             msg.WriteTo(s);

             s.Position = 0;

             copy = copy.ToBuilder().MergeFrom(s).Build();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestBuilderLiteMergeFromStreamExtensions()

         {

             TestAllExtensionsLite copy,

@@ -152,7 +152,7 @@ namespace Google.ProtocolBuffers
                                                     "Should be merged.").Build();

 

             copy = TestAllExtensionsLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             Stream s = new MemoryStream();

             msg.WriteTo(s);

@@ -162,11 +162,11 @@ namespace Google.ProtocolBuffers
             UnittestLite.RegisterAllExtensions(registry);

 

             copy = copy.ToBuilder().MergeFrom(s, registry).Build();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

-            Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakMergeFromIMessageLite()

         {

             TestAllTypesLite copy,

@@ -174,13 +174,13 @@ namespace Google.ProtocolBuffers
                                  .SetOptionalString("Should be merged.").Build();

 

             copy = TestAllTypesLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom((IMessageLite) msg).WeakBuild();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakMergeFromByteString()

         {

             TestAllTypesLite copy,

@@ -188,13 +188,13 @@ namespace Google.ProtocolBuffers
                                  .SetOptionalString("Should be merged.").Build();

 

             copy = TestAllTypesLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString()).WeakBuild();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakMergeFromByteStringExtensions()

         {

             TestAllExtensionsLite copy,

@@ -203,12 +203,12 @@ namespace Google.ProtocolBuffers
                                                     "Should be merged.").Build();

 

             copy = TestAllExtensionsLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             copy =

                 (TestAllExtensionsLite)

                 ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), ExtensionRegistry.Empty).WeakBuild();

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

             UnittestLite.RegisterAllExtensions(registry);

@@ -216,11 +216,11 @@ namespace Google.ProtocolBuffers
             copy =

                 (TestAllExtensionsLite)

                 ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), registry).WeakBuild();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

-            Assert.Equal("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual("Should be merged.", copy.GetExtension(UnittestLite.OptionalStringExtensionLite));

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakMergeFromCodedInputStream()

         {

             TestAllTypesLite copy,

@@ -228,7 +228,7 @@ namespace Google.ProtocolBuffers
                                  .SetOptionalUint32(uint.MaxValue).Build();

 

             copy = TestAllTypesLite.DefaultInstance;

-            Assert.NotEqual(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());

 

             using (MemoryStream ms = new MemoryStream(msg.ToByteArray()))

             {

@@ -236,58 +236,58 @@ namespace Google.ProtocolBuffers
                 copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(ci).WeakBuild();

             }

 

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakBuildPartial()

         {

             IBuilderLite builder = TestRequiredLite.CreateBuilder();

-            Assert.False(builder.IsInitialized);

+            Assert.IsFalse(builder.IsInitialized);

 

             IMessageLite msg = builder.WeakBuildPartial();

-            Assert.False(msg.IsInitialized);

+            Assert.IsFalse(msg.IsInitialized);

 

-            Assert.Equal(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakBuildUninitialized()

         {

             IBuilderLite builder = TestRequiredLite.CreateBuilder();

-            Assert.False(builder.IsInitialized);

+            Assert.IsFalse(builder.IsInitialized);

             Assert.Throws<UninitializedMessageException>(() => builder.WeakBuild());

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakBuild()

         {

             IBuilderLite builder = TestRequiredLite.CreateBuilder()

                 .SetD(0)

                 .SetEn(ExtraEnum.EXLITE_BAZ);

-            Assert.True(builder.IsInitialized);

+            Assert.IsTrue(builder.IsInitialized);

             builder.WeakBuild();

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakClone()

         {

             TestRequiredLite msg = TestRequiredLite.CreateBuilder()

                 .SetD(1).SetEn(ExtraEnum.EXLITE_BAR).Build();

-            Assert.True(msg.IsInitialized);

+            Assert.IsTrue(msg.IsInitialized);

 

             IMessageLite copy = ((IBuilderLite) msg.ToBuilder()).WeakClone().WeakBuild();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

-        [Fact]

+        [Test]

         public void TestIBuilderLiteWeakDefaultInstance()

         {

-            Assert.True(ReferenceEquals(TestRequiredLite.DefaultInstance,

+            Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance,

                                           ((IBuilderLite) TestRequiredLite.CreateBuilder()).WeakDefaultInstanceForType));

         }

 

-        [Fact]

+        [Test]

         public void TestGeneratedBuilderLiteAddRange()

         {

             TestAllTypesLite copy,

@@ -299,11 +299,11 @@ namespace Google.ProtocolBuffers
                                  .Build();

 

             copy = msg.DefaultInstanceForType.ToBuilder().MergeFrom(msg).Build();

-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());

+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());

         }

 

         // ROK 5/7/2013 Issue #54: should retire all bytes in buffer (bufferSize)

-        [Fact]

+        [Test]

         public void TestBufferRefillIssue()

         {

             var ms = new MemoryStream();

@@ -322,15 +322,15 @@ namespace Google.ProtocolBuffers
             var input = CodedInputStream.CreateInstance(ms);

             var builder = BucketOfBytes.CreateBuilder();

             input.ReadMessage(builder, ExtensionRegistry.Empty);

-            Assert.Equal(3005L, input.Position);

-            Assert.Equal(3000, builder.Value.Length);

+            Assert.AreEqual(3005L, input.Position);

+            Assert.AreEqual(3000, builder.Value.Length);

             input.ReadMessage(builder, ExtensionRegistry.Empty);

-            Assert.Equal(5114, input.Position);

-            Assert.Equal(1000, builder.Value.Length);

+            Assert.AreEqual(5114, input.Position);

+            Assert.AreEqual(1000, builder.Value.Length);

             input.ReadMessage(builder, ExtensionRegistry.Empty);

-            Assert.Equal(5217L, input.Position);

-            Assert.Equal(input.Position, ms.Length);

-            Assert.Equal(100, builder.Value.Length);

+            Assert.AreEqual(5217L, input.Position);

+            Assert.AreEqual(input.Position, ms.Length);

+            Assert.AreEqual(100, builder.Value.Length);

         }

     }

 }
\ No newline at end of file