reformatted all code to .NET standard formatting

8 files changed, 1201 insertions, 1041 deletions

diff --git a/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs b/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
index b2c743f3..2a612a9c 100644
--- a/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
+++ b/src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
@@ -1,4 +1,5 @@
-#region Copyright notice and license

+#region Copyright notice and license

+

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

 // http://github.com/jskeet/dotnet-protobufs/

@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

 #endregion

 

 using System;

@@ -39,230 +41,269 @@ using Google.ProtocolBuffers;
 using Google.ProtocolBuffers.TestProtos;

 using NUnit.Framework;

 

-namespace Google.ProtocolBuffers {

-  [TestFixture]

-  public class AbstractBuilderLiteTest {

-

-    [Test]

-    public void TestMergeFromCodedInputStream() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalUint32(uint.MaxValue).Build();

-

-      copy = TestAllTypesLite.DefaultInstance;

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

-

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

-        CodedInputStream ci = CodedInputStream.CreateInstance(ms);

-        copy = copy.ToBuilder().MergeFrom(ci).Build();

-      }

-

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

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakClear() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.DefaultInstance;

-

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

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

-

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

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

-    }

-

-    [Test]

-    public void TestBuilderLiteMergeFromCodedInputStream() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalString("Should be merged.").Build();

-

-      copy = TestAllTypesLite.DefaultInstance;

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

-

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

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

-    }

-

-    [Test]

-    public void TestBuilderLiteMergeDelimitedFrom() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalString("Should be merged.").Build();

-

-      copy = TestAllTypesLite.DefaultInstance;

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

-      Stream s = new MemoryStream();

-      msg.WriteDelimitedTo(s);

-      s.Position = 0;

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

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

-    }

-

-    [Test]

-    public void TestBuilderLiteMergeDelimitedFromExtensions() {

-      TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder()

-        .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build();

-

-      copy = TestAllExtensionsLite.DefaultInstance;

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

-

-      Stream s = new MemoryStream();

-      msg.WriteDelimitedTo(s);

-      s.Position = 0;

-

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);

-

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

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

-      Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));

-    }

-

-    [Test]

-    public void TestBuilderLiteMergeFromStream() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalString("Should be merged.").Build();

-

-      copy = TestAllTypesLite.DefaultInstance;

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

-      Stream s = new MemoryStream();

-      msg.WriteTo(s);

-      s.Position = 0;

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

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

-    }

-

-    [Test]

-    public void TestBuilderLiteMergeFromStreamExtensions() {

-      TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder()

-        .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build();

-

-      copy = TestAllExtensionsLite.DefaultInstance;

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

-

-      Stream s = new MemoryStream();

-      msg.WriteTo(s);

-      s.Position = 0;

-

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);

-

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

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

-      Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakMergeFromIMessageLite() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalString("Should be merged.").Build();

-

-      copy = TestAllTypesLite.DefaultInstance;

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

-

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

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

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakMergeFromByteString() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalString("Should be merged.").Build();

-

-      copy = TestAllTypesLite.DefaultInstance;

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

-

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

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

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakMergeFromByteStringExtensions() {

-      TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder()

-        .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build();

-

-      copy = TestAllExtensionsLite.DefaultInstance;

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

-

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

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

-

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);

-

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

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

-      Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));

-    }

-    

-    [Test]

-    public void TestIBuilderLiteWeakMergeFromCodedInputStream() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalUint32(uint.MaxValue).Build();

-

-      copy = TestAllTypesLite.DefaultInstance;

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

-

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

-        CodedInputStream ci = CodedInputStream.CreateInstance(ms);

-        copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(ci).WeakBuild();

-      }

-

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

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakBuildPartial() {

-      IBuilderLite builder = TestRequiredLite.CreateBuilder();

-      Assert.IsFalse(builder.IsInitialized);

-

-      IMessageLite msg = builder.WeakBuildPartial();

-      Assert.IsFalse(msg.IsInitialized);

-

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

-    }

-

-    [Test, ExpectedException(typeof(UninitializedMessageException ))]

-    public void TestIBuilderLiteWeakBuildUninitialized() {

-      IBuilderLite builder = TestRequiredLite.CreateBuilder();

-      Assert.IsFalse(builder.IsInitialized);

-      builder.WeakBuild();

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakBuild() {

-      IBuilderLite builder = TestRequiredLite.CreateBuilder()

-        .SetD(0)

-        .SetEn(ExtraEnum.EXLITE_BAZ);

-      Assert.IsTrue(builder.IsInitialized);

-      builder.WeakBuild();

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakClone() {

-      TestRequiredLite msg = TestRequiredLite.CreateBuilder()

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

-      Assert.IsTrue(msg.IsInitialized);

-

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

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

-    }

-

-    [Test]

-    public void TestIBuilderLiteWeakDefaultInstance() {

-      Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance,

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

-    }

-

-    [Test]

-    public void TestGeneratedBuilderLiteAddRange() {

-      TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()

-        .SetOptionalUint32(123)

-        .AddRepeatedInt32(1)

-        .AddRepeatedInt32(2)

-        .AddRepeatedInt32(3)

-        .Build();

-

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

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

+namespace Google.ProtocolBuffers

+{

+    [TestFixture]

+    public class AbstractBuilderLiteTest

+    {

+        [Test]

+        public void TestMergeFromCodedInputStream()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalUint32(uint.MaxValue).Build();

+

+            copy = TestAllTypesLite.DefaultInstance;

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

+

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

+            {

+                CodedInputStream ci = CodedInputStream.CreateInstance(ms);

+                copy = copy.ToBuilder().MergeFrom(ci).Build();

+            }

+

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

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakClear()

+        {

+            TestAllTypesLite copy, msg = TestAllTypesLite.DefaultInstance;

+

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

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

+

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

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

+        }

+

+        [Test]

+        public void TestBuilderLiteMergeFromCodedInputStream()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalString("Should be merged.").Build();

+

+            copy = TestAllTypesLite.DefaultInstance;

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

+

+            copy =

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

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

+        }

+

+        [Test]

+        public void TestBuilderLiteMergeDelimitedFrom()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalString("Should be merged.").Build();

+

+            copy = TestAllTypesLite.DefaultInstance;

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

+            Stream s = new MemoryStream();

+            msg.WriteDelimitedTo(s);

+            s.Position = 0;

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

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

+        }

+

+        [Test]

+        public void TestBuilderLiteMergeDelimitedFromExtensions()

+        {

+            TestAllExtensionsLite copy,

+                                  msg = TestAllExtensionsLite.CreateBuilder()

+                                      .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite,

+                                                    "Should be merged.").Build();

+

+            copy = TestAllExtensionsLite.DefaultInstance;

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

+

+            Stream s = new MemoryStream();

+            msg.WriteDelimitedTo(s);

+            s.Position = 0;

+

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestLiteProtoFile.RegisterAllExtensions(registry);

+

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

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

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

+        }

+

+        [Test]

+        public void TestBuilderLiteMergeFromStream()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalString("Should be merged.").Build();

+

+            copy = TestAllTypesLite.DefaultInstance;

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

+            Stream s = new MemoryStream();

+            msg.WriteTo(s);

+            s.Position = 0;

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

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

+        }

+

+        [Test]

+        public void TestBuilderLiteMergeFromStreamExtensions()

+        {

+            TestAllExtensionsLite copy,

+                                  msg = TestAllExtensionsLite.CreateBuilder()

+                                      .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite,

+                                                    "Should be merged.").Build();

+

+            copy = TestAllExtensionsLite.DefaultInstance;

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

+

+            Stream s = new MemoryStream();

+            msg.WriteTo(s);

+            s.Position = 0;

+

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestLiteProtoFile.RegisterAllExtensions(registry);

+

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

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

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

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakMergeFromIMessageLite()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalString("Should be merged.").Build();

+

+            copy = TestAllTypesLite.DefaultInstance;

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

+

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

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

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakMergeFromByteString()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalString("Should be merged.").Build();

+

+            copy = TestAllTypesLite.DefaultInstance;

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

+

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

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

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakMergeFromByteStringExtensions()

+        {

+            TestAllExtensionsLite copy,

+                                  msg = TestAllExtensionsLite.CreateBuilder()

+                                      .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite,

+                                                    "Should be merged.").Build();

+

+            copy = TestAllExtensionsLite.DefaultInstance;

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

+

+            copy =

+                (TestAllExtensionsLite)

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

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

+

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestLiteProtoFile.RegisterAllExtensions(registry);

+

+            copy =

+                (TestAllExtensionsLite)

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

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

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

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakMergeFromCodedInputStream()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalUint32(uint.MaxValue).Build();

+

+            copy = TestAllTypesLite.DefaultInstance;

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

+

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

+            {

+                CodedInputStream ci = CodedInputStream.CreateInstance(ms);

+                copy = (TestAllTypesLite) ((IBuilderLite) copy.ToBuilder()).WeakMergeFrom(ci).WeakBuild();

+            }

+

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

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakBuildPartial()

+        {

+            IBuilderLite builder = TestRequiredLite.CreateBuilder();

+            Assert.IsFalse(builder.IsInitialized);

+

+            IMessageLite msg = builder.WeakBuildPartial();

+            Assert.IsFalse(msg.IsInitialized);

+

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

+        }

+

+        [Test, ExpectedException(typeof (UninitializedMessageException))]

+        public void TestIBuilderLiteWeakBuildUninitialized()

+        {

+            IBuilderLite builder = TestRequiredLite.CreateBuilder();

+            Assert.IsFalse(builder.IsInitialized);

+            builder.WeakBuild();

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakBuild()

+        {

+            IBuilderLite builder = TestRequiredLite.CreateBuilder()

+                .SetD(0)

+                .SetEn(ExtraEnum.EXLITE_BAZ);

+            Assert.IsTrue(builder.IsInitialized);

+            builder.WeakBuild();

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakClone()

+        {

+            TestRequiredLite msg = TestRequiredLite.CreateBuilder()

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

+            Assert.IsTrue(msg.IsInitialized);

+

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

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

+        }

+

+        [Test]

+        public void TestIBuilderLiteWeakDefaultInstance()

+        {

+            Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance,

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

+        }

+

+        [Test]

+        public void TestGeneratedBuilderLiteAddRange()

+        {

+            TestAllTypesLite copy,

+                             msg = TestAllTypesLite.CreateBuilder()

+                                 .SetOptionalUint32(123)

+                                 .AddRepeatedInt32(1)

+                                 .AddRepeatedInt32(2)

+                                 .AddRepeatedInt32(3)

+                                 .Build();

+

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

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

+        }

     }

-  }

-}

