Merge pull request #366 from jskeet/csharp

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

csharp/src/ProtocolBuffers.Test/AbstractMessageTest.cs

@@ -39,13 +39,13 @@ using System.Collections.Generic;
 using System.IO;
 using Google.ProtocolBuffers.Descriptors;
 using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class AbstractMessageTest
     {
-        [Fact]
+        [Test]
         public void Clear()
         {
             AbstractMessageWrapper message =
@@ -53,7 +53,7 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertClear((TestAllTypes) message.WrappedMessage);
         }
 
-        [Fact]
+        [Test]
         public void Copy()
         {
             AbstractMessageWrapper message =
@@ -61,31 +61,31 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage);
         }
 
-        [Fact]
+        [Test]
         public void CreateAndBuild()
         {
             TestAllTypes.CreateBuilder()
                 .Build();
         }
 
-        [Fact]
+        [Test]
         public void SerializedSize()
         {
             TestAllTypes message = TestUtil.GetAllSet();
             IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet());
 
-            Assert.Equal(message.SerializedSize, abstractMessage.SerializedSize);
+            Assert.AreEqual(message.SerializedSize, abstractMessage.SerializedSize);
         }
 
-        [Fact]
+        [Test]
         public void Serialization()
         {
             IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet());
             TestUtil.AssertAllFieldsSet(TestAllTypes.ParseFrom(abstractMessage.ToByteString()));
-            Assert.Equal(TestUtil.GetAllSet().ToByteString(), abstractMessage.ToByteString());
+            Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), abstractMessage.ToByteString());
         }
 
-        [Fact]
+        [Test]
         public void Parsing()
         {
             IBuilder builder = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder());
@@ -94,15 +94,15 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage);
         }
 
-        [Fact]
+        [Test]
         public void PackedSerialization()
         {
             IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetPackedSet());
             TestUtil.AssertPackedFieldsSet(TestPackedTypes.ParseFrom(abstractMessage.ToByteString()));
-            Assert.Equal(TestUtil.GetPackedSet().ToByteString(), abstractMessage.ToByteString());
+            Assert.AreEqual(TestUtil.GetPackedSet().ToByteString(), abstractMessage.ToByteString());
         }
 
-        [Fact]
+        [Test]
         public void PackedParsing()
         {
             AbstractMessageWrapper.Builder builder = new AbstractMessageWrapper.Builder(TestPackedTypes.CreateBuilder());
@@ -110,7 +110,7 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertPackedFieldsSet((TestPackedTypes)message.WrappedMessage);
         }
 
-        [Fact]
+        [Test]
         public void UnpackedParsingOfPackedInput()
         {
             byte[] bytes = TestUtil.GetPackedSet().ToByteArray();
@@ -118,7 +118,7 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertUnpackedFieldsSet(message);
         }
 
-        [Fact]
+        [Test]
         public void PackedParsingOfUnpackedInput()
         {
             byte[] bytes = TestUnpackedTypes.ParseFrom(TestUtil.GetPackedSet().ToByteArray()).ToByteArray();
@@ -126,7 +126,7 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertPackedFieldsSet(message);
         }
 
-        [Fact]
+        [Test]
         public void UnpackedParsingOfPackedInputExtensions()
         {
             byte[] bytes = TestUtil.GetPackedSet().ToByteArray();
@@ -137,7 +137,7 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertUnpackedExtensionsSet(message);
         }
 
-        [Fact]
+        [Test]
         public void PackedParsingOfUnpackedInputExtensions()
         {
             byte[] bytes = TestUnpackedTypes.ParseFrom(TestUtil.GetPackedSet().ToByteArray()).ToByteArray();
@@ -147,13 +147,13 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertPackedExtensionsSet(message);
         }
 
-        [Fact]
+        [Test]
         public void OptimizedForSize()
         {
             // We're mostly only Checking that this class was compiled successfully.
             TestOptimizedForSize message = TestOptimizedForSize.CreateBuilder().SetI(1).Build();
             message = TestOptimizedForSize.ParseFrom(message.ToByteString());
-            Assert.Equal(2, message.SerializedSize);
+            Assert.AreEqual(2, message.SerializedSize);
         }
 
         // -----------------------------------------------------------------
@@ -164,40 +164,40 @@ namespace Google.ProtocolBuffers
         private static readonly TestRequired TestRequiredInitialized =
             TestRequired.CreateBuilder().SetA(1).SetB(2).SetC(3).Build();
 
-        [Fact]
+        [Test]
         public void IsInitialized()
         {
             TestRequired.Builder builder = TestRequired.CreateBuilder();
             AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder);
 
-            Assert.False(abstractBuilder.IsInitialized);
+            Assert.IsFalse(abstractBuilder.IsInitialized);
             builder.A = 1;
-            Assert.False(abstractBuilder.IsInitialized);
+            Assert.IsFalse(abstractBuilder.IsInitialized);
             builder.B = 1;
-            Assert.False(abstractBuilder.IsInitialized);
+            Assert.IsFalse(abstractBuilder.IsInitialized);
             builder.C = 1;
-            Assert.True(abstractBuilder.IsInitialized);
+            Assert.IsTrue(abstractBuilder.IsInitialized);
         }
 
-        [Fact]
+        [Test]
         public void ForeignIsInitialized()
         {
             TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder();
             AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder);
 
-            Assert.True(abstractBuilder.IsInitialized);
+            Assert.IsTrue(abstractBuilder.IsInitialized);
 
             builder.SetOptionalMessage(TestRequiredUninitialized);
-            Assert.False(abstractBuilder.IsInitialized);
+            Assert.IsFalse(abstractBuilder.IsInitialized);
 
             builder.SetOptionalMessage(TestRequiredInitialized);
-            Assert.True(abstractBuilder.IsInitialized);
+            Assert.IsTrue(abstractBuilder.IsInitialized);
 
             builder.AddRepeatedMessage(TestRequiredUninitialized);
-            Assert.False(abstractBuilder.IsInitialized);
+            Assert.IsFalse(abstractBuilder.IsInitialized);
 
             builder.SetRepeatedMessage(0, TestRequiredInitialized);
-            Assert.True(abstractBuilder.IsInitialized);
+            Assert.IsTrue(abstractBuilder.IsInitialized);
         }
 
         // -----------------------------------------------------------------
@@ -226,7 +226,7 @@ namespace Google.ProtocolBuffers
                                                "repeated_string: \"qux\"\n" +
                                                "repeated_string: \"bar\"\n";
 
-        [Fact]
+        [Test]
         public void MergeFrom()
         {
             AbstractMessageWrapper result = (AbstractMessageWrapper)
@@ -234,13 +234,13 @@ namespace Google.ProtocolBuffers
                                                 .MergeFrom(MergeSource)
                                                 .Build();
 
-            Assert.Equal(MergeResultText, result.ToString());
+            Assert.AreEqual(MergeResultText, result.ToString());
         }
 
         // -----------------------------------------------------------------
         // Tests for equals and hashCode
 