+}
\ No newline at end of file
diff --git a/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs b/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs
index 0391308b..5ef9636d 100644
--- a/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs
+++ b/src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs
@@ -1,4 +1,5 @@
-#region Copyright notice and license

+#region Copyright notice and license

+

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

 // http://github.com/jskeet/dotnet-protobufs/

@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

 #endregion

 

 using System;

@@ -39,88 +41,96 @@ using Google.ProtocolBuffers;
 using Google.ProtocolBuffers.TestProtos;

 using NUnit.Framework;

 

-namespace Google.ProtocolBuffers {

-  [TestFixture]

-  public class AbstractMessageLiteTest {

-

-    [Test]

-    public void TestMessageLiteToByteString() {

-      TestRequiredLite msg = TestRequiredLite.CreateBuilder()

-        .SetD(42)

-        .SetEn(ExtraEnum.EXLITE_BAZ)

-        .Build();

-      

-      ByteString b = msg.ToByteString();

-      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]);

-    }

+namespace Google.ProtocolBuffers

+{

+    [TestFixture]

+    public class AbstractMessageLiteTest

+    {

+        [Test]

+        public void TestMessageLiteToByteString()

+        {

+            TestRequiredLite msg = TestRequiredLite.CreateBuilder()

+                .SetD(42)

+                .SetEn(ExtraEnum.EXLITE_BAZ)

+                .Build();

 

-    [Test]

-    public void TestMessageLiteToByteArray() {

-      TestRequiredLite msg = TestRequiredLite.CreateBuilder()

-        .SetD(42)

-        .SetEn(ExtraEnum.EXLITE_BAZ)

-        .Build();

+            ByteString b = msg.ToByteString();

+            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]);

+        }

 

-      ByteString b = msg.ToByteString();

-      ByteString copy = ByteString.CopyFrom(msg.ToByteArray());

-      Assert.AreEqual(b, copy);

-    }

+        [Test]

+        public void TestMessageLiteToByteArray()

+        {

+            TestRequiredLite msg = TestRequiredLite.CreateBuilder()

+                .SetD(42)

+                .SetEn(ExtraEnum.EXLITE_BAZ)

+                .Build();

 

-    [Test]

-    public void TestMessageLiteWriteTo() {

-      TestRequiredLite msg = TestRequiredLite.CreateBuilder()

-        .SetD(42)

-        .SetEn(ExtraEnum.EXLITE_BAZ)

-        .Build();

+            ByteString b = msg.ToByteString();

+            ByteString copy = ByteString.CopyFrom(msg.ToByteArray());

+            Assert.AreEqual(b, copy);

+        }

 

-      MemoryStream ms = new MemoryStream();

-      msg.WriteTo(ms);

-      Assert.AreEqual(msg.ToByteArray(), ms.ToArray());

-    }

+        [Test]

+        public void TestMessageLiteWriteTo()

+        {

+            TestRequiredLite msg = TestRequiredLite.CreateBuilder()

+                .SetD(42)

+                .SetEn(ExtraEnum.EXLITE_BAZ)

+                .Build();

 

-    [Test]

-    public void TestMessageLiteWriteDelimitedTo() {

-      TestRequiredLite msg = TestRequiredLite.CreateBuilder()

-        .SetD(42)

-        .SetEn(ExtraEnum.EXLITE_BAZ)

-        .Build();

-

-      MemoryStream ms = new MemoryStream();

-      msg.WriteDelimitedTo(ms);

-      byte[] buffer = ms.ToArray();

-

-      Assert.AreEqual(5, buffer.Length);

-      Assert.AreEqual(4, buffer[0]);

-      byte[] msgBytes = new byte[4];

-      Array.Copy(buffer, 1, msgBytes, 0, 4);

-      Assert.AreEqual(msg.ToByteArray(), msgBytes);

-    }

+            MemoryStream ms = new MemoryStream();

+            msg.WriteTo(ms);

+            Assert.AreEqual(msg.ToByteArray(), ms.ToArray());

+        }

 

-    [Test]

-    public void TestIMessageLiteWeakCreateBuilderForType() {

-      IMessageLite msg = TestRequiredLite.DefaultInstance;

-      Assert.AreEqual(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());

-    }

+        [Test]

+        public void TestMessageLiteWriteDelimitedTo()

+        {

+            TestRequiredLite msg = TestRequiredLite.CreateBuilder()

+                .SetD(42)

+                .SetEn(ExtraEnum.EXLITE_BAZ)

+                .Build();

 

-    [Test]

-    public void TestMessageLiteWeakToBuilder() {

-      IMessageLite msg = TestRequiredLite.CreateBuilder()

-        .SetD(42)

-        .SetEn(ExtraEnum.EXLITE_BAZ)

-        .Build();

+            MemoryStream ms = new MemoryStream();

+            msg.WriteDelimitedTo(ms);

+            byte[] buffer = ms.ToArray();

 

-      IMessageLite copy = msg.WeakToBuilder().WeakBuild();

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

-    }

+            Assert.AreEqual(5, buffer.Length);

+            Assert.AreEqual(4, buffer[0]);

+            byte[] msgBytes = new byte[4];

+            Array.Copy(buffer, 1, msgBytes, 0, 4);

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

+        }