-        [Fact]
+        [Test]
         public void EqualsAndHashCode()
         {
             TestAllTypes a = TestUtil.GetAllSet();
@@ -296,7 +296,7 @@ namespace Google.ProtocolBuffers
         private static void CheckEqualsIsConsistent(IMessage message)
         {
             // Object should be equal to itself.
-            Assert.Equal(message, message);
+            Assert.AreEqual(message, message);
 
             // Object should be equal to a dynamic copy of itself.
             DynamicMessage dynamic = DynamicMessage.CreateBuilder(message).Build();
@@ -310,9 +310,9 @@ namespace Google.ProtocolBuffers
         {
             // Not using Assert.AreEqual as that checks for type equality, which isn't
             // what we want bearing in mind the dynamic message checks.
-            Assert.True(message1.Equals(message2));
-            Assert.True(message2.Equals(message1));
-            Assert.Equal(message2.GetHashCode(), message1.GetHashCode());
+            Assert.IsTrue(message1.Equals(message2));
+            Assert.IsTrue(message2.Equals(message1));
+            Assert.AreEqual(message2.GetHashCode(), message1.GetHashCode());
         }
 
         /// <summary>
@@ -326,10 +326,10 @@ namespace Google.ProtocolBuffers
         private static void CheckNotEqual(IMessage m1, IMessage m2)
         {
             String equalsError = string.Format("{0} should not be equal to {1}", m1, m2);
-            Assert.False(m1.Equals(m2), equalsError);
-            Assert.False(m2.Equals(m1), equalsError);
+            Assert.IsFalse(m1.Equals(m2), equalsError);
+            Assert.IsFalse(m2.Equals(m1), equalsError);
 
-            Assert.False(m1.GetHashCode() == m2.GetHashCode(),
+            Assert.IsFalse(m1.GetHashCode() == m2.GetHashCode(),
                            string.Format("{0} should have a different hash code from {1}", m1, m2));
         }
 

csharp/src/ProtocolBuffers.Test/ByteStringTest.cs

@@ -36,112 +36,112 @@
 
 using System;
 using System.Text;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class ByteStringTest
     {
-        [Fact]
+        [Test]
         public void EmptyByteStringHasZeroSize()
         {
-            Assert.Equal(0, ByteString.Empty.Length);
+            Assert.AreEqual(0, ByteString.Empty.Length);
         }
 
-        [Fact]
+        [Test]
         public void CopyFromStringWithExplicitEncoding()
         {
             ByteString bs = ByteString.CopyFrom("AB", Encoding.Unicode);
-            Assert.Equal(4, bs.Length);
-            Assert.Equal(65, bs[0]);
-            Assert.Equal(0, bs[1]);
-            Assert.Equal(66, bs[2]);
-            Assert.Equal(0, bs[3]);
+            Assert.AreEqual(4, bs.Length);
+            Assert.AreEqual(65, bs[0]);
+            Assert.AreEqual(0, bs[1]);
+            Assert.AreEqual(66, bs[2]);
+            Assert.AreEqual(0, bs[3]);
         }
 
-        [Fact]
+        [Test]
         public void IsEmptyWhenEmpty()
         {
-            Assert.True(ByteString.CopyFromUtf8("").IsEmpty);
+            Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty);
         }
 
-        [Fact]
+        [Test]
         public void IsEmptyWhenNotEmpty()
         {
-            Assert.False(ByteString.CopyFromUtf8("X").IsEmpty);
+            Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty);
         }
 
-        [Fact]
+        [Test]
         public void CopyFromByteArrayCopiesContents()
         {
             byte[] data = new byte[1];
             data[0] = 10;
             ByteString bs = ByteString.CopyFrom(data);
-            Assert.Equal(10, bs[0]);
+            Assert.AreEqual(10, bs[0]);
             data[0] = 5;
-            Assert.Equal(10, bs[0]);
+            Assert.AreEqual(10, bs[0]);
         }
 
-        [Fact]
+        [Test]
         public void ToByteArrayCopiesContents()
         {
             ByteString bs = ByteString.CopyFromUtf8("Hello");
             byte[] data = bs.ToByteArray();
-            Assert.Equal((byte)'H', data[0]);
-            Assert.Equal((byte)'H', bs[0]);
+            Assert.AreEqual((byte)'H', data[0]);
+            Assert.AreEqual((byte)'H', bs[0]);
             data[0] = 0;
-            Assert.Equal(0, data[0]);
-            Assert.Equal((byte)'H', bs[0]);
+            Assert.AreEqual(0, data[0]);
+            Assert.AreEqual((byte)'H', bs[0]);
         }
 
-        [Fact]
+        [Test]
         public void CopyFromUtf8UsesUtf8()
         {
             ByteString bs = ByteString.CopyFromUtf8("\u20ac");
-            Assert.Equal(3, bs.Length);
-            Assert.Equal(0xe2, bs[0]);
-            Assert.Equal(0x82, bs[1]);
-            Assert.Equal(0xac, bs[2]);
+            Assert.AreEqual(3, bs.Length);
+            Assert.AreEqual(0xe2, bs[0]);
+            Assert.AreEqual(0x82, bs[1]);
+            Assert.AreEqual(0xac, bs[2]);
         }
 
-        [Fact]
+        [Test]
         public void CopyFromPortion()
         {
             byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6};
             ByteString bs = ByteString.CopyFrom(data, 2, 3);
-            Assert.Equal(3, bs.Length);
-            Assert.Equal(2, bs[0]);
-            Assert.Equal(3, bs[1]);
+            Assert.AreEqual(3, bs.Length);
+            Assert.AreEqual(2, bs[0]);
+            Assert.AreEqual(3, bs[1]);
         }
 
-        [Fact]
+        [Test]
         public void ToStringUtf8()
         {
             ByteString bs = ByteString.CopyFromUtf8("\u20ac");
-            Assert.Equal("\u20ac", bs.ToStringUtf8());
+            Assert.AreEqual("\u20ac", bs.ToStringUtf8());
         }
 
-        [Fact]
+        [Test]
         public void ToStringWithExplicitEncoding()
         {
             ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode);
-            Assert.Equal("\u20ac", bs.ToString(Encoding.Unicode));
+            Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode));
         }
 
-        [Fact]
+        [Test]
         public void FromBase64_WithText()
         {
             byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6};
             string base64 = Convert.ToBase64String(data);
             ByteString bs = ByteString.FromBase64(base64);
-            Assert.Equal(data, bs.ToByteArray());
+            Assert.AreEqual(data, bs.ToByteArray());
         }
 
-        [Fact]
+        [Test]
         public void FromBase64_Empty()
         {
             // Optimization which also fixes issue 61.
-            Assert.Same(ByteString.Empty, ByteString.FromBase64(""));
+            Assert.AreSame(ByteString.Empty, ByteString.FromBase64(""));
         }
     }
 }
\ No newline at end of file

csharp/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs

@@ -36,13 +36,13 @@
 
 using System;
 using System.Collections.Generic;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers.Collections
 {
     public class PopsicleListTest
     {
-        [Fact]
+        [Test]
         public void MutatingOperationsOnFrozenList()
         {
             PopsicleList<string> list = new PopsicleList<string>();
@@ -55,20 +55,20 @@ namespace Google.ProtocolBuffers.Collections
             Assert.Throws<NotSupportedException>(() => list.Add(new[] { "", "" }));
         }
 
-        [Fact]
+        [Test]
         public void NonMutatingOperationsOnFrozenList()
         {
             PopsicleList<string> list = new PopsicleList<string>();
             list.MakeReadOnly();
-            Assert.False(list.Contains(""));
-            Assert.Equal(0, list.Count);
+            Assert.IsFalse(list.Contains(""));
+            Assert.AreEqual(0, list.Count);
             list.CopyTo(new string[5], 0);
             list.GetEnumerator();
-            Assert.Equal(-1, list.IndexOf(""));
-            Assert.True(list.IsReadOnly);
+            Assert.AreEqual(-1, list.IndexOf(""));
+            Assert.IsTrue(list.IsReadOnly);
         }
 
-        [Fact]
+        [Test]
         public void MutatingOperationsOnFluidList()
         {
             PopsicleList<string> list = new PopsicleList<string>();
@@ -80,26 +80,26 @@ namespace Google.ProtocolBuffers.Collections
             list.RemoveAt(0);
         }
 
-        [Fact]
+        [Test]
         public void NonMutatingOperationsOnFluidList()
         {
             PopsicleList<string> list = new PopsicleList<string>();
-            Assert.False(list.Contains(""));
-            Assert.Equal(0, list.Count);
+            Assert.IsFalse(list.Contains(""));
+            Assert.AreEqual(0, list.Count);
             list.CopyTo(new string[5], 0);
             list.GetEnumerator();
-            Assert.Equal(-1, list.IndexOf(""));
-            Assert.False(list.IsReadOnly);
+            Assert.AreEqual(-1, list.IndexOf(""));
+            Assert.IsFalse(list.IsReadOnly);
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddNullEnumerable()
         {
             PopsicleList<string> list = new PopsicleList<string>();
             Assert.Throws<ArgumentNullException>(() => list.Add((IEnumerable<string>) null));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddRangeWithNull()
         {
             PopsicleList<string> list = new PopsicleList<string>();
@@ -107,14 +107,14 @@ namespace Google.ProtocolBuffers.Collections
             Assert.Throws<ArgumentNullException>(() => list.Add(new[] {"a", "b", null}));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddNull()
         {
             PopsicleList<string> list = new PopsicleList<string>();
             Assert.Throws<ArgumentNullException>(() => list.Add((string) null));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotSetNull()
         {
             PopsicleList<string> list = new PopsicleList<string>();

csharp/src/ProtocolBuffers.Test/Compatibility/CompatibilityTests.cs

 using System;
 using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 
 namespace Google.ProtocolBuffers.Compatibility
 {
     /// <summary>
     /// This abstract base implements several tests to ensure that well-known messages can be written
-    /// and read to/from various formats without losing data.  Implementations overload the two serailization
+    /// and read to/from various formats without losing data.  Implementations override the two serialization
     /// methods to provide the tests with the means to read and write for a given format.
     /// </summary>
     public abstract class CompatibilityTests
@@ -22,10 +22,10 @@ namespace Google.ProtocolBuffers.Compatibility
 
         protected virtual void AssertOutputEquals(object lhs, object rhs)
         {
-            Assert.Equal<object>(lhs, rhs);
+            Assert.AreEqual(lhs, rhs);
         }
 
-        [Fact]
+        [Test]
         public virtual void RoundTripWithEmptyChildMessageSize()
         {
             SizeMessage1 msg = SizeMessage1.CreateBuilder()
@@ -37,12 +37,12 @@ namespace Google.ProtocolBuffers.Compatibility
 
             SizeMessage1 copy = DeserializeMessage<SizeMessage1, SizeMessage1.Builder>(content, SizeMessage1.CreateBuilder(), ExtensionRegistry.Empty).BuildPartial();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<SizeMessage1, SizeMessage1.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray()));
         }
 
-        [Fact]
+        [Test]
         public virtual void RoundTripWithEmptyChildMessageSpeed()
         {
             SpeedMessage1 msg = SpeedMessage1.CreateBuilder()
@@ -54,12 +54,12 @@ namespace Google.ProtocolBuffers.Compatibility
 
             SpeedMessage1 copy = DeserializeMessage<SpeedMessage1, SpeedMessage1.Builder>(content, SpeedMessage1.CreateBuilder(), ExtensionRegistry.Empty).BuildPartial();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<SpeedMessage1, SpeedMessage1.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(contents), Convert.ToBase64String(copy.ToByteArray()));
         }
 
-        [Fact]
+        [Test]
         public virtual void RoundTripMessage1OptimizeSize()
         {
             SizeMessage1 msg = SizeMessage1.CreateBuilder().MergeFrom(TestResources.google_message1).Build();
@@ -67,12 +67,12 @@ namespace Google.ProtocolBuffers.Compatibility
 
             SizeMessage1 copy = DeserializeMessage<SizeMessage1, SizeMessage1.Builder>(content, SizeMessage1.CreateBuilder(), ExtensionRegistry.Empty).Build();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<SizeMessage1, SizeMessage1.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray()));
         }
 
-        [Fact]
+        [Test]
         public virtual void RoundTripMessage2OptimizeSize()
         {
             SizeMessage2 msg = SizeMessage2.CreateBuilder().MergeFrom(TestResources.google_message2).Build();
@@ -80,12 +80,12 @@ namespace Google.ProtocolBuffers.Compatibility
 
             SizeMessage2 copy = DeserializeMessage<SizeMessage2, SizeMessage2.Builder>(content, SizeMessage2.CreateBuilder(), ExtensionRegistry.Empty).Build();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<SizeMessage2, SizeMessage2.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray()));
         }
 
-        [Fact]
+        [Test]
         public virtual void RoundTripMessage1OptimizeSpeed()
         {
             SpeedMessage1 msg = SpeedMessage1.CreateBuilder().MergeFrom(TestResources.google_message1).Build();
@@ -93,12 +93,12 @@ namespace Google.ProtocolBuffers.Compatibility
 
             SpeedMessage1 copy = DeserializeMessage<SpeedMessage1, SpeedMessage1.Builder>(content, SpeedMessage1.CreateBuilder(), ExtensionRegistry.Empty).Build();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<SpeedMessage1, SpeedMessage1.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(TestResources.google_message1), Convert.ToBase64String(copy.ToByteArray()));
         }
 
-        [Fact]
+        [Test]
         public virtual void RoundTripMessage2OptimizeSpeed()
         {
             SpeedMessage2 msg = SpeedMessage2.CreateBuilder().MergeFrom(TestResources.google_message2).Build();
@@ -106,9 +106,9 @@ namespace Google.ProtocolBuffers.Compatibility
 
             SpeedMessage2 copy = DeserializeMessage<SpeedMessage2, SpeedMessage2.Builder>(content, SpeedMessage2.CreateBuilder(), ExtensionRegistry.Empty).Build();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<SpeedMessage2, SpeedMessage2.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(TestResources.google_message2), Convert.ToBase64String(copy.ToByteArray()));
         }
 
         #region Test message builders
@@ -185,7 +185,7 @@ namespace Google.ProtocolBuffers.Compatibility
 
         #endregion
 
-        [Fact]
+        [Test]
         public void TestRoundTripAllTypes()
         {
             TestAllTypes msg = AddAllTypes(new TestAllTypes.Builder()).Build();
@@ -193,12 +193,12 @@ namespace Google.ProtocolBuffers.Compatibility
 
             TestAllTypes copy = DeserializeMessage<TestAllTypes, TestAllTypes.Builder>(content, TestAllTypes.CreateBuilder(), ExtensionRegistry.Empty).Build();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<TestAllTypes, TestAllTypes.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray()));
         }
 
-        [Fact]
+        [Test]
         public void TestRoundTripRepeatedTypes()
         {
             TestAllTypes msg = AddRepeatedTypes(new TestAllTypes.Builder(), 5).Build();
@@ -206,12 +206,12 @@ namespace Google.ProtocolBuffers.Compatibility
 
             TestAllTypes copy = DeserializeMessage<TestAllTypes, TestAllTypes.Builder>(content, TestAllTypes.CreateBuilder(), ExtensionRegistry.Empty).Build();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<TestAllTypes, TestAllTypes.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray()));
         }
 
-        [Fact]
+        [Test]
         public void TestRoundTripPackedTypes()
         {
             TestPackedTypes msg = AddPackedTypes(new TestPackedTypes.Builder(), 5).Build();
@@ -219,9 +219,9 @@ namespace Google.ProtocolBuffers.Compatibility
 
             TestPackedTypes copy = DeserializeMessage<TestPackedTypes, TestPackedTypes.Builder>(content, TestPackedTypes.CreateBuilder(), ExtensionRegistry.Empty).Build();
 
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
             AssertOutputEquals(content, SerializeMessage<TestPackedTypes, TestPackedTypes.Builder>(copy));
-            Assert.Equal(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray()));
+            Assert.AreEqual(Convert.ToBase64String(msg.ToByteArray()), Convert.ToBase64String(copy.ToByteArray()));
         }
     }
 }