+

+        [Test]

+        public void TestIMessageLiteWeakCreateBuilderForType()

+        {

+            IMessageLite msg = TestRequiredLite.DefaultInstance;

+            Assert.AreEqual(typeof (TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());

+        }

+

+        [Test]

+        public void TestMessageLiteWeakToBuilder()

+        {

+            IMessageLite msg = TestRequiredLite.CreateBuilder()

+                .SetD(42)

+                .SetEn(ExtraEnum.EXLITE_BAZ)

+                .Build();

+

+            IMessageLite copy = msg.WeakToBuilder().WeakBuild();

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

+        }

 

-    [Test]

-    public void TestMessageLiteWeakDefaultInstanceForType() {

-      IMessageLite msg = TestRequiredLite.DefaultInstance;

-      Assert.IsTrue(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType));

+        [Test]

+        public void TestMessageLiteWeakDefaultInstanceForType()

+        {

+            IMessageLite msg = TestRequiredLite.DefaultInstance;

+            Assert.IsTrue(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType));

+        }

     }

-  }

-}

+}
\ No newline at end of file
diff --git a/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs b/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs
index f4e7fccc..75580473 100644
--- a/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs
+++ b/src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs
@@ -1,4 +1,5 @@
-#region Copyright notice and license

+#region Copyright notice and license

+

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

 // http://github.com/jskeet/dotnet-protobufs/

@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

 #endregion

 

 using System;

@@ -39,229 +41,249 @@ using Google.ProtocolBuffers;
 using Google.ProtocolBuffers.TestProtos;

 using NUnit.Framework;

 

-namespace Google.ProtocolBuffers {

-  [TestFixture]

-  public class ExtendableBuilderLiteTest {

-

-    [Test]

-    public void TestHasExtensionT() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-          .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123);

-

-      Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestHasExtensionTMissing() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestGetExtensionCountT() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3);

-

-      Assert.AreEqual(3, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestGetExtensionCountTEmpty() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestGetExtensionTNull() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      string value = builder.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite);

-      Assert.IsNull(value);

-    }

-

-    [Test]

-    public void TestGetExtensionTValue() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-          .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 3);

-

-      Assert.AreEqual(3, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestGetExtensionTEmpty() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      Assert.AreEqual(0, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite).Count);

-    }

-

-    [Test]

-    public void TestGetExtensionTList() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3);

-

-      IList<int> values = builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite);

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

-    }

-

-    [Test]

-    public void TestGetExtensionTIndex() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2);

-

-      for(int i = 0; i < 3; i++ )

-        Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));

-    }

-

-    [Test,ExpectedException(typeof(ArgumentOutOfRangeException))]

-    public void TestGetExtensionTIndexOutOfRange() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

-    }

-

-    [Test]

-    public void TestSetExtensionTIndex() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2);

-

-      for (int i = 0; i < 3; i++)

-        Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));

-

-      builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, 5);

-      builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1, 6);

-      builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2, 7);

-

-      for (int i = 0; i < 3; i++)

-        Assert.AreEqual(5 + i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));

-    }

-

-    [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]

-    public void TestSetExtensionTIndexOutOfRange() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, -1);

-    }

-

-    [Test]

-    public void TestClearExtensionTList() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-        .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

-      Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-      

-      builder.ClearExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite);

-      Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestClearExtensionTValue() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-        .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 0);

-      Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-

-      builder.ClearExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite);

-      Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestIndexedByDescriptor() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-      

-      builder[UnitTestLiteProtoFile.OptionalInt32ExtensionLite.Descriptor] = 123;

-      

-      Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-      Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestIndexedByDescriptorAndOrdinal() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-        .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

-      Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-

-      IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

-      builder[f, 0] = 123;

-

-      Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-      Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0));

-    }

-

-    [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]

-    public void TestIndexedByDescriptorAndOrdinalOutOfRange() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-      Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-

-      IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

-      builder[f, 0] = 123;

-    }

-

-    [Test]

-    public void TestClearFieldByDescriptor() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-        .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

-      Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-

-      IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

-      builder.ClearField(f);

-      Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-    }

-

-    [Test]

-    public void TestAddRepeatedFieldByDescriptor() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-        .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

-      Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-

-      IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

-      builder.AddRepeatedField(f, 123);

-      Assert.AreEqual(2, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

-      Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1));

-    }

-

-    [Test]

-    public void TestMissingExtensionsLite()

-    {

-        const int optionalInt32 = 12345678;

-        TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

-        builder.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, optionalInt32);

-        builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.1);

-        builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.2);

-        builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.3);

-        TestAllExtensionsLite msg = builder.Build();

-

-        Assert.IsTrue(msg.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-        Assert.AreEqual(3, msg.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite));

-

-        byte[] bits = msg.ToByteArray();

-        TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);

-        Assert.IsFalse(copy.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-        Assert.AreEqual(0, copy.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite));

-        Assert.AreNotEqual(msg, copy);

-

-        //The lite runtime removes all unknown fields and extensions

-        byte[] copybits = copy.ToByteArray();

-        Assert.AreEqual(0, copybits.Length);

-    }

-

-    [Test]

-    public void TestMissingFieldsLite()

+namespace Google.ProtocolBuffers

+{

+    [TestFixture]

+    public class ExtendableBuilderLiteTest

     {

-        TestAllTypesLite msg = TestAllTypesLite.CreateBuilder()

-            .SetOptionalInt32(123)

-            .SetOptionalString("123")

-            .Build();

-

-        byte[] bits = msg.ToByteArray();

-        TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);

-        Assert.AreNotEqual(msg, copy);

-

-        //The lite runtime removes all unknown fields and extensions

-        byte[] copybits = copy.ToByteArray();

-        Assert.AreEqual(0, copybits.Length);

+        [Test]

+        public void TestHasExtensionT()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123);

+

+            Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestHasExtensionTMissing()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestGetExtensionCountT()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3);

+

+            Assert.AreEqual(3, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestGetExtensionCountTEmpty()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestGetExtensionTNull()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            string value = builder.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite);

+            Assert.IsNull(value);

+        }

+

+        [Test]

+        public void TestGetExtensionTValue()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 3);

+

+            Assert.AreEqual(3, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestGetExtensionTEmpty()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            Assert.AreEqual(0, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite).Count);

+        }

+

+        [Test]

+        public void TestGetExtensionTList()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3);

+

+            IList<int> values = builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite);

+            Assert.AreEqual(3, values.Count);

+        }

+

+        [Test]

+        public void TestGetExtensionTIndex()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2);

+

+            for (int i = 0; i < 3; i++)

+                Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));

+        }

+

+        [Test, ExpectedException(typeof (ArgumentOutOfRangeException))]

+        public void TestGetExtensionTIndexOutOfRange()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

+        }

+

+        [Test]

+        public void TestSetExtensionTIndex()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2);

+

+            for (int i = 0; i < 3; i++)

+                Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));

+

+            builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, 5);

+            builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1, 6);

+            builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2, 7);

+

+            for (int i = 0; i < 3; i++)

+                Assert.AreEqual(5 + i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));

+        }

+

+        [Test, ExpectedException(typeof (ArgumentOutOfRangeException))]

+        public void TestSetExtensionTIndexOutOfRange()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, -1);

+        }

+

+        [Test]

+        public void TestClearExtensionTList()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

+            Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+

+            builder.ClearExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite);

+            Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestClearExtensionTValue()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 0);

+            Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+

+            builder.ClearExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite);

+            Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestIndexedByDescriptor()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+

+            builder[UnitTestLiteProtoFile.OptionalInt32ExtensionLite.Descriptor] = 123;

+

+            Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+            Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestIndexedByDescriptorAndOrdinal()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