csharp/src/ProtocolBuffers.Test/Compatibility/DictionaryCompatibilityTests.cs

 using System;
 using System.Collections.Generic;
 using Google.ProtocolBuffers.Serialization;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers.Compatibility
 {
+    [TestFixture]
     public class DictionaryCompatibilityTests : CompatibilityTests
     {
         protected override object SerializeMessage<TMessage, TBuilder>(TMessage message)
@@ -25,7 +26,7 @@ namespace Google.ProtocolBuffers.Compatibility
             IDictionary<string, object> left = (IDictionary<string, object>)lhs;
             IDictionary<string, object> right = (IDictionary<string, object>)rhs;
 
-            Assert.Equal(
+            Assert.AreEqual(
                 String.Join(",", new List<string>(left.Keys).ToArray()),
                 String.Join(",", new List<string>(right.Keys).ToArray())
             );

csharp/src/ProtocolBuffers.Test/Compatibility/JsonCompatibilityTests.cs

 using System.IO;
 using Google.ProtocolBuffers.Serialization;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers.Compatibility
 {
+    [TestFixture]
     public class JsonCompatibilityTests : CompatibilityTests
     {
         protected override object SerializeMessage<TMessage, TBuilder>(TMessage message)
@@ -20,6 +22,7 @@ namespace Google.ProtocolBuffers.Compatibility
         }
     }
 
+    [TestFixture]
     public class JsonCompatibilityFormattedTests : CompatibilityTests
     {
         protected override object SerializeMessage<TMessage, TBuilder>(TMessage message)

csharp/src/ProtocolBuffers.Test/Compatibility/TestResources.cs

 using System.IO;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers.Compatibility
 {
@@ -16,7 +16,7 @@ namespace Google.ProtocolBuffers.Compatibility
 
                 byte[] bytes = new byte[resource.Length];
                 int amtRead = resource.Read(bytes, 0, bytes.Length);
-                Assert.Equal(bytes.Length, amtRead);
+                Assert.AreEqual(bytes.Length, amtRead);
                 return bytes;
             }
         }
@@ -30,7 +30,7 @@ namespace Google.ProtocolBuffers.Compatibility
                 Assert.NotNull(resource);
                 byte[] bytes = new byte[resource.Length];
                 int amtRead = resource.Read(bytes, 0, bytes.Length);
-                Assert.Equal(bytes.Length, amtRead);
+                Assert.AreEqual(bytes.Length, amtRead);
                 return bytes;
             }
         }

csharp/src/ProtocolBuffers.Test/Compatibility/TextCompatibilityTests.cs

 using System.IO;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers.Compatibility
 {
+    [TestFixture]
     public class TextCompatibilityTests : CompatibilityTests
     {
         protected override object SerializeMessage<TMessage, TBuilder>(TMessage message)
@@ -18,14 +19,14 @@ namespace Google.ProtocolBuffers.Compatibility
             return builder;
         }
         //This test can take a very long time to run.
-        [Fact]
+        [Test]
         public override void RoundTripMessage2OptimizeSize()
         {
             //base.RoundTripMessage2OptimizeSize();
         }
 
         //This test can take a very long time to run.
-        [Fact]
+        [Test]
         public override void RoundTripMessage2OptimizeSpeed()
         {
             //base.RoundTripMessage2OptimizeSpeed();

csharp/src/ProtocolBuffers.Test/Compatibility/XmlCompatibilityTests.cs

 using System.IO;
 using System.Xml;
 using Google.ProtocolBuffers.Serialization;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers.Compatibility
 {
+    [TestFixture]
     public class XmlCompatibilityTests : CompatibilityTests
     {
         protected override object SerializeMessage<TMessage, TBuilder>(TMessage message)
@@ -21,6 +23,7 @@ namespace Google.ProtocolBuffers.Compatibility
         }
     }
 
+    [TestFixture]
     public class XmlCompatibilityFormattedTests : CompatibilityTests
     {
         protected override object SerializeMessage<TMessage, TBuilder>(TMessage message)

csharp/src/ProtocolBuffers.Test/DeprecatedMemberTest.cs

 using System;
 using System.Reflection;
 using UnitTest.Issues.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
@@ -10,10 +10,10 @@ namespace Google.ProtocolBuffers
         private static void AssertIsDeprecated(MemberInfo member)
         {
             Assert.NotNull(member);
-            Assert.True(member.IsDefined(typeof(ObsoleteAttribute), false), "Member not obsolete: " + member);
+            Assert.IsTrue(member.IsDefined(typeof(ObsoleteAttribute), false), "Member not obsolete: " + member);
         }
 
-        [Fact]
+        [Test]
         public void TestDepreatedPrimitiveValue()
         {
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("HasPrimitiveValue"));
@@ -24,7 +24,7 @@ namespace Google.ProtocolBuffers
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearPrimitiveValue"));
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetPrimitiveValue"));
         }
-        [Fact]
+        [Test]
         public void TestDepreatedPrimitiveArray()
         {
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("PrimitiveArrayList"));
@@ -39,7 +39,7 @@ namespace Google.ProtocolBuffers
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("AddRangePrimitiveArray"));
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearPrimitiveArray"));
         }
-        [Fact]
+        [Test]
         public void TestDepreatedMessageValue()
         {
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("HasMessageValue"));
@@ -52,7 +52,7 @@ namespace Google.ProtocolBuffers
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetMessageValue", new[] { typeof(DeprecatedChild) }));
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetMessageValue", new[] { typeof(DeprecatedChild.Builder) }));
         }
-        [Fact]
+        [Test]
         public void TestDepreatedMessageArray()
         {
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("MessageArrayList"));
@@ -69,7 +69,7 @@ namespace Google.ProtocolBuffers
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("AddRangeMessageArray"));
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearMessageArray"));
         }
-        [Fact]
+        [Test]
         public void TestDepreatedEnumValue()
         {
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("HasEnumValue"));
@@ -80,7 +80,7 @@ namespace Google.ProtocolBuffers
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("ClearEnumValue"));
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage.Builder).GetMethod("SetEnumValue"));
         }