+            Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+

+            IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

+            builder[f, 0] = 123;

+

+            Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+            Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0));

+        }

+

+        [Test, ExpectedException(typeof (ArgumentOutOfRangeException))]

+        public void TestIndexedByDescriptorAndOrdinalOutOfRange()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+

+            IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

+            builder[f, 0] = 123;

+        }

+

+        [Test]

+        public void TestClearFieldByDescriptor()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

+            Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+

+            IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

+            builder.ClearField(f);

+            Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+        }

+

+        [Test]

+        public void TestAddRepeatedFieldByDescriptor()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);

+            Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+

+            IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;

+            builder.AddRepeatedField(f, 123);

+            Assert.AreEqual(2, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));

+            Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1));

+        }

+

+        [Test]

+        public void TestMissingExtensionsLite()

+        {

+            const int optionalInt32 = 12345678;

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();

+            builder.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, optionalInt32);

+            builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.1);

+            builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.2);

+            builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.3);

+            TestAllExtensionsLite msg = builder.Build();

+

+            Assert.IsTrue(msg.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+            Assert.AreEqual(3, msg.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite));

+

+            byte[] bits = msg.ToByteArray();

+            TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);

+            Assert.IsFalse(copy.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+            Assert.AreEqual(0, copy.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite));

+            Assert.AreNotEqual(msg, copy);

+

+            //The lite runtime removes all unknown fields and extensions

+            byte[] copybits = copy.ToByteArray();

+            Assert.AreEqual(0, copybits.Length);

+        }

+

+        [Test]

+        public void TestMissingFieldsLite()

+        {

+            TestAllTypesLite msg = TestAllTypesLite.CreateBuilder()

+                .SetOptionalInt32(123)

+                .SetOptionalString("123")

+                .Build();

+

+            byte[] bits = msg.ToByteArray();

+            TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);

+            Assert.AreNotEqual(msg, copy);

+

+            //The lite runtime removes all unknown fields and extensions

+            byte[] copybits = copy.ToByteArray();

+            Assert.AreEqual(0, copybits.Length);

+        }

     }

-  }

-}

+}
\ No newline at end of file
diff --git a/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs b/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs
index 05ad064e..399e3082 100644
--- a/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs
+++ b/src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs
@@ -1,4 +1,5 @@
-#region Copyright notice and license

+#region Copyright notice and license

+

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

 // http://github.com/jskeet/dotnet-protobufs/

@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

 #endregion

 

 using System;

@@ -39,266 +41,292 @@ using Google.ProtocolBuffers;
 using Google.ProtocolBuffers.TestProtos;

 using NUnit.Framework;

 

-namespace Google.ProtocolBuffers {

-  [TestFixture]

-  public class ExtendableMessageLiteTest {

-

-    [Test, Ignore("Not implemented, no assertion made"), ExpectedException(typeof(ArgumentException))]

-    public void ExtensionWriterInvalidExtension() {

-      TestPackedExtensionsLite.CreateBuilder()[UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite.Descriptor] = 

-        ForeignMessageLite.DefaultInstance;

-    }

-

-    [Test]

-    public void ExtensionWriterTestMessages() {

-      TestAllExtensionsLite.Builder b = TestAllExtensionsLite.CreateBuilder().SetExtension(

-        UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.CreateBuilder().SetC(123).Build());

-      TestAllExtensionsLite copy, msg = b.Build();

+namespace Google.ProtocolBuffers

+{

+    [TestFixture]

+    public class ExtendableMessageLiteTest

+    {

+        [Test, Ignore("Not implemented, no assertion made"), ExpectedException(typeof (ArgumentException))]

+        public void ExtensionWriterInvalidExtension()

+        {

+            TestPackedExtensionsLite.CreateBuilder()[

+                UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite.Descriptor] =

+                ForeignMessageLite.DefaultInstance;

+        }

 

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);

+        [Test]

+        public void ExtensionWriterTestMessages()

+        {

+            TestAllExtensionsLite.Builder b = TestAllExtensionsLite.CreateBuilder().SetExtension(

+                UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite,

+                ForeignMessageLite.CreateBuilder().SetC(123).Build());

+            TestAllExtensionsLite copy, msg = b.Build();

 

-      copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);

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

-    }

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestLiteProtoFile.RegisterAllExtensions(registry);

 

-    [Test]

-    public void ExtensionWriterIsInitialized() {

-      Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized);

-      Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized);

-      Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension(

-        UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance)

-        .IsInitialized);

-    }

+            copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);

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

+        }

 

-    [Test]

-    public void ExtensionWriterTestSetExtensionLists() {

-      TestAllExtensionsLite msg, copy;

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-        .SetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, new[] { true, false })

-        .SetExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, new[] { "123", "456" })

-        .SetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, new[] { ForeignEnumLite.FOREIGN_LITE_BAZ, ForeignEnumLite.FOREIGN_LITE_FOO })

-        ;

+        [Test]

+        public void ExtensionWriterIsInitialized()

+        {

+            Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized);

+            Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized);

+            Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension(

+                UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance)

+                              .IsInitialized);

+        }

 

-      msg = builder.Build();

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);

+        [Test]

+        public void ExtensionWriterTestSetExtensionLists()

+        {

+            TestAllExtensionsLite msg, copy;

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .SetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, new[] {true, false})

+                .SetExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, new[] {"123", "456"})

+                .SetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite,

+                              new[] {ForeignEnumLite.FOREIGN_LITE_BAZ, ForeignEnumLite.FOREIGN_LITE_FOO})

+                ;

 

-      copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);

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

+            msg = builder.Build();

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestLiteProtoFile.RegisterAllExtensions(registry);

 

-      Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO, copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 1));

-    }

+            copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);

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

 

-    [Test]

-    public void ExtensionWriterTest() {

-      TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

-        .SetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite, true)

-        .SetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite, ByteString.CopyFromUtf8("123"))

-        .SetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite, "123")

-        .SetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite, 123u)

-        .SetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite, 123u)

-        .SetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)

-        .SetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)

-        .SetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO)

-        .SetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite, "123")

-        .SetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite, "123")

-        .SetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite, 123u)

-        .SetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite, 123u)

-        //Optional

-        .SetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite, true)

-        .SetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite, ByteString.CopyFromUtf8("123"))

-        .SetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite, "123")

-        .SetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite, 123u)

-        .SetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite, 123u)

-        .SetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)

-        .SetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)

-        .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO)

-        .SetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite, 123)

-        .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "123")

-        .SetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite, "123")

-        .SetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite, 123u)

-        .SetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite, 123u)

-        //Repeated

-        .AddExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, true)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedBytesExtensionLite, ByteString.CopyFromUtf8("123"))

-        .AddExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, "123")

-        .AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedSfixed32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "123")

-        .AddExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, "123")

-        .AddExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 123u)

-        ;

-      TestAllExtensionsLite msg = builder.Build();

+            Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO,

+                            copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 1));

+        }

 

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);

+        [Test]

+        public void ExtensionWriterTest()

+        {

+            TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()

+                .SetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite, true)

+                .SetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite, ByteString.CopyFromUtf8("123"))

+                .SetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite, "123")

+                .SetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite, 123u)

+                .SetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite, 123u)

+                .SetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)

+                .SetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)

+                .SetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite,

+                              TestAllTypesLite.Types.NestedEnum.FOO)

+                .SetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite, "123")

+                .SetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite, "123")

+                .SetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite, 123u)

+                .SetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite, 123u)

+                //Optional

+                .SetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite, true)

+                .SetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite, ByteString.CopyFromUtf8("123"))

+                .SetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite, "123")

+                .SetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite, 123u)

+                .SetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite, 123u)

+                .SetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)

+                .SetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)

+                .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite,

+                              TestAllTypesLite.Types.NestedEnum.FOO)

+                .SetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite, 123)

+                .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "123")

+                .SetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite, "123")

+                .SetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite, 123u)

+                .SetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite, 123u)

+                //Repeated

+                .AddExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, true)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedBytesExtensionLite, ByteString.CopyFromUtf8("123"))

+                .AddExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, "123")

+                .AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedNestedEnumExtensionLite,

+                              TestAllTypesLite.Types.NestedEnum.FOO)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedSfixed32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "123")

+                .AddExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, "123")

+                .AddExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 123u)

+                ;

+            TestAllExtensionsLite msg = builder.Build();

 

-      TestAllExtensionsLite.Builder copyBuilder = TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);

-      TestAllExtensionsLite copy = copyBuilder.Build();

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestLiteProtoFile.RegisterAllExtensions(registry);

 

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

+            TestAllExtensionsLite.Builder copyBuilder =

+                TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);

+            TestAllExtensionsLite copy = copyBuilder.Build();

 

-      Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite));

-      Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite));

-      Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite));

-      Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite));

-      Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite));

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

 

-      Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite));

-      Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite));

-      Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite));

-      Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite));

-      Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite));

-

-      Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, 0));

-      Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.RepeatedBytesExtensionLite, 0));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 0));

-      Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 0));

-      Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.RepeatedImportEnumExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 0));

-      Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.RepeatedNestedEnumExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSfixed32ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 0));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0));

-      Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 0));

-    }

+            Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite));

+            Assert.AreEqual(ByteString.CopyFromUtf8("123"),

+                            copy.GetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite));

+            Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ,

+                            copy.GetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite));

+            Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ,

+                            copy.GetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite));

+            Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO,

+                            copy.GetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite));

 

-    [Test]

-    public void ExtensionWriterTestPacked() {

+            Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite));

+            Assert.AreEqual(ByteString.CopyFromUtf8("123"),

+                            copy.GetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite));

+            Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ,

+                            copy.GetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite));

+            Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ,

+                            copy.GetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite));

+            Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO,

+                            copy.GetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite));

 

-      TestPackedExtensionsLite.Builder builder = TestPackedExtensionsLite.CreateBuilder()

-        .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true)

-        .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true)

-        .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123)

-        .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u)

-        .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u);

+            Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, 0));

+            Assert.AreEqual(ByteString.CopyFromUtf8("123"),

+                            copy.GetExtension(UnitTestLiteProtoFile.RepeatedBytesExtensionLite, 0));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 0));

+            Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ,

+                            copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 0));

+            Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ,

+                            copy.GetExtension(UnitTestLiteProtoFile.RepeatedImportEnumExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 0));

+            Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO,

+                            copy.GetExtension(UnitTestLiteProtoFile.RepeatedNestedEnumExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSfixed32ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 0));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0));

+            Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 0));

+        }

 

-      TestPackedExtensionsLite msg = builder.Build();

+        [Test]

+        public void ExtensionWriterTestPacked()

+        {

+            TestPackedExtensionsLite.Builder builder = TestPackedExtensionsLite.CreateBuilder()

+                .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true)

+                .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true)

+                .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123)

+                .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u)

+                .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u);

 

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);

+            TestPackedExtensionsLite msg = builder.Build();

 

-      TestPackedExtensionsLite.Builder copyBuilder = TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);

-      TestPackedExtensionsLite copy = copyBuilder.Build();

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestLiteProtoFile.RegisterAllExtensions(registry);

 

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

+            TestPackedExtensionsLite.Builder copyBuilder =

+                TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);

+            TestPackedExtensionsLite copy = copyBuilder.Build();

 

-      Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 0));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 0));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 0));

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

 

-      Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 1));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 1));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 1));

-      Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 1));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 1));

-      Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 1));

+            Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 0));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 0));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 0));

 

+            Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 1));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 1));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 1));

+            Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 1));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 1));

+            Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 1));

+        }

     }

-  }

-}

+}
\ No newline at end of file
diff --git a/src/ProtocolBuffersLite.Test/InteropLiteTest.cs b/src/ProtocolBuffersLite.Test/InteropLiteTest.cs
index 48537e56..c49e0350 100644
--- a/src/ProtocolBuffersLite.Test/InteropLiteTest.cs
+++ b/src/ProtocolBuffersLite.Test/InteropLiteTest.cs
@@ -1,4 +1,5 @@
-#region Copyright notice and license

+#region Copyright notice and license

+

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

 // http://github.com/jskeet/dotnet-protobufs/

@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

 #endregion

 

 using System;

@@ -38,125 +40,147 @@ using Google.ProtocolBuffers;
 using Google.ProtocolBuffers.TestProtos;

 using NUnit.Framework;

 

-namespace Google.ProtocolBuffers {

-  [TestFixture]

-  public class InteropLiteTest {

-

-    [Test]

-    public void TestConvertFromFullMinimal() {

-      TestInteropPerson person = TestInteropPerson.CreateBuilder()

-        .SetId(123)

-        .SetName("abc")

-        .Build();

-      Assert.IsTrue(person.IsInitialized);

-

-      TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray());

-

-      Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());

-    }

-

-    [Test]

-    public void TestConvertFromFullComplete() {

-      TestInteropPerson person = TestInteropPerson.CreateBuilder()

-        .SetId(123)

-        .SetName("abc")

-        .SetEmail("abc@123.com")

-        .AddRangeCodes(new[] { 1, 2, 3 })

-        .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())

-        .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").Build())

-        .AddAddresses(TestInteropPerson.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())

-        .SetExtension(UnitTestExtrasFullProtoFile.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())

-        .Build();

-      Assert.IsTrue(person.IsInitialized);

-

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestExtrasLiteProtoFile.RegisterAllExtensions(registry);

-

-      TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray(), registry);

-

-      Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());

-    }

-

-    [Test]

-    public void TestConvertFromLiteMinimal() {

-      TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()

-        .SetId(123)

-        .SetName("abc")

-        .Build();

-      Assert.IsTrue(person.IsInitialized);

-

-      TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray());

-

-      Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());

-    }

-

-    [Test]

-    public void TestConvertFromLiteComplete() {

-      TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()

-        .SetId(123)

-        .SetName("abc")

-        .SetEmail("abc@123.com")

-        .AddRangeCodes(new[] { 1, 2, 3 })

-        .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())

-        .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").Build())

-        .AddAddresses(TestInteropPersonLite.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())

-        .SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())

-        .Build();

-      Assert.IsTrue(person.IsInitialized);

-

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);

-

-      TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);

-

-      Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());

-    }

-

-    public ByteString AllBytes {

-      get {

-        byte[] bytes = new byte[256];

-        for (int i = 0; i < bytes.Length; i++)

-          bytes[i] = (byte)i;

-        return ByteString.CopyFrom(bytes);

-      }

-    }

-

-      [Test]

-    public void TestCompareStringValues() {

-      TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()

-        .SetId(123)

-        .SetName("abc")

-        .SetEmail("abc@123.com")

-        .AddRangeCodes(new[] { 1, 2, 3 })

-        .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())

-        .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber(System.Text.Encoding.ASCII.GetString(AllBytes.ToByteArray())).Build())

-        .AddAddresses(TestInteropPersonLite.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())

-        .SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())

-        .Build();

-      Assert.IsTrue(person.IsInitialized);

-

-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

-      UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);

-

-      TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);

-

-      Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());

-

-      TestInteropPerson.Builder copyBuilder = TestInteropPerson.CreateBuilder();

-      TextFormat.Merge(person.ToString().Replace("[protobuf_unittest_extra.employee_id_lite]", "[protobuf_unittest_extra.employee_id]"), registry, copyBuilder);

-

-      copy = copyBuilder.Build();

-      Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());

-

-      string liteText = person.ToString().TrimEnd().Replace("\r", "");