-        [Fact]
+        [Test]
         public void TestDepreatedEnumArray()
         {
             AssertIsDeprecated(typeof(DeprecatedFieldsMessage).GetProperty("EnumArrayList"));

csharp/src/ProtocolBuffers.Test/DynamicMessageTest.cs

@@ -37,7 +37,7 @@
 using System;
 using System.Collections.Generic;
 using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
@@ -54,7 +54,7 @@ namespace Google.ProtocolBuffers
             packedReflectionTester = ReflectionTester.CreateTestPackedTypesInstance();
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageAccessors()
         {
             IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
@@ -63,7 +63,7 @@ namespace Google.ProtocolBuffers
             reflectionTester.AssertAllFieldsSetViaReflection(message);
         }
 
-        [Fact]
+        [Test]
         public void DoubleBuildError()
         {
             DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
@@ -71,14 +71,14 @@ namespace Google.ProtocolBuffers
             Assert.Throws<InvalidOperationException>(() => builder.Build());
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageSettersRejectNull()
         {
             IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
             reflectionTester.AssertReflectionSettersRejectNull(builder);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageExtensionAccessors()
         {
             // We don't need to extensively test DynamicMessage's handling of
@@ -90,14 +90,14 @@ namespace Google.ProtocolBuffers
             extensionsReflectionTester.AssertAllFieldsSetViaReflection(message);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageExtensionSettersRejectNull()
         {
             IBuilder builder = DynamicMessage.CreateBuilder(TestAllExtensions.Descriptor);
             extensionsReflectionTester.AssertReflectionSettersRejectNull(builder);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageRepeatedSetters()
         {
             IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
@@ -107,21 +107,21 @@ namespace Google.ProtocolBuffers
             reflectionTester.AssertRepeatedFieldsModifiedViaReflection(message);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageRepeatedSettersRejectNull()
         {
             IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
             reflectionTester.AssertReflectionRepeatedSettersRejectNull(builder);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageDefaults()
         {
             reflectionTester.AssertClearViaReflection(DynamicMessage.GetDefaultInstance(TestAllTypes.Descriptor));
             reflectionTester.AssertClearViaReflection(DynamicMessage.CreateBuilder(TestAllTypes.Descriptor).Build());
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageSerializedSize()
         {
             TestAllTypes message = TestUtil.GetAllSet();
@@ -130,10 +130,10 @@ namespace Google.ProtocolBuffers
             reflectionTester.SetAllFieldsViaReflection(dynamicBuilder);
             IMessage dynamicMessage = dynamicBuilder.WeakBuild();
 
-            Assert.Equal(message.SerializedSize, dynamicMessage.SerializedSize);
+            Assert.AreEqual(message.SerializedSize, dynamicMessage.SerializedSize);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageSerialization()
         {
             IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
@@ -146,10 +146,10 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertAllFieldsSet(message2);
 
             // In fact, the serialized forms should be exactly the same, byte-for-byte.
-            Assert.Equal(TestUtil.GetAllSet().ToByteString(), rawBytes);
+            Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), rawBytes);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageParsing()
         {
             TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
@@ -162,7 +162,7 @@ namespace Google.ProtocolBuffers
             reflectionTester.AssertAllFieldsSetViaReflection(message2);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessagePackedSerialization()
         {
             IBuilder builder = DynamicMessage.CreateBuilder(TestPackedTypes.Descriptor);
@@ -175,10 +175,10 @@ namespace Google.ProtocolBuffers
             TestUtil.AssertPackedFieldsSet(message2);
 
             // In fact, the serialized forms should be exactly the same, byte-for-byte.
-            Assert.Equal(TestUtil.GetPackedSet().ToByteString(), rawBytes);
+            Assert.AreEqual(TestUtil.GetPackedSet().ToByteString(), rawBytes);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessagePackedParsing()
         {
             TestPackedTypes.Builder builder = TestPackedTypes.CreateBuilder();
@@ -191,7 +191,7 @@ namespace Google.ProtocolBuffers
             packedReflectionTester.AssertPackedFieldsSetViaReflection(message2);
         }
 
-        [Fact]
+        [Test]
         public void DynamicMessageCopy()
         {
             TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
@@ -202,7 +202,7 @@ namespace Google.ProtocolBuffers
             reflectionTester.AssertAllFieldsSetViaReflection(copy);
         }
 
-        [Fact]
+        [Test]
         public void ToBuilder()
         {
             DynamicMessage.Builder builder =
@@ -220,8 +220,8 @@ namespace Google.ProtocolBuffers
             reflectionTester.AssertAllFieldsSetViaReflection(derived);
 
             IList<ulong> values = derived.UnknownFields.FieldDictionary[unknownFieldNum].VarintList;
-            Assert.Equal(1, values.Count);
-            Assert.Equal(unknownFieldVal, values[0]);
+            Assert.AreEqual(1, values.Count);
+            Assert.AreEqual(unknownFieldVal, values[0]);
         }
     }
 }
\ No newline at end of file

csharp/src/ProtocolBuffers.Test/FieldPresenceTest.cs

@@ -34,7 +34,7 @@
 using System;
 using Google.ProtocolBuffers.Descriptors;
 using Google.ProtocolBuffers.TestProtos.FieldPresence;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
@@ -48,7 +48,7 @@ namespace Google.ProtocolBuffers
             Assert.Null(proto3Type.GetProperty("Has" + name));
         }
 
-        [Fact]
+        [Test]
         public void TestHasMethod()
         {
             // Optional non-message fields don't have HasFoo method generated
@@ -67,11 +67,11 @@ namespace Google.ProtocolBuffers
             CheckHasMethodRemoved(proto2Type, proto3Type, "OptionalNestedEnum");
 
             // message fields still have the HasFoo method generated
-            Assert.False(TestAllTypes.CreateBuilder().Build().HasOptionalNestedMessage);
-            Assert.False(TestAllTypes.CreateBuilder().HasOptionalNestedMessage);
+            Assert.IsFalse(TestAllTypes.CreateBuilder().Build().HasOptionalNestedMessage);
+            Assert.IsFalse(TestAllTypes.CreateBuilder().HasOptionalNestedMessage);
         }
 
-        [Fact]
+        [Test]
         public void TestFieldPresence()
         {
             // Optional non-message fields set to their default value are treated the same
@@ -84,7 +84,7 @@ namespace Google.ProtocolBuffers
             builder.SetOptionalBytes(ByteString.Empty);
             builder.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.FOO);
             TestAllTypes message = builder.Build();
-            Assert.Equal(0, message.SerializedSize);
+            Assert.AreEqual(0, message.SerializedSize);
 
             // Test merge
             TestAllTypes.Builder a = TestAllTypes.CreateBuilder();
@@ -94,19 +94,19 @@ namespace Google.ProtocolBuffers
             a.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.BAR);
             a.MergeFrom(message);
             TestAllTypes messageA = a.Build();
-            Assert.Equal(1, messageA.OptionalInt32);
-            Assert.Equal("x", messageA.OptionalString);
-            Assert.Equal(ByteString.CopyFromUtf8("y"), messageA.OptionalBytes);
-            Assert.Equal(TestAllTypes.Types.NestedEnum.BAR, messageA.OptionalNestedEnum);
+            Assert.AreEqual(1, messageA.OptionalInt32);
+            Assert.AreEqual("x", messageA.OptionalString);
+            Assert.AreEqual(ByteString.CopyFromUtf8("y"), messageA.OptionalBytes);
+            Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, messageA.OptionalNestedEnum);
 
             // equals/hashCode should produce the same results
             TestAllTypes empty = TestAllTypes.CreateBuilder().Build();
-            Assert.True(empty.Equals(message));
-            Assert.True(message.Equals(empty));
-            Assert.Equal(empty.GetHashCode(), message.GetHashCode());
+            Assert.IsTrue(empty.Equals(message));
+            Assert.IsTrue(message.Equals(empty));
+            Assert.AreEqual(empty.GetHashCode(), message.GetHashCode());
         }
 
-        [Fact]
+        [Test]
         public void TestFieldPresenceReflection()
         {
             MessageDescriptor descriptor = TestAllTypes.Descriptor;
@@ -116,10 +116,10 @@ namespace Google.ProtocolBuffers
             FieldDescriptor optionalNestedEnumField = descriptor.FindFieldByName("optional_nested_enum");
 
             TestAllTypes message = TestAllTypes.CreateBuilder().Build();
-            Assert.False(message.HasField(optionalInt32Field));
-            Assert.False(message.HasField(optionalStringField));
-            Assert.False(message.HasField(optionalBytesField));
-            Assert.False(message.HasField(optionalNestedEnumField));
+            Assert.IsFalse(message.HasField(optionalInt32Field));
+            Assert.IsFalse(message.HasField(optionalStringField));
+            Assert.IsFalse(message.HasField(optionalBytesField));
+            Assert.IsFalse(message.HasField(optionalNestedEnumField));
 
             // Set to default value is seen as not present
             message = TestAllTypes.CreateBuilder()
@@ -128,11 +128,11 @@ namespace Google.ProtocolBuffers
                 .SetOptionalBytes(ByteString.Empty)
                 .SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.FOO)
                 .Build();
-            Assert.False(message.HasField(optionalInt32Field));
-            Assert.False(message.HasField(optionalStringField));
-            Assert.False(message.HasField(optionalBytesField));
-            Assert.False(message.HasField(optionalNestedEnumField));
-            Assert.Equal(0, message.AllFields.Count);
+            Assert.IsFalse(message.HasField(optionalInt32Field));
+            Assert.IsFalse(message.HasField(optionalStringField));
+            Assert.IsFalse(message.HasField(optionalBytesField));
+            Assert.IsFalse(message.HasField(optionalNestedEnumField));
+            Assert.AreEqual(0, message.AllFields.Count);
             
             // Set t0 non-defalut value is seen as present
             message = TestAllTypes.CreateBuilder()
@@ -141,28 +141,28 @@ namespace Google.ProtocolBuffers
                 .SetOptionalBytes(ByteString.CopyFromUtf8("y"))
                 .SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.BAR)
                 .Build();
-            Assert.True(message.HasField(optionalInt32Field));
-            Assert.True(message.HasField(optionalStringField));
-            Assert.True(message.HasField(optionalBytesField));
-            Assert.True(message.HasField(optionalNestedEnumField));
-            Assert.Equal(4, message.AllFields.Count);
+            Assert.IsTrue(message.HasField(optionalInt32Field));
+            Assert.IsTrue(message.HasField(optionalStringField));
+            Assert.IsTrue(message.HasField(optionalBytesField));
+            Assert.IsTrue(message.HasField(optionalNestedEnumField));
+            Assert.AreEqual(4, message.AllFields.Count);
         }
 
-        [Fact]
+        [Test]
         public void TestMessageField()
         {
             TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
-            Assert.False(builder.HasOptionalNestedMessage);
-            Assert.False(builder.Build().HasOptionalNestedMessage);
+            Assert.IsFalse(builder.HasOptionalNestedMessage);
+            Assert.IsFalse(builder.Build().HasOptionalNestedMessage);
 
             // Unlike non-message fields, if we set default value to message field, the field
             // shoule be seem as present.
             builder.SetOptionalNestedMessage(TestAllTypes.Types.NestedMessage.DefaultInstance);
-            Assert.True(builder.HasOptionalNestedMessage);
-            Assert.True(builder.Build().HasOptionalNestedMessage);
+            Assert.IsTrue(builder.HasOptionalNestedMessage);
+            Assert.IsTrue(builder.Build().HasOptionalNestedMessage);
         }
 
-        [Fact]
+        [Test]
         public void TestSerializeAndParse()
         {
             TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
@@ -172,12 +172,12 @@ namespace Google.ProtocolBuffers
             ByteString data = builder.Build().ToByteString();
 
             TestAllTypes message = TestAllTypes.ParseFrom(data);
-            Assert.Equal(1234, message.OptionalInt32);
-            Assert.Equal("hello", message.OptionalString);
-            Assert.Equal(ByteString.Empty, message.OptionalBytes);
-            Assert.Equal(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum);
-            Assert.True(message.HasOptionalNestedMessage);
-            Assert.Equal(0, message.OptionalNestedMessage.Value);
+            Assert.AreEqual(1234, message.OptionalInt32);
+            Assert.AreEqual("hello", message.OptionalString);
+            Assert.AreEqual(ByteString.Empty, message.OptionalBytes);
+            Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum);
+            Assert.IsTrue(message.HasOptionalNestedMessage);
+            Assert.AreEqual(0, message.OptionalNestedMessage.Value);
         }
     }
 }

csharp/src/ProtocolBuffers.Test/GeneratedBuilderTest.cs

 using System;
 using System.Collections.Generic;
 using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
@@ -17,7 +17,7 @@ namespace Google.ProtocolBuffers
             }
             public IEnumerator<T> GetEnumerator()
             {
-                Assert.False(_enumerated);
+                Assert.IsFalse(_enumerated);
                 _enumerated = true;
                 yield return _item;
             }
@@ -27,49 +27,49 @@ namespace Google.ProtocolBuffers
             }
         }
 