-      string fullText = copy.ToString().TrimEnd().Replace("\r", "");

-      //map the extension type

-      liteText = liteText.Replace("[protobuf_unittest_extra.employee_id_lite]", "[protobuf_unittest_extra.employee_id]");

-      //lite version does not indent

-      while (fullText.IndexOf("\n ") >= 0)

-        fullText = fullText.Replace("\n ", "\n");

-

-      Assert.AreEqual(fullText, liteText);

+namespace Google.ProtocolBuffers

+{

+    [TestFixture]

+    public class InteropLiteTest

+    {

+        [Test]

+        public void TestConvertFromFullMinimal()

+        {

+            TestInteropPerson person = TestInteropPerson.CreateBuilder()

+                .SetId(123)

+                .SetName("abc")

+                .Build();

+            Assert.IsTrue(person.IsInitialized);

+

+            TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray());

+

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

+        }

+

+        [Test]

+        public void TestConvertFromFullComplete()

+        {

+            TestInteropPerson person = TestInteropPerson.CreateBuilder()

+                .SetId(123)

+                .SetName("abc")

+                .SetEmail("abc@123.com")

+                .AddRangeCodes(new[] {1, 2, 3})

+                .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())

+                .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").Build())

+                .AddAddresses(

+                    TestInteropPerson.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").

+                        SetState("NA").SetZip(12345).Build())

+                .SetExtension(UnitTestExtrasFullProtoFile.EmployeeId,

+                              TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())

+                .Build();

+            Assert.IsTrue(person.IsInitialized);

+

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestExtrasLiteProtoFile.RegisterAllExtensions(registry);

+

+            TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray(), registry);

+

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

+        }

+

+        [Test]

+        public void TestConvertFromLiteMinimal()

+        {

+            TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()

+                .SetId(123)

+                .SetName("abc")

+                .Build();

+            Assert.IsTrue(person.IsInitialized);

+

+            TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray());

+

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

+        }

+

+        [Test]

+        public void TestConvertFromLiteComplete()

+        {

+            TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()

+                .SetId(123)

+                .SetName("abc")

+                .SetEmail("abc@123.com")

+                .AddRangeCodes(new[] {1, 2, 3})

+                .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())

+                .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").Build())

+                .AddAddresses(

+                    TestInteropPersonLite.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland")

+                        .SetState("NA").SetZip(12345).Build())

+                .SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite,

+                              TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())

+                .Build();

+            Assert.IsTrue(person.IsInitialized);

+

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);

+

+            TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);

+

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

+        }

+

+        public ByteString AllBytes

+        {

+            get

+            {

+                byte[] bytes = new byte[256];

+                for (int i = 0; i < bytes.Length; i++)

+                    bytes[i] = (byte) i;

+                return ByteString.CopyFrom(bytes);

+            }

+        }

+

+        [Test]

+        public void TestCompareStringValues()

+        {

+            TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()

+                .SetId(123)

+                .SetName("abc")

+                .SetEmail("abc@123.com")

+                .AddRangeCodes(new[] {1, 2, 3})

+                .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())

+                .AddPhone(

+                    TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber(

+                        System.Text.Encoding.ASCII.GetString(AllBytes.ToByteArray())).Build())

+                .AddAddresses(

+                    TestInteropPersonLite.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland")

+                        .SetState("NA").SetZip(12345).Build())

+                .SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite,

+                              TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())

+                .Build();

+            Assert.IsTrue(person.IsInitialized);

+

+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();

+            UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);

+

+            TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);

+

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

+

+            TestInteropPerson.Builder copyBuilder = TestInteropPerson.CreateBuilder();

+            TextFormat.Merge(

+                person.ToString().Replace("[protobuf_unittest_extra.employee_id_lite]",

+                                          "[protobuf_unittest_extra.employee_id]"), registry, copyBuilder);

+

+            copy = copyBuilder.Build();

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

+

+            string liteText = person.ToString().TrimEnd().Replace("\r", "");

+            string fullText = copy.ToString().TrimEnd().Replace("\r", "");

+            //map the extension type

+            liteText = liteText.Replace("[protobuf_unittest_extra.employee_id_lite]",

+                                        "[protobuf_unittest_extra.employee_id]");

+            //lite version does not indent

+            while (fullText.IndexOf("\n ") >= 0)

+                fullText = fullText.Replace("\n ", "\n");

+

+            Assert.AreEqual(fullText, liteText);

+        }

     }

-  }

-}

+}
\ No newline at end of file
diff --git a/src/ProtocolBuffersLite.Test/LiteTest.cs b/src/ProtocolBuffersLite.Test/LiteTest.cs
index ca5c4bff..f1cb949a 100644
--- a/src/ProtocolBuffersLite.Test/LiteTest.cs
+++ b/src/ProtocolBuffersLite.Test/LiteTest.cs
@@ -1,4 +1,5 @@
-#region Copyright notice and license

+#region Copyright notice and license

+

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

 // http://github.com/jskeet/dotnet-protobufs/

@@ -30,6 +31,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

 #endregion

 

 using System;

@@ -39,74 +41,78 @@ using Google.ProtocolBuffers.Descriptors;
 using Google.ProtocolBuffers.TestProtos;

 using NUnit.Framework;

 

-namespace Google.ProtocolBuffers {

-  /// <summary>

-  /// Miscellaneous tests for message operations that apply to both

-  /// generated and dynamic messages.

-  /// </summary>

-  [TestFixture]

-  public class LiteTest {

-    [Test]

-    public void TestLite() {

-      // Since lite messages are a subset of regular messages, we can mostly

-      // assume that the functionality of lite messages is already thoroughly

-      // tested by the regular tests.  All this test really verifies is that

-      // a proto with optimize_for = LITE_RUNTIME compiles correctly when

-      // linked only against the lite library.  That is all tested at compile

-      // time, leaving not much to do in this method.  Let's just do some random

-      // stuff to make sure the lite message is actually here and usable.

+namespace Google.ProtocolBuffers

+{

+    /// <summary>

+    /// Miscellaneous tests for message operations that apply to both

+    /// generated and dynamic messages.

+    /// </summary>

+    [TestFixture]

+    public class LiteTest

+    {

+        [Test]

+        public void TestLite()

+        {

+            // Since lite messages are a subset of regular messages, we can mostly

+            // assume that the functionality of lite messages is already thoroughly

+            // tested by the regular tests.  All this test really verifies is that

+            // a proto with optimize_for = LITE_RUNTIME compiles correctly when

+            // linked only against the lite library.  That is all tested at compile

+            // time, leaving not much to do in this method.  Let's just do some random

+            // stuff to make sure the lite message is actually here and usable.

 

-      TestAllTypesLite message =

-        TestAllTypesLite.CreateBuilder()

-                        .SetOptionalInt32(123)

-                        .AddRepeatedString("hello")

-                        .SetOptionalNestedMessage(

-                            TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7))

-                        .Build();

+            TestAllTypesLite message =

+                TestAllTypesLite.CreateBuilder()

+                    .SetOptionalInt32(123)

+                    .AddRepeatedString("hello")

+                    .SetOptionalNestedMessage(

+                        TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7))

+                    .Build();

 

-      ByteString data = message.ToByteString();

+            ByteString data = message.ToByteString();

 

-      TestAllTypesLite message2 = TestAllTypesLite.ParseFrom(data);

+            TestAllTypesLite message2 = TestAllTypesLite.ParseFrom(data);

 

-      Assert.AreEqual(123, message2.OptionalInt32);

-      Assert.AreEqual(1, message2.RepeatedStringCount);

-      Assert.AreEqual("hello", message2.RepeatedStringList[0]);

-      Assert.AreEqual(7, message2.OptionalNestedMessage.Bb);

-    }

+            Assert.AreEqual(123, message2.OptionalInt32);

+            Assert.AreEqual(1, message2.RepeatedStringCount);

+            Assert.AreEqual("hello", message2.RepeatedStringList[0]);

+            Assert.AreEqual(7, message2.OptionalNestedMessage.Bb);

+        }

 

-    [Test]

-    public void TestLiteExtensions() {

-      // TODO(kenton):  Unlike other features of the lite library, extensions are

-      //   implemented completely differently from the regular library.  We

-      //   should probably test them more thoroughly.

+        [Test]

+        public void TestLiteExtensions()

+        {

+            // TODO(kenton):  Unlike other features of the lite library, extensions are

+            //   implemented completely differently from the regular library.  We

+            //   should probably test them more thoroughly.

 

-      TestAllExtensionsLite message =

-        TestAllExtensionsLite.CreateBuilder()

-          .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123)

-          .AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "hello")

-          .SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite,

-              TestAllTypesLite.Types.NestedEnum.BAZ)

-          .SetExtension(UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite,

-              TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7).Build())

-          .Build();

+            TestAllExtensionsLite message =

+                TestAllExtensionsLite.CreateBuilder()

+                    .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123)

+                    .AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "hello")

+                    .SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite,

+                                  TestAllTypesLite.Types.NestedEnum.BAZ)

+                    .SetExtension(UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite,

+                                  TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7).Build())

+                    .Build();

 

-      // Test copying a message, since coping extensions actually does use a

-      // different code path between lite and regular libraries, and as of this

-      // writing, parsing hasn't been implemented yet.

-      TestAllExtensionsLite message2 = message.ToBuilder().Build();

+            // Test copying a message, since coping extensions actually does use a

+            // different code path between lite and regular libraries, and as of this

+            // writing, parsing hasn't been implemented yet.

+            TestAllExtensionsLite message2 = message.ToBuilder().Build();

 

-      Assert.AreEqual(123, (int)message2.GetExtension(

-          UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

-      Assert.AreEqual(1, message2.GetExtensionCount(

-          UnitTestLiteProtoFile.RepeatedStringExtensionLite));

-      Assert.AreEqual(1, message2.GetExtension(

-          UnitTestLiteProtoFile.RepeatedStringExtensionLite).Count);

-      Assert.AreEqual("hello", message2.GetExtension(

-          UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0));

-      Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension(

-          UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite));

-      Assert.AreEqual(7, message2.GetExtension(

-          UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite).Bb);

+            Assert.AreEqual(123, (int) message2.GetExtension(

+                UnitTestLiteProtoFile.OptionalInt32ExtensionLite));

+            Assert.AreEqual(1, message2.GetExtensionCount(

+                UnitTestLiteProtoFile.RepeatedStringExtensionLite));

+            Assert.AreEqual(1, message2.GetExtension(

+                UnitTestLiteProtoFile.RepeatedStringExtensionLite).Count);

+            Assert.AreEqual("hello", message2.GetExtension(

+                UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0));

+            Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension(

+                UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite));

+            Assert.AreEqual(7, message2.GetExtension(

+                UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite).Bb);

+        }

     }

-  }

 }
\ No newline at end of file
diff --git a/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs b/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs
index f43f709d..47014f34 100644
--- a/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs
+++ b/src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs
@@ -1,4 +1,4 @@
-#region Copyright notice and license

+#region Copyright notice and license

 

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

@@ -39,11 +39,14 @@ using NUnit.Framework;
 using System.Collections.Generic;

 using Google.ProtocolBuffers.TestProtos;

 