-        [Fact]
+        [Test]
         public void DoesNotEnumerateTwiceForMessageList()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             b.AddRangeRepeatedForeignMessage(new OneTimeEnumerator<ForeignMessage>(ForeignMessage.DefaultInstance));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotEnumerateTwiceForPrimitiveList()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             b.AddRangeRepeatedInt32(new OneTimeEnumerator<int>(1));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotEnumerateTwiceForStringList()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             b.AddRangeRepeatedString(new OneTimeEnumerator<string>("test"));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotEnumerateTwiceForEnumList()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             b.AddRangeRepeatedForeignEnum(new OneTimeEnumerator<ForeignEnum>(ForeignEnum.FOREIGN_BAR));
         }
         
-        [Fact]
+        [Test]
         public void DoesNotAddNullToMessageListByAddRange()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             Assert.Throws<ArgumentNullException>(() => b.AddRangeRepeatedForeignMessage(new ForeignMessage[] { null }));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddNullToMessageListByAdd()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             Assert.Throws<ArgumentNullException>(() => b.AddRepeatedForeignMessage((ForeignMessage)null));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddNullToMessageListBySet()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
@@ -77,21 +77,21 @@ namespace Google.ProtocolBuffers
             Assert.Throws<ArgumentNullException>(() => b.SetRepeatedForeignMessage(0, (ForeignMessage)null));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddNullToStringListByAddRange()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             Assert.Throws<ArgumentNullException>(() => b.AddRangeRepeatedString(new String[] { null }));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddNullToStringListByAdd()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();
             Assert.Throws<ArgumentNullException>(() => b.AddRepeatedString(null));
         }
 
-        [Fact]
+        [Test]
         public void DoesNotAddNullToStringListBySet()
         {
             TestAllTypes.Builder b = new TestAllTypes.Builder();

csharp/src/ProtocolBuffers.Test/IssuesTest.cs

@@ -37,7 +37,7 @@
 
 using Google.ProtocolBuffers.Descriptors;
 using UnitTest.Issues.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 
 namespace Google.ProtocolBuffers
@@ -48,13 +48,13 @@ namespace Google.ProtocolBuffers
     public class IssuesTest
     {
         // Issue 45
-        [Fact]
+        [Test]
         public void FieldCalledItem()
         {
             ItemField message = new ItemField.Builder { Item = 3 }.Build();
             FieldDescriptor field = ItemField.Descriptor.FindFieldByName("item");
             Assert.NotNull(field);
-            Assert.Equal(3, (int)message[field]);
+            Assert.AreEqual(3, (int)message[field]);
         }
     }
 }

csharp/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs

@@ -37,27 +37,27 @@
 using System.Collections.Generic;
 using System.IO;
 using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
 using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage;
 
 namespace Google.ProtocolBuffers
 {
     public class MessageStreamIteratorTest
     {
-        [Fact]
+        [Test]
         public void ThreeMessagesInMemory()
         {
             MemoryStream stream = new MemoryStream(MessageStreamWriterTest.ThreeMessageData);
             IEnumerable<NestedMessage> iterator = MessageStreamIterator<NestedMessage>.FromStreamProvider(() => stream);
             List<NestedMessage> messages = new List<NestedMessage>(iterator);
 
-            Assert.Equal(3, messages.Count);
-            Assert.Equal(5, messages[0].Bb);
-            Assert.Equal(1500, messages[1].Bb);
-            Assert.False(messages[2].HasBb);
+            Assert.AreEqual(3, messages.Count);
+            Assert.AreEqual(5, messages[0].Bb);
+            Assert.AreEqual(1500, messages[1].Bb);
+            Assert.IsFalse(messages[2].HasBb);
         }
 
-        [Fact]
+        [Test]
         public void ManyMessagesShouldNotTriggerSizeAlert()
         {
             int messageSize = TestUtil.GetAllSet().SerializedSize;
@@ -83,7 +83,7 @@ namespace Google.ProtocolBuffers
                     count++;
                     TestUtil.AssertAllFieldsSet(message);
                 }
-                Assert.Equal(correctCount, count);
+                Assert.AreEqual(correctCount, count);
             }
         }
     }

csharp/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs

@@ -35,7 +35,7 @@
 #endregion
 
 using System.IO;
-using Xunit;
+using NUnit.Framework;
 using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage;
 
 namespace Google.ProtocolBuffers
@@ -54,7 +54,7 @@ namespace Google.ProtocolBuffers
                                                                    (1 << 3) | 2, 0, // Field 1, no data (third message)
                                                                };
 
-        [Fact]
+        [Test]
         public void ThreeMessages()
         {
             NestedMessage message1 = new NestedMessage.Builder {Bb = 5}.Build();

csharp/src/ProtocolBuffers.Test/MessageUtilTest.cs

@@ -36,47 +36,47 @@
 
 using System;
 using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class MessageUtilTest
     {
-        [Fact]
+        [Test]
         public void NullTypeName()
         {
             Assert.Throws<ArgumentNullException>(() => MessageUtil.GetDefaultMessage((string) null));
         }
 
-        [Fact]
+        [Test]
         public void InvalidTypeName()
         {
             Assert.Throws<ArgumentException>(() => MessageUtil.GetDefaultMessage("invalidtypename"));
         }
 
-        [Fact]
+        [Test]
         public void ValidTypeName()
         {
-            Assert.Same(TestAllTypes.DefaultInstance,
+            Assert.AreSame(TestAllTypes.DefaultInstance,
                            MessageUtil.GetDefaultMessage(typeof(TestAllTypes).AssemblyQualifiedName));
         }
 
-        [Fact]
+        [Test]
         public void NullType()
         {
             Assert.Throws<ArgumentNullException>(() => MessageUtil.GetDefaultMessage((Type)null));
         }
 
-        [Fact]
+        [Test]
         public void NonMessageType()
         {
             Assert.Throws<ArgumentException>(() => MessageUtil.GetDefaultMessage(typeof(string)));
         }
 
-        [Fact]
+        [Test]
         public void ValidType()
         {
-            Assert.Same(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes)));
+            Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes)));
         }
     }
 }
\ No newline at end of file

csharp/src/ProtocolBuffers.Test/NameHelpersTest.cs

@@ -34,48 +34,48 @@
 
 #endregion
 
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class NameHelpersTest
     {
-        [Fact]
+        [Test]
         public void UnderscoresToPascalCase()
         {
-            Assert.Equal("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_bar"));
-            Assert.Equal("FooBar", NameHelpers.UnderscoresToPascalCase("foo_bar"));
-            Assert.Equal("Foo0Bar", NameHelpers.UnderscoresToPascalCase("Foo0bar"));
-            Assert.Equal("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_+_Bar"));
+            Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_bar"));
+            Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("foo_bar"));
+            Assert.AreEqual("Foo0Bar", NameHelpers.UnderscoresToPascalCase("Foo0bar"));
+            Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_+_Bar"));
 
-            Assert.Equal("Bar", NameHelpers.UnderscoresToPascalCase("__+bar"));
-            Assert.Equal("Bar", NameHelpers.UnderscoresToPascalCase("bar_"));
-            Assert.Equal("_0Bar", NameHelpers.UnderscoresToPascalCase("_0bar"));
-            Assert.Equal("_1Bar", NameHelpers.UnderscoresToPascalCase("_1_bar"));
+            Assert.AreEqual("Bar", NameHelpers.UnderscoresToPascalCase("__+bar"));
+            Assert.AreEqual("Bar", NameHelpers.UnderscoresToPascalCase("bar_"));
+            Assert.AreEqual("_0Bar", NameHelpers.UnderscoresToPascalCase("_0bar"));
+            Assert.AreEqual("_1Bar", NameHelpers.UnderscoresToPascalCase("_1_bar"));
         }
 
-        [Fact]
+        [Test]
         public void UnderscoresToCamelCase()
         {
-            Assert.Equal("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_bar"));
-            Assert.Equal("fooBar", NameHelpers.UnderscoresToCamelCase("foo_bar"));
-            Assert.Equal("foo0Bar", NameHelpers.UnderscoresToCamelCase("Foo0bar"));
-            Assert.Equal("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_+_Bar"));
+            Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_bar"));
+            Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("foo_bar"));
+            Assert.AreEqual("foo0Bar", NameHelpers.UnderscoresToCamelCase("Foo0bar"));
+            Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_+_Bar"));
 
-            Assert.Equal("bar", NameHelpers.UnderscoresToCamelCase("__+bar"));
-            Assert.Equal("bar", NameHelpers.UnderscoresToCamelCase("bar_"));
-            Assert.Equal("_0Bar", NameHelpers.UnderscoresToCamelCase("_0bar"));
-            Assert.Equal("_1Bar", NameHelpers.UnderscoresToCamelCase("_1_bar"));
+            Assert.AreEqual("bar", NameHelpers.UnderscoresToCamelCase("__+bar"));
+            Assert.AreEqual("bar", NameHelpers.UnderscoresToCamelCase("bar_"));
+            Assert.AreEqual("_0Bar", NameHelpers.UnderscoresToCamelCase("_0bar"));
+            Assert.AreEqual("_1Bar", NameHelpers.UnderscoresToCamelCase("_1_bar"));
         }
 
-        [Fact]
+        [Test]
         public void StripSuffix()
         {
             string text = "FooBar";
-            Assert.False(NameHelpers.StripSuffix(ref text, "Foo"));
-            Assert.Equal("FooBar", text);
-            Assert.True(NameHelpers.StripSuffix(ref text, "Bar"));
-            Assert.Equal("Foo", text);
+            Assert.IsFalse(NameHelpers.StripSuffix(ref text, "Foo"));
+            Assert.AreEqual("FooBar", text);
+            Assert.IsTrue(NameHelpers.StripSuffix(ref text, "Bar"));
+            Assert.AreEqual("Foo", text);
         }
     }
 }
\ No newline at end of file

csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj

 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" />
-  <Import Project="..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props" Condition="Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -19,7 +17,8 @@
     <OldToolsVersion>3.5</OldToolsVersion>
     <TargetFrameworkProfile>
     </TargetFrameworkProfile>
-    <NuGetPackageImportStamp>d37384c8</NuGetPackageImportStamp>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -50,17 +49,28 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="mscorlib" />
-    <Reference Include="System" />
-    <Reference Include="System.Xml" />
-    <Reference Include="xunit.abstractions">
-      <HintPath>..\packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll</HintPath>
+    <Reference Include="nunit.core, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\nunit.core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="nunit.core.interfaces, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\nunit.core.interfaces.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="nunit.framework, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
+      <Private>True</Private>
     </Reference>
-    <Reference Include="xunit.assert">
-      <HintPath>..\packages\xunit.assert.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.assert.dll</HintPath>
+    <Reference Include="nunit.util, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\nunit.util.dll</HintPath>
+      <Private>True</Private>
     </Reference>
-    <Reference Include="xunit.core">
-      <HintPath>..\packages\xunit.extensibility.core.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.dll</HintPath>
+    <Reference Include="NUnit.VisualStudio.TestAdapter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=4cb40d35494691ac, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\NUnit.VisualStudio.TestAdapter.dll</HintPath>
+      <Private>True</Private>
     </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AbstractMessageTest.cs" />
@@ -144,11 +154,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props'))" />
-    <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props'))" />
-  </Target>
 </Project>
\ No newline at end of file

csharp/src/ProtocolBuffers.Test/ReusableBuilderTest.cs

@@ -2,14 +2,14 @@
 using Google.ProtocolBuffers.Collections;
 using Google.ProtocolBuffers.TestProtos;
 using UnitTest.Issues.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class ReusableBuilderTest
     {
         //Issue 28: Circular message dependencies result in null defaults for DefaultInstance
-        [Fact]
+        [Test]
         public void EnsureStaticCicularReference()
         {
             MyMessageAReferenceB ab = MyMessageAReferenceB.DefaultInstance;
@@ -20,24 +20,24 @@ namespace Google.ProtocolBuffers
             Assert.NotNull(ba.Value);
         }
 
-        [Fact]
+        [Test]
         public void TestModifyDefaultInstance()
         {
             //verify that the default instance has correctly been marked as read-only
-            Assert.Equal(typeof(PopsicleList<bool>), TestAllTypes.DefaultInstance.RepeatedBoolList.GetType());
+            Assert.AreEqual(typeof(PopsicleList<bool>), TestAllTypes.DefaultInstance.RepeatedBoolList.GetType());
             PopsicleList<bool> list = (PopsicleList<bool>)TestAllTypes.DefaultInstance.RepeatedBoolList;
-            Assert.True(list.IsReadOnly);
+            Assert.IsTrue(list.IsReadOnly);
         }
 
-        [Fact]
+        [Test]
         public void TestUnmodifiedDefaultInstance()
         {
             //Simply calling ToBuilder().Build() no longer creates a copy of the message
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void BuildMultipleWithoutChange()
         {
             //Calling Build() or BuildPartial() does not require a copy of the message
@@ -46,31 +46,31 @@ namespace Google.ProtocolBuffers
 
             TestAllTypes first = builder.BuildPartial();
             //Still the same instance?
-            Assert.True(ReferenceEquals(first, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(first, builder.Build()));
             //Still the same instance?
-            Assert.True(ReferenceEquals(first, builder.BuildPartial().ToBuilder().Build()));
+            Assert.IsTrue(ReferenceEquals(first, builder.BuildPartial().ToBuilder().Build()));
         }
 
-        [Fact]
+        [Test]
         public void MergeFromDefaultInstance()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             builder.MergeFrom(TestAllTypes.DefaultInstance);
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void BuildNewBuilderIsDefaultInstance()
         {
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, new TestAllTypes.Builder().Build()));
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, new TestAllTypes.Builder().Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().Build()));
             //last test, if you clear a builder it reverts to default instance
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance,
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance,
                 TestAllTypes.CreateBuilder().SetOptionalBool(true).Build().ToBuilder().Clear().Build()));
         }
 