-namespace Google.ProtocolBuffers {

+namespace Google.ProtocolBuffers

+{

     [TestFixture]

-    public class MissingFieldAndExtensionTest {

+    public class MissingFieldAndExtensionTest

+    {

         [Test]

-        public void TestRecoverMissingExtensions() {

+        public void TestRecoverMissingExtensions()

+        {

             const int optionalInt32 = 12345678;

             TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();

             builder.SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32);

@@ -88,7 +91,8 @@ namespace Google.ProtocolBuffers {
         }

 

         [Test]

-        public void TestRecoverMissingFields() {

+        public void TestRecoverMissingFields()

+        {

             TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder()

                 .SetId(1001)

                 .SetName("Name")

@@ -101,7 +105,8 @@ namespace Google.ProtocolBuffers {
             Assert.AreEqual("Name", msgb.Name);

             Assert.IsFalse(msgb.HasWebsite);

             Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);

-            Assert.AreEqual("missing@field.value", msgb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8());

+            Assert.AreEqual("missing@field.value",

+                            msgb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8());

 

             //serializes exactly the same (at least for this simple example)

             Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());

@@ -126,7 +131,9 @@ namespace Google.ProtocolBuffers {
             Assert.AreEqual("Name", copya.Name);

             Assert.AreEqual("missing@field.value", copya.Email);

             Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count);

-            Assert.AreEqual("http://new.missing.field", copya.UnknownFields[TestMissingFieldsB.WebsiteFieldNumber].LengthDelimitedList[0].ToStringUtf8());

+            Assert.AreEqual("http://new.missing.field",

+                            copya.UnknownFields[TestMissingFieldsB.WebsiteFieldNumber].LengthDelimitedList[0].

+                                ToStringUtf8());

 

             //Lastly we can even still trip back to type B and see all fields:

             TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());

@@ -135,12 +142,17 @@ namespace Google.ProtocolBuffers {
             Assert.AreEqual("Name", copyb.Name);

             Assert.AreEqual("http://new.missing.field", copyb.Website);

             Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count);

-            Assert.AreEqual("missing@field.value", copyb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8());

+            Assert.AreEqual("missing@field.value",

+                            copyb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8

+                                ());

         }

 

         [Test]

-        public void TestRecoverMissingMessage() {

-            TestMissingFieldsA.Types.SubA suba = TestMissingFieldsA.Types.SubA.CreateBuilder().SetCount(3).AddValues("a").AddValues("b").AddValues("c").Build();

+        public void TestRecoverMissingMessage()

+        {

+            TestMissingFieldsA.Types.SubA suba =

+                TestMissingFieldsA.Types.SubA.CreateBuilder().SetCount(3).AddValues("a").AddValues("b").AddValues("c").

+                    Build();

             TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder()

                 .SetId(1001)

                 .SetName("Name")

@@ -152,7 +164,10 @@ namespace Google.ProtocolBuffers {
             Assert.AreEqual(1001, msgb.Id);

             Assert.AreEqual("Name", msgb.Name);

             Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);

-            Assert.AreEqual(suba.ToString(), TestMissingFieldsA.Types.SubA.ParseFrom(msgb.UnknownFields[TestMissingFieldsA.TestAFieldNumber].LengthDelimitedList[0]).ToString());

+            Assert.AreEqual(suba.ToString(),

+                            TestMissingFieldsA.Types.SubA.ParseFrom(

+                                msgb.UnknownFields[TestMissingFieldsA.TestAFieldNumber].LengthDelimitedList[0]).ToString

+                                ());

 

             //serializes exactly the same (at least for this simple example)

             Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());

@@ -166,7 +181,8 @@ namespace Google.ProtocolBuffers {
             Assert.AreEqual(suba, copya.TestA);

 

             //Now we modify B... and try again

-            TestMissingFieldsB.Types.SubB subb = TestMissingFieldsB.Types.SubB.CreateBuilder().AddValues("test-b").Build();

+            TestMissingFieldsB.Types.SubB subb =

+                TestMissingFieldsB.Types.SubB.CreateBuilder().AddValues("test-b").Build();

             msgb = msgb.ToBuilder().SetTestB(subb).Build();

             //Does B still have the missing field?

             Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);

@@ -178,7 +194,8 @@ namespace Google.ProtocolBuffers {
             Assert.AreEqual("Name", copya.Name);

             Assert.AreEqual(suba, copya.TestA);

             Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count);

-            Assert.AreEqual(subb.ToByteArray(), copya.UnknownFields[TestMissingFieldsB.TestBFieldNumber].LengthDelimitedList[0].ToByteArray());

+            Assert.AreEqual(subb.ToByteArray(),

+                            copya.UnknownFields[TestMissingFieldsB.TestBFieldNumber].LengthDelimitedList[0].ToByteArray());

 

             //Lastly we can even still trip back to type B and see all fields:

             TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());

@@ -190,7 +207,8 @@ namespace Google.ProtocolBuffers {
         }

 

         [Test]

-        public void TestRestoreFromOtherType() {

+        public void TestRestoreFromOtherType()

+        {

             TestInteropPerson person = TestInteropPerson.CreateBuilder()

                 .SetId(123)

                 .SetName("abc")

@@ -198,8 +216,11 @@ namespace Google.ProtocolBuffers {
                 .AddRangeCodes(new[] {1, 2, 3})

                 .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())

                 .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").Build())

-                .AddAddresses(TestInteropPerson.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())

-                .SetExtension(UnitTestExtrasFullProtoFile.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())

+                .AddAddresses(

+                    TestInteropPerson.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").

+                        SetState("NA").SetZip(12345).Build())

+                .SetExtension(UnitTestExtrasFullProtoFile.EmployeeId,

+                              TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())

                 .Build();

             Assert.IsTrue(person.IsInitialized);

 

diff --git a/src/ProtocolBuffersLite.Test/TestLiteByApi.cs b/src/ProtocolBuffersLite.Test/TestLiteByApi.cs
index 5fc00a45..5fee2ecb 100644
--- a/src/ProtocolBuffersLite.Test/TestLiteByApi.cs
+++ b/src/ProtocolBuffersLite.Test/TestLiteByApi.cs
@@ -1,4 +1,5 @@
-#region Copyright notice and license

+#region Copyright notice and license

+

 // Protocol Buffers - Google's data interchange format

 // Copyright 2008 Google Inc.  All rights reserved.

 // http://github.com/jskeet/dotnet-protobufs/

@@ -30,84 +31,91 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

 #endregion

 

 using Google.ProtocolBuffers.TestProtos;

 using NUnit.Framework;

 

-namespace Google.ProtocolBuffers {

-  [TestFixture]

-  public class TestLiteByApi {

-

-    [Test]

-    public void TestAllTypesEquality() {

-      TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

-      TestAllTypesLite copy = msg.ToBuilder().Build();

-      Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());

-      Assert.IsTrue(msg.Equals(copy));

-      msg = msg.ToBuilder().SetOptionalString("Hi").Build();

-      Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode());

-      Assert.IsFalse(msg.Equals(copy));

-      copy = copy.ToBuilder().SetOptionalString("Hi").Build();

-      Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());

-      Assert.IsTrue(msg.Equals(copy));

-    }

+namespace Google.ProtocolBuffers

+{

+    [TestFixture]

+    public class TestLiteByApi

+    {

+        [Test]

+        public void TestAllTypesEquality()

+        {

+            TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

+            TestAllTypesLite copy = msg.ToBuilder().Build();

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

+            Assert.IsTrue(msg.Equals(copy));

+            msg = msg.ToBuilder().SetOptionalString("Hi").Build();

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

+            Assert.IsFalse(msg.Equals(copy));

+            copy = copy.ToBuilder().SetOptionalString("Hi").Build();

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

+            Assert.IsTrue(msg.Equals(copy));

+        }

 

-    [Test]

-    public void TestEqualityOnExtensions() {

-      TestAllExtensionsLite msg = TestAllExtensionsLite.DefaultInstance;

-      TestAllExtensionsLite copy = msg.ToBuilder().Build();

-      Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());

-      Assert.IsTrue(msg.Equals(copy));

-      msg = msg.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build();

-      Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode());

-      Assert.IsFalse(msg.Equals(copy));

-      copy = copy.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build();

-      Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());

-      Assert.IsTrue(msg.Equals(copy));

-    }

+        [Test]

+        public void TestEqualityOnExtensions()

+        {

+            TestAllExtensionsLite msg = TestAllExtensionsLite.DefaultInstance;

+            TestAllExtensionsLite copy = msg.ToBuilder().Build();

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

+            Assert.IsTrue(msg.Equals(copy));

+            msg = msg.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build();

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

+            Assert.IsFalse(msg.Equals(copy));

+            copy = copy.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build();

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

+            Assert.IsTrue(msg.Equals(copy));

+        }

 

-    [Test]

-    public void TestAllTypesToString() {

-      TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

-      TestAllTypesLite copy = msg.ToBuilder().Build();

-      Assert.AreEqual(msg.ToString(), copy.ToString());

-      Assert.IsEmpty(msg.ToString());

-      msg = msg.ToBuilder().SetOptionalInt32(-1).Build();

-      Assert.AreEqual("optional_int32: -1", msg.ToString().TrimEnd());

-      msg = msg.ToBuilder().SetOptionalString("abc123").Build();

-      Assert.AreEqual("optional_int32: -1\noptional_string: \"abc123\"", msg.ToString().Replace("\r", "").TrimEnd());

-    }

+        [Test]

+        public void TestAllTypesToString()

+        {

+            TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

+            TestAllTypesLite copy = msg.ToBuilder().Build();

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

+            Assert.IsEmpty(msg.ToString());

+            msg = msg.ToBuilder().SetOptionalInt32(-1).Build();

+            Assert.AreEqual("optional_int32: -1", msg.ToString().TrimEnd());

+            msg = msg.ToBuilder().SetOptionalString("abc123").Build();

+            Assert.AreEqual("optional_int32: -1\noptional_string: \"abc123\"",

+                            msg.ToString().Replace("\r", "").TrimEnd());

+        }

 

-    [Test]

-    public void TestAllTypesDefaultedRoundTrip() {

-      TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

-      Assert.IsTrue(msg.IsInitialized);

-      TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();

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

-    }

+        [Test]

+        public void TestAllTypesDefaultedRoundTrip()

+        {

+            TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

+            Assert.IsTrue(msg.IsInitialized);

+            TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();

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

+        }

 

-    [Test]

-    public void TestAllTypesModifiedRoundTrip() {

-      TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

-      msg.ToBuilder()

-        .SetOptionalBool(true)

-        .SetOptionalCord("Hi")

-        .SetOptionalDouble(1.123)

-        .SetOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_FOO)

-        .SetOptionalForeignMessage(ForeignMessageLite.CreateBuilder().SetC('c').Build())

-        .SetOptionalGroup(TestAllTypesLite.Types.OptionalGroup.CreateBuilder().SetA('a').Build())

-        .SetOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR)

-        .SetOptionalInt32(32)

-        .SetOptionalInt64(64)

-        .SetOptionalNestedEnum(TestAllTypesLite.Types.NestedEnum.FOO)

-        .SetOptionalString("SetOptionalString")

-        .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('a').Build())

-        .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('A').Build())

-        ;

-      TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();

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

+        [Test]

+        public void TestAllTypesModifiedRoundTrip()

+        {

+            TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;

+            msg.ToBuilder()

+                .SetOptionalBool(true)

+                .SetOptionalCord("Hi")

+                .SetOptionalDouble(1.123)

+                .SetOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_FOO)

+                .SetOptionalForeignMessage(ForeignMessageLite.CreateBuilder().SetC('c').Build())

+                .SetOptionalGroup(TestAllTypesLite.Types.OptionalGroup.CreateBuilder().SetA('a').Build())

+                .SetOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR)

+                .SetOptionalInt32(32)

+                .SetOptionalInt64(64)

+                .SetOptionalNestedEnum(TestAllTypesLite.Types.NestedEnum.FOO)

+                .SetOptionalString("SetOptionalString")

+                .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('a').Build())

+                .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('A').Build())

+                ;

+            TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();

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

+        }

     }

-

-  }

-}

+}
\ No newline at end of file