-        [Fact]
+        [Test]
         public void BuildModifyAndRebuild()
         {
             TestAllTypes.Builder b1 = new TestAllTypes.Builder();
@@ -86,80 +86,80 @@ namespace Google.ProtocolBuffers
 
             TestAllTypes m2 = b1.Build();
             
-            Assert.Equal("{\"optional_foreign_message\":{},\"repeated_int32\":[2],\"default_int32\":1}", Extensions.ToJson(m1));
-            Assert.Equal("{\"optional_foreign_message\":{\"c\":7},\"repeated_int32\":[2,6],\"default_int32\":5}", Extensions.ToJson(m2));
+            Assert.AreEqual("{\"optional_foreign_message\":{},\"repeated_int32\":[2],\"default_int32\":1}", Extensions.ToJson(m1));
+            Assert.AreEqual("{\"optional_foreign_message\":{\"c\":7},\"repeated_int32\":[2,6],\"default_int32\":5}", Extensions.ToJson(m2));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnChangePrimitive()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             builder.SetDefaultBool(true);
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnAddRepeatedBool()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             builder.AddRepeatedBool(true);
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnGetRepeatedBoolList()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             GC.KeepAlive(builder.RepeatedBoolList);
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnChangeMessage()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             builder.SetOptionalForeignMessage(new ForeignMessage.Builder());
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnClearMessage()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             builder.ClearOptionalForeignMessage();
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnGetRepeatedForeignMessageList()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             GC.KeepAlive(builder.RepeatedForeignMessageList);
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnChangeEnumValue()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             builder.SetOptionalForeignEnum(ForeignEnum.FOREIGN_BAR);
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
-        [Fact]
+        [Test]
         public void CloneOnGetRepeatedForeignEnumList()
         {
             TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
-            Assert.True(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
             GC.KeepAlive(builder.RepeatedForeignEnumList);
-            Assert.False(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
+            Assert.IsFalse(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
         }
 
     }

csharp/src/ProtocolBuffers.Test/TestCornerCases.cs

 using UnitTest.Issues.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class TestCornerCases
     {
-        [Fact]
+        [Test]
         public void TestRoundTripNegativeEnums()
         {
             NegativeEnumMessage msg = NegativeEnumMessage.CreateBuilder()
@@ -19,16 +19,16 @@ namespace Google.ProtocolBuffers
                 .AddPackedValues(NegativeEnum.FiveBelow) //10
                 .Build();
 
-            Assert.Equal(58, msg.SerializedSize);
+            Assert.AreEqual(58, msg.SerializedSize);
 
             byte[] bytes = new byte[58];
             CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
 
             msg.WriteTo(output);
-            Assert.Equal(0, output.SpaceLeft);
+            Assert.AreEqual(0, output.SpaceLeft);
 
             NegativeEnumMessage copy = NegativeEnumMessage.ParseFrom(bytes);
-            Assert.Equal(msg, copy);
+            Assert.AreEqual(msg, copy);
         }
     }
 }

csharp/src/ProtocolBuffers.Test/TestReaderForUrlEncoded.cs

@@ -3,13 +3,13 @@ using System.IO;
 using System.Text;
 using Google.ProtocolBuffers.TestProtos;
 using Google.ProtocolBuffers.Serialization.Http;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class TestReaderForUrlEncoded
     {
-        [Fact]
+        [Test]
         public void Example_FromQueryString()
         {
             Uri sampleUri = new Uri("http://sample.com/Path/File.ext?text=two+three%20four&valid=true&numbers=1&numbers=2", UriKind.Absolute);
@@ -20,14 +20,14 @@ namespace Google.ProtocolBuffers
             builder.MergeFrom(input);
             
             TestXmlMessage message = builder.Build();
-            Assert.Equal(true, message.Valid);
-            Assert.Equal("two three four", message.Text);
-            Assert.Equal(2, message.NumbersCount);
-            Assert.Equal(1, message.NumbersList[0]);
-            Assert.Equal(2, message.NumbersList[1]);
+            Assert.AreEqual(true, message.Valid);
+            Assert.AreEqual("two three four", message.Text);
+            Assert.AreEqual(2, message.NumbersCount);
+            Assert.AreEqual(1, message.NumbersList[0]);
+            Assert.AreEqual(2, message.NumbersList[1]);
         }
 
-        [Fact]
+        [Test]
         public void Example_FromFormData()
         {
             Stream rawPost = new MemoryStream(Encoding.UTF8.GetBytes("text=two+three%20four&valid=true&numbers=1&numbers=2"), false);
@@ -38,42 +38,42 @@ namespace Google.ProtocolBuffers
             builder.MergeFrom(input);
 
             TestXmlMessage message = builder.Build();
-            Assert.Equal(true, message.Valid);
-            Assert.Equal("two three four", message.Text);
-            Assert.Equal(2, message.NumbersCount);
-            Assert.Equal(1, message.NumbersList[0]);
-            Assert.Equal(2, message.NumbersList[1]);
+            Assert.AreEqual(true, message.Valid);
+            Assert.AreEqual("two three four", message.Text);
+            Assert.AreEqual(2, message.NumbersCount);
+            Assert.AreEqual(1, message.NumbersList[0]);
+            Assert.AreEqual(2, message.NumbersList[1]);
         }
 
-        [Fact]
+        [Test]
         public void TestEmptyValues()
         {
             ICodedInputStream input = FormUrlEncodedReader.CreateInstance("valid=true&text=&numbers=1");
             TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder();
             builder.MergeFrom(input);
 
-            Assert.True(builder.Valid);
-            Assert.True(builder.HasText);
-            Assert.Equal("", builder.Text);
-            Assert.Equal(1, builder.NumbersCount);
-            Assert.Equal(1, builder.NumbersList[0]);
+            Assert.IsTrue(builder.Valid);
+            Assert.IsTrue(builder.HasText);
+            Assert.AreEqual("", builder.Text);
+            Assert.AreEqual(1, builder.NumbersCount);
+            Assert.AreEqual(1, builder.NumbersList[0]);
         }
 
-        [Fact]
+        [Test]
         public void TestNoValue()
         {
             ICodedInputStream input = FormUrlEncodedReader.CreateInstance("valid=true&text&numbers=1");
             TestXmlMessage.Builder builder = TestXmlMessage.CreateBuilder();
             builder.MergeFrom(input);
 
-            Assert.True(builder.Valid);
-            Assert.True(builder.HasText);
-            Assert.Equal("", builder.Text);
-            Assert.Equal(1, builder.NumbersCount);
-            Assert.Equal(1, builder.NumbersList[0]);
+            Assert.IsTrue(builder.Valid);
+            Assert.IsTrue(builder.HasText);
+            Assert.AreEqual("", builder.Text);
+            Assert.AreEqual(1, builder.NumbersCount);
+            Assert.AreEqual(1, builder.NumbersList[0]);
         }
 
-        [Fact]
+        [Test]
         public void FormUrlEncodedReaderDoesNotSupportChildren()
         {
             ICodedInputStream input = FormUrlEncodedReader.CreateInstance("child=uh0");

csharp/src/ProtocolBuffers.Test/packages.config

 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="xunit" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.abstractions" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.assert" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.core" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.extensibility.core" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.runner.visualstudio" version="2.0.0" targetFramework="net45" />
+  <package id="NUnit" version="2.6.4" targetFramework="net45" userInstalled="true" />
+  <package id="NUnitTestAdapter" version="2.0.0" targetFramework="net45" userInstalled="true" />
 </packages>
\ No newline at end of file

csharp/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs

@@ -37,13 +37,13 @@
 using System;
 using System.IO;
 using Google.ProtocolBuffers.TestProtos;
-using Xunit;
+using NUnit.Framework;
 
 namespace Google.ProtocolBuffers
 {
     public class AbstractMessageLiteTest
     {
-        [Fact]
+        [Test]
         public void TestMessageLiteToByteString()
         {
             TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -52,14 +52,14 @@ namespace Google.ProtocolBuffers
                 .Build();
 
             ByteString b = msg.ToByteString();
-            Assert.Equal(4, b.Length);
-            Assert.Equal(TestRequiredLite.DFieldNumber << 3, b[0]);
-            Assert.Equal(42, b[1]);
-            Assert.Equal(TestRequiredLite.EnFieldNumber << 3, b[2]);
-            Assert.Equal((int) ExtraEnum.EXLITE_BAZ, b[3]);
+            Assert.AreEqual(4, b.Length);
+            Assert.AreEqual(TestRequiredLite.DFieldNumber << 3, b[0]);
+            Assert.AreEqual(42, b[1]);
+            Assert.AreEqual(TestRequiredLite.EnFieldNumber << 3, b[2]);
+            Assert.AreEqual((int) ExtraEnum.EXLITE_BAZ, b[3]);
         }
 
-        [Fact]
+        [Test]
         public void TestMessageLiteToByteArray()
         {
             TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -69,10 +69,10 @@ namespace Google.ProtocolBuffers
 
             ByteString b = msg.ToByteString();
             ByteString copy = ByteString.CopyFrom(msg.ToByteArray());
-            Assert.Equal(b, copy);
+            Assert.AreEqual(b, copy);
         }
 
-        [Fact]
+        [Test]
         public void TestMessageLiteWriteTo()
         {
             TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -82,10 +82,10 @@ namespace Google.ProtocolBuffers
 
             MemoryStream ms = new MemoryStream();
             msg.WriteTo(ms);
-            Assert.Equal(msg.ToByteArray(), ms.ToArray());
+            Assert.AreEqual(msg.ToByteArray(), ms.ToArray());
         }
 
-        [Fact]
+        [Test]
         public void TestMessageLiteWriteDelimitedTo()
         {
             TestRequiredLite msg = TestRequiredLite.CreateBuilder()
@@ -97,21 +97,21 @@ namespace Google.ProtocolBuffers
             msg.WriteDelimitedTo(ms);
             byte[] buffer = ms.ToArray();
 
-            Assert.Equal(5, buffer.Length);
-            Assert.Equal(4, buffer[0]);
+            Assert.AreEqual(5, buffer.Length);
+            Assert.AreEqual(4, buffer[0]);
             byte[] msgBytes = new byte[4];
             Array.Copy(buffer, 1, msgBytes, 0, 4);
-            Assert.Equal(msg.ToByteArray(), msgBytes);
+            Assert.AreEqual(msg.ToByteArray(), msgBytes);
         }
 
-        [Fact]
+        [Test]
         public void TestIMessageLiteWeakCreateBuilderForType()
         {
             IMessageLite msg = TestRequiredLite.DefaultInstance;
-            Assert.Equal(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());
+            Assert.AreEqual(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());
         }
 
-        [Fact]
+        [Test]
         public void TestMessageLiteWeakToBuilder()
         {
             IMessageLite msg = TestRequiredLite.CreateBuilder()
@@ -120,14 +120,14 @@ namespace Google.ProtocolBuffers
                 .Build();
 
             IMessageLite copy = msg.WeakToBuilder().WeakBuild();
-            Assert.Equal(msg.ToByteArray(), copy.ToByteArray());
+            Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
         }
 
-        [Fact]
+        [Test]
         public void TestMessageLiteWeakDefaultInstanceForType()
         {
             IMessageLite msg = TestRequiredLite.DefaultInstance;
-            Assert.True(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType));
+            Assert.IsTrue(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType));
         }
     }
 }
\ No newline at end of file

csharp/src/ProtocolBuffersLite.Test/packages.config

 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="xunit" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.abstractions" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.assert" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.core" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.extensibility.core" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.runner.visualstudio" version="2.0.0" targetFramework="net45" />
+  <package id="NUnit" version="2.6.4" targetFramework="net45" userInstalled="true" />
+  <package id="NUnitTestAdapter" version="2.0.0" targetFramework="net45" userInstalled="true" />
 </packages>
\ No newline at end of file