line-ending-to-crlf

src/ProtocolBuffers/RpcUtil.cs

@@ -1,71 +1,71 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-
-namespace Google.ProtocolBuffers {
-  /// <summary>
-  /// Grab-bag of utility functions useful when dealing with RPCs.
-  /// </summary>
-  public static class RpcUtil {
-
-    /// <summary>
-    /// Converts an Action[IMessage] to an Action[T].
-    /// </summary>
-    public static Action<T> SpecializeCallback<T>(Action<IMessage> action) 
-        where T : IMessage<T> {
-      return message => action(message);
-    }
-
-    /// <summary>
-    /// Converts an Action[T] to an Action[IMessage].
-    /// The generalized action will accept any message object which has
-    /// the same descriptor, and will convert it to the correct class
-    /// before calling the original action. However, if the generalized
-    /// callback is given a message with a different descriptor, an
-    /// exception will be thrown.
-    /// </summary>
-    public static Action<IMessage> GeneralizeCallback<TMessage, TBuilder>(Action<TMessage> action, TMessage defaultInstance)
-        where TMessage : class, IMessage<TMessage, TBuilder> 
-        where TBuilder : IBuilder<TMessage, TBuilder> {
-      return message => {
-        TMessage castMessage = message as TMessage;
-        if (castMessage == null) {  
-          castMessage = defaultInstance.CreateBuilderForType().MergeFrom(message).Build();
-        }
-        action(castMessage);
-      };
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Grab-bag of utility functions useful when dealing with RPCs.
+  /// </summary>
+  public static class RpcUtil {
+
+    /// <summary>
+    /// Converts an Action[IMessage] to an Action[T].
+    /// </summary>
+    public static Action<T> SpecializeCallback<T>(Action<IMessage> action) 
+        where T : IMessage<T> {
+      return message => action(message);
+    }
+
+    /// <summary>
+    /// Converts an Action[T] to an Action[IMessage].
+    /// The generalized action will accept any message object which has
+    /// the same descriptor, and will convert it to the correct class
+    /// before calling the original action. However, if the generalized
+    /// callback is given a message with a different descriptor, an
+    /// exception will be thrown.
+    /// </summary>
+    public static Action<IMessage> GeneralizeCallback<TMessage, TBuilder>(Action<TMessage> action, TMessage defaultInstance)
+        where TMessage : class, IMessage<TMessage, TBuilder> 
+        where TBuilder : IBuilder<TMessage, TBuilder> {
+      return message => {
+        TMessage castMessage = message as TMessage;
+        if (castMessage == null) {  
+          castMessage = defaultInstance.CreateBuilderForType().MergeFrom(message).Build();
+        }
+        action(castMessage);
+      };
+    }
+  }
+}

src/ProtocolBuffers/SilverlightCompatibility.cs

@@ -1,52 +1,52 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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.Text.RegularExpressions;
-
-namespace Google.ProtocolBuffers
-{
-    /// <summary>
-    /// Class containing helpful workarounds for Silverlight compatibility
-    /// </summary>
-    internal static class SilverlightCompatibility
-    {
-
-#if SILVERLIGHT2
-        internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.None;
-#else
-        internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.Compiled;
-#endif
-
-    }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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.Text.RegularExpressions;
+
+namespace Google.ProtocolBuffers
+{
+    /// <summary>
+    /// Class containing helpful workarounds for Silverlight compatibility
+    /// </summary>
+    internal static class SilverlightCompatibility
+    {
+
+#if SILVERLIGHT2
+        internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.None;
+#else
+        internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.Compiled;
+#endif
+
+    }
+}

src/ProtocolBuffers/SortedList.cs

@@ -1,172 +1,172 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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
-
-#if SILVERLIGHT2
-using System.Collections;
-using System.Collections.Generic;
-
-namespace Google.ProtocolBuffers
-{
-    /// <summary>
-    /// Dictionary implementation which always yields keys in sorted order.
-    /// This is not particularly efficient: it wraps a normal dictionary
-    /// for most operations, but sorts by key when either iterating or
-    /// fetching the Keys/Values properties.
-    /// This is only used for Silverlight, which doesn't have the normal
-    /// sorted collections.
-    /// </summary>
-    internal sealed class SortedList<TKey, TValue> : IDictionary<TKey, TValue>
-    {
-        private readonly IDictionary<TKey, TValue> wrapped = new Dictionary<TKey, TValue>();
-
-        public SortedList()
-        {
-        }
-
-        public SortedList(IDictionary<TKey, TValue> dictionary)
-        {
-            foreach (KeyValuePair<TKey, TValue> entry in dictionary)
-            {
-                Add(entry.Key, entry.Value);
-            }
-        }
-
-        public void Add(TKey key, TValue value)
-        {
-            wrapped.Add(key, value);
-        }
-
-        public bool ContainsKey(TKey key)
-        {
-            return wrapped.ContainsKey(key);
-        }
-
-        public ICollection<TKey> Keys
-        {
-            get
-            {
-                List<TKey> keys = new List<TKey>(wrapped.Count);
-                foreach (var pair in this)
-                {
-                    keys.Add(pair.Key);
-                }
-                return keys;
-            }
-        }
-
-        public bool Remove(TKey key)
-        {
-            return wrapped.Remove(key);
-        }
-
-        public bool TryGetValue(TKey key, out TValue value)
-        {
-            return wrapped.TryGetValue(key, out value);
-        }
-
-        public ICollection<TValue> Values
-        {
-            get
-            {
-                List<TValue> values = new List<TValue>(wrapped.Count);
-                foreach (var pair in this)
-                {
-                    values.Add(pair.Value);
-                }
-                return values;
-            }
-        }
-
-        public TValue this[TKey key]
-        {
-            get
-            {
-                return wrapped[key];
-            }
-            set
-            {
-                wrapped[key] = value;
-            }
-        }
-
-        public void Add(KeyValuePair<TKey, TValue> item)
-        {
-            wrapped.Add(item);
-        }
-
-        public void Clear()
-        {
-            wrapped.Clear();
-        }
-
-        public bool Contains(KeyValuePair<TKey, TValue> item)
-        {
-            return wrapped.Contains(item);
-        }
-
-        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
-        {
-            wrapped.CopyTo(array, arrayIndex);
-        }
-
-        public int Count
-        {
-            get { return wrapped.Count; }
-        }
-
-        public bool IsReadOnly
-        {
-            get { return wrapped.IsReadOnly; }
-        }
-
-        public bool Remove(KeyValuePair<TKey, TValue> item)
-        {
-            return wrapped.Remove(item);
-        }
-
-        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
-        {
-            IComparer<TKey> comparer = Comparer<TKey>.Default;
-            var list = new List<KeyValuePair<TKey, TValue>>(wrapped);
-            list.Sort((x, y) => comparer.Compare(x.Key, y.Key));
-            return list.GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-    }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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
+
+#if SILVERLIGHT2
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Google.ProtocolBuffers
+{
+    /// <summary>
+    /// Dictionary implementation which always yields keys in sorted order.
+    /// This is not particularly efficient: it wraps a normal dictionary
+    /// for most operations, but sorts by key when either iterating or
+    /// fetching the Keys/Values properties.
+    /// This is only used for Silverlight, which doesn't have the normal
+    /// sorted collections.
+    /// </summary>
+    internal sealed class SortedList<TKey, TValue> : IDictionary<TKey, TValue>
+    {
+        private readonly IDictionary<TKey, TValue> wrapped = new Dictionary<TKey, TValue>();
+
+        public SortedList()
+        {
+        }
+
+        public SortedList(IDictionary<TKey, TValue> dictionary)
+        {
+            foreach (KeyValuePair<TKey, TValue> entry in dictionary)
+            {
+                Add(entry.Key, entry.Value);
+            }
+        }
+
+        public void Add(TKey key, TValue value)
+        {
+            wrapped.Add(key, value);
+        }
+
+        public bool ContainsKey(TKey key)
+        {
+            return wrapped.ContainsKey(key);
+        }
+
+        public ICollection<TKey> Keys
+        {
+            get
+            {
+                List<TKey> keys = new List<TKey>(wrapped.Count);
+                foreach (var pair in this)
+                {
+                    keys.Add(pair.Key);
+                }
+                return keys;
+            }
+        }
+
+        public bool Remove(TKey key)
+        {
+            return wrapped.Remove(key);
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            return wrapped.TryGetValue(key, out value);
+        }
+
+        public ICollection<TValue> Values
+        {
+            get
+            {
+                List<TValue> values = new List<TValue>(wrapped.Count);
+                foreach (var pair in this)
+                {
+                    values.Add(pair.Value);
+                }
+                return values;
+            }
+        }
+
+        public TValue this[TKey key]
+        {
+            get
+            {
+                return wrapped[key];
+            }
+            set
+            {
+                wrapped[key] = value;
+            }
+        }
+
+        public void Add(KeyValuePair<TKey, TValue> item)
+        {
+            wrapped.Add(item);
+        }
+
+        public void Clear()
+        {
+            wrapped.Clear();
+        }
+
+        public bool Contains(KeyValuePair<TKey, TValue> item)
+        {
+            return wrapped.Contains(item);
+        }
+
+        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            wrapped.CopyTo(array, arrayIndex);
+        }
+
+        public int Count
+        {
+            get { return wrapped.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return wrapped.IsReadOnly; }
+        }
+
+        public bool Remove(KeyValuePair<TKey, TValue> item)
+        {
+            return wrapped.Remove(item);
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            IComparer<TKey> comparer = Comparer<TKey>.Default;
+            var list = new List<KeyValuePair<TKey, TValue>>(wrapped);
+            list.Sort((x, y) => comparer.Compare(x.Key, y.Key));
+            return list.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}
 #endif

src/ProtocolBuffers/TextGenerator.cs

@@ -1,143 +1,143 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.IO;
-using System.Text;
-
-namespace Google.ProtocolBuffers {
-
-  /// <summary>
-  /// Helper class to control indentation. Used for TextFormat and by ProtoGen.
-  /// </summary>
-  public sealed class TextGenerator {
-
-    /// <summary>
-    /// The string to use at the end of each line. We assume that "Print" is only called using \n
-    /// to indicate a line break; that's what we use to detect when we need to indent etc, and
-    /// *just* the \n is replaced with the contents of lineBreak.
-    /// </summary>
-    private readonly string lineBreak;
-
-    /// <summary>
-    /// Writer to write formatted text to.
-    /// </summary>
-    private readonly TextWriter writer;
-
-    /// <summary>
-    /// Keeps track of whether the next piece of text should be indented
-    /// </summary>
-    bool atStartOfLine = true;
-
-    /// <summary>
-    /// Keeps track of the current level of indentation
-    /// </summary>
-    readonly StringBuilder indent = new StringBuilder();
-
-    /// <summary>
-    /// Creates a generator writing to the given writer. The writer
-    /// is not closed by this class.
-    /// </summary>
-    public TextGenerator(TextWriter writer, string lineBreak) {
-      this.writer = writer;
-      this.lineBreak = lineBreak;
-    }
-
-    /// <summary>
-    /// Indents text by two spaces. After calling Indent(), two spaces
-    /// will be inserted at the beginning of each line of text. Indent() may
-    /// be called multiple times to produce deeper indents.
-    /// </summary>
-    public void Indent() {
-      indent.Append("  ");
-    }
-
-    /// <summary>
-    /// Reduces the current indent level by two spaces.
-    /// </summary>
-    public void Outdent() {
-      if (indent.Length == 0) {
-        throw new InvalidOperationException("Too many calls to Outdent()");
-      }
-      indent.Length -= 2;
-    }
-
-    public void WriteLine(string text) {
-      Print(text);
-      Print("\n");
-    }
-
-    public void WriteLine(string format, params object[] args) {
-      WriteLine(string.Format(format, args));
-    }
-
-    public void WriteLine() {
-      WriteLine("");
-    }
-
-    /// <summary>
-    /// Prints the given text to the output stream, indenting at line boundaries.
-    /// </summary>
-    /// <param name="text"></param>
-    public void Print(string text) {
-      int pos = 0;
-
-      for (int i = 0; i < text.Length; i++) {
-        if (text[i] == '\n') {
-          // Strip off the \n from what we write
-          Write(text.Substring(pos, i - pos));
-          Write(lineBreak);
-          pos = i + 1;
-          atStartOfLine = true;
-        }
-      }
-      Write(text.Substring(pos));
-    }
-
-    public void Write(string format, params object[] args) {
-      Write(string.Format(format, args));
-    }
-    
-    private void Write(string data) {
-      if (data.Length == 0) {
-        return;
-      }
-      if (atStartOfLine) {
-        atStartOfLine = false;
-        writer.Write(indent);
-      }
-      writer.Write(data);
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.IO;
+using System.Text;
+
+namespace Google.ProtocolBuffers {
+
+  /// <summary>
+  /// Helper class to control indentation. Used for TextFormat and by ProtoGen.
+  /// </summary>
+  public sealed class TextGenerator {
+
+    /// <summary>
+    /// The string to use at the end of each line. We assume that "Print" is only called using \n
+    /// to indicate a line break; that's what we use to detect when we need to indent etc, and
+    /// *just* the \n is replaced with the contents of lineBreak.
+    /// </summary>
+    private readonly string lineBreak;
+
+    /// <summary>
+    /// Writer to write formatted text to.
+    /// </summary>
+    private readonly TextWriter writer;
+
+    /// <summary>
+    /// Keeps track of whether the next piece of text should be indented
+    /// </summary>
+    bool atStartOfLine = true;
+
+    /// <summary>
+    /// Keeps track of the current level of indentation
+    /// </summary>
+    readonly StringBuilder indent = new StringBuilder();
+
+    /// <summary>
+    /// Creates a generator writing to the given writer. The writer
+    /// is not closed by this class.
+    /// </summary>
+    public TextGenerator(TextWriter writer, string lineBreak) {
+      this.writer = writer;
+      this.lineBreak = lineBreak;
+    }
+
+    /// <summary>
+    /// Indents text by two spaces. After calling Indent(), two spaces
+    /// will be inserted at the beginning of each line of text. Indent() may
+    /// be called multiple times to produce deeper indents.
+    /// </summary>
+    public void Indent() {
+      indent.Append("  ");
+    }
+
+    /// <summary>
+    /// Reduces the current indent level by two spaces.
+    /// </summary>
+    public void Outdent() {
+      if (indent.Length == 0) {
+        throw new InvalidOperationException("Too many calls to Outdent()");
+      }
+      indent.Length -= 2;
+    }
+
+    public void WriteLine(string text) {
+      Print(text);
+      Print("\n");
+    }
+
+    public void WriteLine(string format, params object[] args) {
+      WriteLine(string.Format(format, args));
+    }
+
+    public void WriteLine() {
+      WriteLine("");
+    }
+
+    /// <summary>
+    /// Prints the given text to the output stream, indenting at line boundaries.
+    /// </summary>
+    /// <param name="text"></param>
+    public void Print(string text) {
+      int pos = 0;
+
+      for (int i = 0; i < text.Length; i++) {
+        if (text[i] == '\n') {
+          // Strip off the \n from what we write
+          Write(text.Substring(pos, i - pos));
+          Write(lineBreak);
+          pos = i + 1;
+          atStartOfLine = true;
+        }
+      }
+      Write(text.Substring(pos));
+    }
+
+    public void Write(string format, params object[] args) {
+      Write(string.Format(format, args));
+    }
+    
+    private void Write(string data) {
+      if (data.Length == 0) {
+        return;
+      }
+      if (atStartOfLine) {
+        atStartOfLine = false;
+        writer.Write(indent);
+      }
+      writer.Write(data);
+    }
+  }
+}

src/ProtocolBuffers/TextTokenizer.cs

@@ -1,412 +1,412 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Globalization;
-using System.Text.RegularExpressions;
-
-namespace Google.ProtocolBuffers {
-  /// <summary>
-  /// Represents a stream of tokens parsed from a string.
-  /// </summary>
-  internal sealed class TextTokenizer {
-    private readonly string text;
-    private string currentToken;
-
-    /// <summary>
-    /// The character index within the text to perform the next regex match at.
-    /// </summary>
-    private int matchPos = 0;
-
-    /// <summary>
-    /// The character index within the text at which the current token begins.
-    /// </summary>
-    private int pos = 0;
-
-    /// <summary>
-    /// The line number of the current token.
-    /// </summary>
-    private int line = 0;
-    /// <summary>
-    /// The column number of the current token.
-    /// </summary>
-    private int column = 0;
-
-    /// <summary>
-    /// The line number of the previous token.
-    /// </summary>
-    private int previousLine = 0;
-    /// <summary>
-    /// The column number of the previous token.
-    /// </summary>
-    private int previousColumn = 0;
-
-    // Note: atomic groups used to mimic possessive quantifiers in Java in both of these regexes
-    internal static readonly Regex WhitespaceAndCommentPattern = new Regex("\\G(?>(\\s|(#.*$))+)",
-        SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.Multiline);
-    private static readonly Regex TokenPattern = new Regex(
-      "\\G[a-zA-Z_](?>[0-9a-zA-Z_+-]*)|" +              // an identifier
-      "\\G[0-9+-](?>[0-9a-zA-Z_.+-]*)|" +                  // a number
-      "\\G\"(?>([^\"\\\n\\\\]|\\\\.)*)(\"|\\\\?$)|" +    // a double-quoted string
-      "\\G\'(?>([^\"\\\n\\\\]|\\\\.)*)(\'|\\\\?$)",      // a single-quoted string
-      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.Multiline);
-
-    private static readonly Regex DoubleInfinity = new Regex("^-?inf(inity)?$",
-      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.IgnoreCase);
-    private static readonly Regex FloatInfinity = new Regex("^-?inf(inity)?f?$",
-      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.IgnoreCase);
-    private static readonly Regex FloatNan = new Regex("^nanf?$",
-      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.IgnoreCase);
-
-    /** Construct a tokenizer that parses tokens from the given text. */
-    public TextTokenizer(string text) {
-      this.text = text;
-      SkipWhitespace();
-      NextToken();
-    }
-
-    /// <summary>
-    /// Are we at the end of the input?
-    /// </summary>
-    public bool AtEnd {
-      get { return currentToken.Length == 0; }
-    }
-
-    /// <summary>
-    /// Advances to the next token.
-    /// </summary>
-    public void NextToken() {
-      previousLine = line;
-      previousColumn = column;
-
-      // Advance the line counter to the current position.
-      while (pos < matchPos) {
-        if (text[pos] == '\n') {
-          ++line;
-          column = 0;
-        } else {
-          ++column;
-        }
-        ++pos;
-      }
-
-      // Match the next token.
-      if (matchPos == text.Length) {
-        // EOF
-        currentToken = "";
-      } else {
-        Match match = TokenPattern.Match(text, matchPos);
-        if (match.Success) {
-          currentToken = match.Value;
-          matchPos += match.Length;
-        } else {
-          // Take one character.
-          currentToken = text[matchPos].ToString();
-          matchPos++;
-        }
-
-        SkipWhitespace();
-      }
-    }
-
-    /// <summary>
-    /// Skip over any whitespace so that matchPos starts at the next token.
-    /// </summary>
-    private void SkipWhitespace() {
-      Match match = WhitespaceAndCommentPattern.Match(text, matchPos);
-      if (match.Success) {
-        matchPos += match.Length;
-      }
-    }
-
-    /// <summary>
-    /// If the next token exactly matches the given token, consume it and return
-    /// true. Otherwise, return false without doing anything.
-    /// </summary>
-    public bool TryConsume(string token) {
-      if (currentToken == token) {
-        NextToken();
-        return true;
-      }
-      return false;
-    }
-
-    /*
-     * If the next token exactly matches {@code token}, consume it.  Otherwise,
-     * throw a {@link ParseException}.
-     */
-    /// <summary>
-    /// If the next token exactly matches the specified one, consume it.
-    /// Otherwise, throw a FormatException.
-    /// </summary>
-    /// <param name="token"></param>
-    public void Consume(string token) {
-      if (!TryConsume(token)) {
-        throw CreateFormatException("Expected \"" + token + "\".");
-      }
-    }
-
-    /// <summary>
-    /// Returns true if the next token is an integer, but does not consume it.
-    /// </summary>
-    public bool LookingAtInteger() {
-      if (currentToken.Length == 0) {
-        return false;
-      }
-
-      char c = currentToken[0];
-      return ('0' <= c && c <= '9') || c == '-' || c == '+';
-    }
-
-    /// <summary>
-    /// If the next token is an identifier, consume it and return its value.
-    /// Otherwise, throw a FormatException.
-    /// </summary>
-    public string ConsumeIdentifier() {
-      foreach (char c in currentToken) {
-        if (('a' <= c && c <= 'z') ||
-            ('A' <= c && c <= 'Z') ||
-            ('0' <= c && c <= '9') ||
-            (c == '_') || (c == '.')) {
-          // OK
-        } else {
-          throw CreateFormatException("Expected identifier.");
-        }
-      }
-
-      string result = currentToken;
-      NextToken();
-      return result;
-    }
-
-    /// <summary>
-    /// If the next token is a 32-bit signed integer, consume it and return its 
-    /// value. Otherwise, throw a FormatException.
-    /// </summary>
-    public int ConsumeInt32()  {
-      try {
-        int result = TextFormat.ParseInt32(currentToken);
-        NextToken();
-        return result;
-      } catch (FormatException e) {
-        throw CreateIntegerParseException(e);
-      }
-    }
-
-    /// <summary>
-    /// If the next token is a 32-bit unsigned integer, consume it and return its
-    /// value. Otherwise, throw a FormatException.
-    /// </summary>
-    public uint ConsumeUInt32() {
-      try {
-        uint result = TextFormat.ParseUInt32(currentToken);
-        NextToken();
-        return result;
-      } catch (FormatException e) {
-        throw CreateIntegerParseException(e);
-      }
-    }
-
-    /// <summary>
-    /// If the next token is a 64-bit signed integer, consume it and return its
-    /// value. Otherwise, throw a FormatException.
-    /// </summary>
-    public long ConsumeInt64() {
-      try {
-        long result = TextFormat.ParseInt64(currentToken);
-        NextToken();
-        return result;
-      } catch (FormatException e) {
-        throw CreateIntegerParseException(e);
-      }
-    }
-
-    /// <summary>
-    /// If the next token is a 64-bit unsigned integer, consume it and return its
-    /// value. Otherwise, throw a FormatException.
-    /// </summary>
-    public ulong ConsumeUInt64() {
-      try {
-        ulong result = TextFormat.ParseUInt64(currentToken);
-        NextToken();
-        return result;
-      } catch (FormatException e) {
-        throw CreateIntegerParseException(e);
-      }
-    }
-
-    /// <summary>
-    /// If the next token is a double, consume it and return its value.
-    /// Otherwise, throw a FormatException.
-    /// </summary>
-    public double ConsumeDouble() {
-      // We need to parse infinity and nan separately because
-      // double.Parse() does not accept "inf", "infinity", or "nan".
-      if (DoubleInfinity.IsMatch(currentToken)) {
-        bool negative = currentToken.StartsWith("-");
-        NextToken();
-        return negative ? double.NegativeInfinity : double.PositiveInfinity;
-      }
-      if (currentToken.Equals("nan", StringComparison.InvariantCultureIgnoreCase)) {
-        NextToken();
-        return Double.NaN;
-      }
-
-      try {
-        double result = double.Parse(currentToken, CultureInfo.InvariantCulture);
-        NextToken();
-        return result;
-      } catch (FormatException e) {
-        throw CreateFloatParseException(e);
-      } catch (OverflowException e) {
-        throw CreateFloatParseException(e);
-      }
-    }
-
-    /// <summary>
-    /// If the next token is a float, consume it and return its value.
-    /// Otherwise, throw a FormatException.
-    /// </summary>
-    public float ConsumeFloat() {
-      // We need to parse infinity and nan separately because
-      // Float.parseFloat() does not accept "inf", "infinity", or "nan".
-      if (FloatInfinity.IsMatch(currentToken)) {
-        bool negative = currentToken.StartsWith("-");
-        NextToken();
-        return negative ? float.NegativeInfinity : float.PositiveInfinity;
-      }
-      if (FloatNan.IsMatch(currentToken)) {
-        NextToken();
-        return float.NaN;
-      }
-
-      if (currentToken.EndsWith("f")) {
-        currentToken = currentToken.TrimEnd('f');
-      }
-
-      try {
-        float result = float.Parse(currentToken, CultureInfo.InvariantCulture);
-        NextToken();
-        return result;
-      } catch (FormatException e) {
-        throw CreateFloatParseException(e);
-      } catch (OverflowException e) {
-        throw CreateFloatParseException(e);
-      }
-    }
-
-    /// <summary>
-    /// If the next token is a Boolean, consume it and return its value.
-    /// Otherwise, throw a FormatException.    
-    /// </summary>
-    public bool ConsumeBoolean() {
-      if (currentToken == "true") {
-        NextToken();
-        return true;
-      } 
-      if (currentToken == "false") {
-        NextToken();
-        return false;
-      }
-      throw CreateFormatException("Expected \"true\" or \"false\".");
-    }
-
-    /// <summary>
-    /// If the next token is a string, consume it and return its (unescaped) value.
-    /// Otherwise, throw a FormatException.
-    /// </summary>
-    public string ConsumeString() {
-      return ConsumeByteString().ToStringUtf8();
-    }
-
-    /// <summary>
-    /// If the next token is a string, consume it, unescape it as a
-    /// ByteString and return it. Otherwise, throw a FormatException.
-    /// </summary>
-    public ByteString ConsumeByteString() {
-      char quote = currentToken.Length > 0 ? currentToken[0] : '\0';
-      if (quote != '\"' && quote != '\'') {
-        throw CreateFormatException("Expected string.");
-      }
-
-      if (currentToken.Length < 2 ||
-          currentToken[currentToken.Length-1] != quote) {
-        throw CreateFormatException("String missing ending quote.");
-      }
-
-      try {
-        string escaped = currentToken.Substring(1, currentToken.Length - 2);
-        ByteString result = TextFormat.UnescapeBytes(escaped);
-        NextToken();
-        return result;
-      } catch (FormatException e) {
-        throw CreateFormatException(e.Message);
-      }
-    }
-
-    /// <summary>
-    /// Returns a format exception with the current line and column numbers
-    /// in the description, suitable for throwing.
-    /// </summary>
-    public FormatException CreateFormatException(string description) {
-      // Note:  People generally prefer one-based line and column numbers.
-      return new FormatException((line + 1) + ":" + (column + 1) + ": " + description);
-    }
-
-    /// <summary>
-    /// Returns a format exception with the line and column numbers of the
-    /// previous token in the description, suitable for throwing.
-    /// </summary>
-    public FormatException CreateFormatExceptionPreviousToken(string description) {
-      // Note:  People generally prefer one-based line and column numbers.
-      return new FormatException((previousLine + 1) + ":" + (previousColumn + 1) + ": " + description);
-    }
-
-    /// <summary>
-    /// Constructs an appropriate FormatException for the given existing exception
-    /// when trying to parse an integer.
-    /// </summary>
-    private FormatException CreateIntegerParseException(FormatException e) {
-      return CreateFormatException("Couldn't parse integer: " + e.Message);
-    }
-
-    /// <summary>
-    /// Constructs an appropriate FormatException for the given existing exception
-    /// when trying to parse a float or double.
-    /// </summary>
-    private FormatException CreateFloatParseException(Exception e) {
-      return CreateFormatException("Couldn't parse number: " + e.Message);
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Represents a stream of tokens parsed from a string.
+  /// </summary>
+  internal sealed class TextTokenizer {
+    private readonly string text;
+    private string currentToken;
+
+    /// <summary>
+    /// The character index within the text to perform the next regex match at.
+    /// </summary>
+    private int matchPos = 0;
+
+    /// <summary>
+    /// The character index within the text at which the current token begins.
+    /// </summary>
+    private int pos = 0;
+
+    /// <summary>
+    /// The line number of the current token.
+    /// </summary>
+    private int line = 0;
+    /// <summary>
+    /// The column number of the current token.
+    /// </summary>
+    private int column = 0;
+
+    /// <summary>
+    /// The line number of the previous token.
+    /// </summary>
+    private int previousLine = 0;
+    /// <summary>
+    /// The column number of the previous token.
+    /// </summary>
+    private int previousColumn = 0;
+
+    // Note: atomic groups used to mimic possessive quantifiers in Java in both of these regexes
+    internal static readonly Regex WhitespaceAndCommentPattern = new Regex("\\G(?>(\\s|(#.*$))+)",
+        SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.Multiline);
+    private static readonly Regex TokenPattern = new Regex(
+      "\\G[a-zA-Z_](?>[0-9a-zA-Z_+-]*)|" +              // an identifier
+      "\\G[0-9+-](?>[0-9a-zA-Z_.+-]*)|" +                  // a number
+      "\\G\"(?>([^\"\\\n\\\\]|\\\\.)*)(\"|\\\\?$)|" +    // a double-quoted string
+      "\\G\'(?>([^\"\\\n\\\\]|\\\\.)*)(\'|\\\\?$)",      // a single-quoted string
+      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.Multiline);
+
+    private static readonly Regex DoubleInfinity = new Regex("^-?inf(inity)?$",
+      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.IgnoreCase);
+    private static readonly Regex FloatInfinity = new Regex("^-?inf(inity)?f?$",
+      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.IgnoreCase);
+    private static readonly Regex FloatNan = new Regex("^nanf?$",
+      SilverlightCompatibility.CompiledRegexWhereAvailable | RegexOptions.IgnoreCase);
+
+    /** Construct a tokenizer that parses tokens from the given text. */
+    public TextTokenizer(string text) {
+      this.text = text;
+      SkipWhitespace();
+      NextToken();
+    }
+
+    /// <summary>
+    /// Are we at the end of the input?
+    /// </summary>
+    public bool AtEnd {
+      get { return currentToken.Length == 0; }
+    }
+
+    /// <summary>
+    /// Advances to the next token.
+    /// </summary>
+    public void NextToken() {
+      previousLine = line;
+      previousColumn = column;
+
+      // Advance the line counter to the current position.
+      while (pos < matchPos) {
+        if (text[pos] == '\n') {
+          ++line;
+          column = 0;
+        } else {
+          ++column;
+        }
+        ++pos;
+      }
+
+      // Match the next token.
+      if (matchPos == text.Length) {
+        // EOF
+        currentToken = "";
+      } else {
+        Match match = TokenPattern.Match(text, matchPos);
+        if (match.Success) {
+          currentToken = match.Value;
+          matchPos += match.Length;
+        } else {
+          // Take one character.
+          currentToken = text[matchPos].ToString();
+          matchPos++;
+        }
+
+        SkipWhitespace();
+      }
+    }
+
+    /// <summary>
+    /// Skip over any whitespace so that matchPos starts at the next token.
+    /// </summary>
+    private void SkipWhitespace() {
+      Match match = WhitespaceAndCommentPattern.Match(text, matchPos);
+      if (match.Success) {
+        matchPos += match.Length;
+      }
+    }
+
+    /// <summary>
+    /// If the next token exactly matches the given token, consume it and return
+    /// true. Otherwise, return false without doing anything.
+    /// </summary>
+    public bool TryConsume(string token) {
+      if (currentToken == token) {
+        NextToken();
+        return true;
+      }
+      return false;
+    }
+
+    /*
+     * If the next token exactly matches {@code token}, consume it.  Otherwise,
+     * throw a {@link ParseException}.
+     */
+    /// <summary>
+    /// If the next token exactly matches the specified one, consume it.
+    /// Otherwise, throw a FormatException.
+    /// </summary>
+    /// <param name="token"></param>
+    public void Consume(string token) {
+      if (!TryConsume(token)) {
+        throw CreateFormatException("Expected \"" + token + "\".");
+      }
+    }
+
+    /// <summary>
+    /// Returns true if the next token is an integer, but does not consume it.
+    /// </summary>
+    public bool LookingAtInteger() {
+      if (currentToken.Length == 0) {
+        return false;
+      }
+
+      char c = currentToken[0];
+      return ('0' <= c && c <= '9') || c == '-' || c == '+';
+    }
+
+    /// <summary>
+    /// If the next token is an identifier, consume it and return its value.
+    /// Otherwise, throw a FormatException.
+    /// </summary>
+    public string ConsumeIdentifier() {
+      foreach (char c in currentToken) {
+        if (('a' <= c && c <= 'z') ||
+            ('A' <= c && c <= 'Z') ||
+            ('0' <= c && c <= '9') ||
+            (c == '_') || (c == '.')) {
+          // OK
+        } else {
+          throw CreateFormatException("Expected identifier.");
+        }
+      }
+
+      string result = currentToken;
+      NextToken();
+      return result;
+    }
+
+    /// <summary>
+    /// If the next token is a 32-bit signed integer, consume it and return its 
+    /// value. Otherwise, throw a FormatException.
+    /// </summary>
+    public int ConsumeInt32()  {
+      try {
+        int result = TextFormat.ParseInt32(currentToken);
+        NextToken();
+        return result;
+      } catch (FormatException e) {
+        throw CreateIntegerParseException(e);
+      }
+    }
+
+    /// <summary>
+    /// If the next token is a 32-bit unsigned integer, consume it and return its
+    /// value. Otherwise, throw a FormatException.
+    /// </summary>
+    public uint ConsumeUInt32() {
+      try {
+        uint result = TextFormat.ParseUInt32(currentToken);
+        NextToken();
+        return result;
+      } catch (FormatException e) {
+        throw CreateIntegerParseException(e);
+      }
+    }
+
+    /// <summary>
+    /// If the next token is a 64-bit signed integer, consume it and return its
+    /// value. Otherwise, throw a FormatException.
+    /// </summary>
+    public long ConsumeInt64() {
+      try {
+        long result = TextFormat.ParseInt64(currentToken);
+        NextToken();
+        return result;
+      } catch (FormatException e) {
+        throw CreateIntegerParseException(e);
+      }
+    }
+
+    /// <summary>
+    /// If the next token is a 64-bit unsigned integer, consume it and return its
+    /// value. Otherwise, throw a FormatException.
+    /// </summary>
+    public ulong ConsumeUInt64() {
+      try {
+        ulong result = TextFormat.ParseUInt64(currentToken);
+        NextToken();
+        return result;
+      } catch (FormatException e) {
+        throw CreateIntegerParseException(e);
+      }
+    }
+
+    /// <summary>
+    /// If the next token is a double, consume it and return its value.
+    /// Otherwise, throw a FormatException.
+    /// </summary>
+    public double ConsumeDouble() {
+      // We need to parse infinity and nan separately because
+      // double.Parse() does not accept "inf", "infinity", or "nan".
+      if (DoubleInfinity.IsMatch(currentToken)) {
+        bool negative = currentToken.StartsWith("-");
+        NextToken();
+        return negative ? double.NegativeInfinity : double.PositiveInfinity;
+      }
+      if (currentToken.Equals("nan", StringComparison.InvariantCultureIgnoreCase)) {
+        NextToken();
+        return Double.NaN;
+      }
+
+      try {
+        double result = double.Parse(currentToken, CultureInfo.InvariantCulture);
+        NextToken();
+        return result;
+      } catch (FormatException e) {
+        throw CreateFloatParseException(e);
+      } catch (OverflowException e) {
+        throw CreateFloatParseException(e);
+      }
+    }
+
+    /// <summary>
+    /// If the next token is a float, consume it and return its value.
+    /// Otherwise, throw a FormatException.
+    /// </summary>
+    public float ConsumeFloat() {
+      // We need to parse infinity and nan separately because
+      // Float.parseFloat() does not accept "inf", "infinity", or "nan".
+      if (FloatInfinity.IsMatch(currentToken)) {
+        bool negative = currentToken.StartsWith("-");
+        NextToken();
+        return negative ? float.NegativeInfinity : float.PositiveInfinity;
+      }
+      if (FloatNan.IsMatch(currentToken)) {
+        NextToken();
+        return float.NaN;
+      }
+
+      if (currentToken.EndsWith("f")) {
+        currentToken = currentToken.TrimEnd('f');
+      }
+
+      try {
+        float result = float.Parse(currentToken, CultureInfo.InvariantCulture);
+        NextToken();
+        return result;
+      } catch (FormatException e) {
+        throw CreateFloatParseException(e);
+      } catch (OverflowException e) {
+        throw CreateFloatParseException(e);
+      }
+    }
+
+    /// <summary>
+    /// If the next token is a Boolean, consume it and return its value.
+    /// Otherwise, throw a FormatException.    
+    /// </summary>
+    public bool ConsumeBoolean() {
+      if (currentToken == "true") {
+        NextToken();
+        return true;
+      } 
+      if (currentToken == "false") {
+        NextToken();
+        return false;
+      }
+      throw CreateFormatException("Expected \"true\" or \"false\".");
+    }
+
+    /// <summary>
+    /// If the next token is a string, consume it and return its (unescaped) value.
+    /// Otherwise, throw a FormatException.
+    /// </summary>
+    public string ConsumeString() {
+      return ConsumeByteString().ToStringUtf8();
+    }
+
+    /// <summary>
+    /// If the next token is a string, consume it, unescape it as a
+    /// ByteString and return it. Otherwise, throw a FormatException.
+    /// </summary>
+    public ByteString ConsumeByteString() {
+      char quote = currentToken.Length > 0 ? currentToken[0] : '\0';
+      if (quote != '\"' && quote != '\'') {
+        throw CreateFormatException("Expected string.");
+      }
+
+      if (currentToken.Length < 2 ||
+          currentToken[currentToken.Length-1] != quote) {
+        throw CreateFormatException("String missing ending quote.");
+      }
+
+      try {
+        string escaped = currentToken.Substring(1, currentToken.Length - 2);
+        ByteString result = TextFormat.UnescapeBytes(escaped);
+        NextToken();
+        return result;
+      } catch (FormatException e) {
+        throw CreateFormatException(e.Message);
+      }
+    }
+
+    /// <summary>
+    /// Returns a format exception with the current line and column numbers
+    /// in the description, suitable for throwing.
+    /// </summary>
+    public FormatException CreateFormatException(string description) {
+      // Note:  People generally prefer one-based line and column numbers.
+      return new FormatException((line + 1) + ":" + (column + 1) + ": " + description);
+    }
+
+    /// <summary>
+    /// Returns a format exception with the line and column numbers of the
+    /// previous token in the description, suitable for throwing.
+    /// </summary>
+    public FormatException CreateFormatExceptionPreviousToken(string description) {
+      // Note:  People generally prefer one-based line and column numbers.
+      return new FormatException((previousLine + 1) + ":" + (previousColumn + 1) + ": " + description);
+    }
+
+    /// <summary>
+    /// Constructs an appropriate FormatException for the given existing exception
+    /// when trying to parse an integer.
+    /// </summary>
+    private FormatException CreateIntegerParseException(FormatException e) {
+      return CreateFormatException("Couldn't parse integer: " + e.Message);
+    }
+
+    /// <summary>
+    /// Constructs an appropriate FormatException for the given existing exception
+    /// when trying to parse a float or double.
+    /// </summary>
+    private FormatException CreateFloatParseException(Exception e) {
+      return CreateFormatException("Couldn't parse number: " + e.Message);
+    }
+  }
+}

src/ProtocolBuffers/ThrowHelper.cs

@@ -1,73 +1,73 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections.Generic;
-
-namespace Google.ProtocolBuffers {
-  /// <summary>
-  /// Helper methods for throwing exceptions
-  /// </summary>
-  public static class ThrowHelper {
-
-    /// <summary>
-    /// Throws an ArgumentNullException if the given value is null.
-    /// </summary>
-    public static void ThrowIfNull(object value, string name) {
-      if (value == null) {
-        throw new ArgumentNullException(name);
-      }
-    }
-
-    /// <summary>
-    /// Throws an ArgumentNullException if the given value is null.
-    /// </summary>
-    public static void ThrowIfNull(object value) {
-      if (value == null) {
-        throw new ArgumentNullException();
-      }
-    }
-
-    /// <summary>
-    /// Throws an ArgumentNullException if the given value or any element within it is null.
-    /// </summary>
-    public static void ThrowIfAnyNull<T>(IEnumerable<T> sequence) {
-      foreach (T t in sequence) {
-        if (t == null) {
-          throw new ArgumentNullException();
-        }
-      }
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections.Generic;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Helper methods for throwing exceptions
+  /// </summary>
+  public static class ThrowHelper {
+
+    /// <summary>
+    /// Throws an ArgumentNullException if the given value is null.
+    /// </summary>
+    public static void ThrowIfNull(object value, string name) {
+      if (value == null) {
+        throw new ArgumentNullException(name);
+      }
+    }
+
+    /// <summary>
+    /// Throws an ArgumentNullException if the given value is null.
+    /// </summary>
+    public static void ThrowIfNull(object value) {
+      if (value == null) {
+        throw new ArgumentNullException();
+      }
+    }
+
+    /// <summary>
+    /// Throws an ArgumentNullException if the given value or any element within it is null.
+    /// </summary>
+    public static void ThrowIfAnyNull<T>(IEnumerable<T> sequence) {
+      foreach (T t in sequence) {
+        if (t == null) {
+          throw new ArgumentNullException();
+        }
+      }
+    }
+  }
+}

src/ProtocolBuffers/UninitializedMessageException.cs

@@ -1,170 +1,170 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections;
-using System.Collections.Generic;
-using System.Text;
-#if !LITE
-using Google.ProtocolBuffers.Collections;
-using Google.ProtocolBuffers.Descriptors;
-#endif
-
-namespace Google.ProtocolBuffers {
-  /// <summary>
-  /// TODO(jonskeet): Write summary text.
-  /// </summary>
-  public sealed class UninitializedMessageException : Exception {
-
-    private readonly IList<string> missingFields;
-
-    private UninitializedMessageException(IList<string> missingFields)
-        : base(BuildDescription(missingFields)) {
-      this.missingFields = new List<string>(missingFields);
-    }
-    /// <summary>
-    /// Returns a read-only list of human-readable names of
-    /// required fields missing from this message. Each name
-    /// is a full path to a field, e.g. "foo.bar[5].baz"
-    /// </summary>
-    public IList<string> MissingFields {
-      get { return missingFields; }
-    }
-
-    /// <summary>
-    /// Converts this exception into an InvalidProtocolBufferException.
-    /// When a parsed message is missing required fields, this should be thrown
-    /// instead of UninitializedMessageException.
-    /// </summary>
-    public InvalidProtocolBufferException AsInvalidProtocolBufferException() {
-      return new InvalidProtocolBufferException(Message);
-    }
-
-    /// <summary>
-    /// Constructs the description string for a given list of missing fields.
-    /// </summary>
-    private static string BuildDescription(IEnumerable<string> missingFields) {
-      StringBuilder description = new StringBuilder("Message missing required fields: ");
-      bool first = true;
-      foreach(string field in missingFields) {
-        if (first) {
-          first = false;
-        } else {
-          description.Append(", ");
-        }
-        description.Append(field);
-      }
-      return description.ToString();
-    }
-
-    /// <summary>
-    /// For Lite exceptions that do not known how to enumerate missing fields
-    /// </summary>
-    public UninitializedMessageException(IMessageLite message)
-      : base(String.Format("Message {0} is missing required fields", message.GetType())) {
-      missingFields = new List<string>();
-    }
-
-#if !LITE
-    public UninitializedMessageException(IMessage message)
-        : this(FindMissingFields(message)) {
-    }
-
-    /// <summary>
-    /// Returns a list of the full "paths" of missing required
-    /// fields in the specified message.
-    /// </summary>
-    private static IList<String> FindMissingFields(IMessage message) {
-      List<String> results = new List<String>();
-      FindMissingFields(message, "", results);
-      return results;
-    }
-
-    /// <summary>
-    /// Recursive helper implementing FindMissingFields.
-    /// </summary>
-    private static void FindMissingFields(IMessage message, String prefix, List<String> results) {
-      foreach (FieldDescriptor field in message.DescriptorForType.Fields) {
-        if (field.IsRequired && !message.HasField(field)) {
-          results.Add(prefix + field.Name);
-        }
-      }
-
-      foreach (KeyValuePair<FieldDescriptor, object> entry in message.AllFields) {
-        FieldDescriptor field = entry.Key;
-        object value = entry.Value;
-
-        if (field.MappedType == MappedType.Message) {
-          if (field.IsRepeated) {
-            int i = 0;
-            foreach (object element in (IEnumerable) value) {
-              if (element is IMessage) {
-                FindMissingFields((IMessage)element, SubMessagePrefix(prefix, field, i++), results);
-              } else {
-                results.Add(prefix + field.Name);
-              }
-            }
-          } else {
-            if (message.HasField(field)) {
-              if (value is IMessage) {
-                FindMissingFields((IMessage)value, SubMessagePrefix(prefix, field, -1), results);
-              } else {
-                results.Add(prefix + field.Name);
-              }
-            }
-          }
-        }
-      }
-    }
-
-    private static String SubMessagePrefix(String prefix, FieldDescriptor field, int index) {
-      StringBuilder result = new StringBuilder(prefix);
-      if (field.IsExtension) {
-        result.Append('(')
-              .Append(field.FullName)
-              .Append(')');
-      } else {
-        result.Append(field.Name);
-      }
-      if (index != -1) {
-        result.Append('[')
-              .Append(index)
-              .Append(']');
-      }
-      result.Append('.');
-      return result.ToString();
-    }
-#endif
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+#if !LITE
+using Google.ProtocolBuffers.Collections;
+using Google.ProtocolBuffers.Descriptors;
+#endif
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// TODO(jonskeet): Write summary text.
+  /// </summary>
+  public sealed class UninitializedMessageException : Exception {
+
+    private readonly IList<string> missingFields;
+
+    private UninitializedMessageException(IList<string> missingFields)
+        : base(BuildDescription(missingFields)) {
+      this.missingFields = new List<string>(missingFields);
+    }
+    /// <summary>
+    /// Returns a read-only list of human-readable names of
+    /// required fields missing from this message. Each name
+    /// is a full path to a field, e.g. "foo.bar[5].baz"
+    /// </summary>
+    public IList<string> MissingFields {
+      get { return missingFields; }
+    }
+
+    /// <summary>
+    /// Converts this exception into an InvalidProtocolBufferException.
+    /// When a parsed message is missing required fields, this should be thrown
+    /// instead of UninitializedMessageException.
+    /// </summary>
+    public InvalidProtocolBufferException AsInvalidProtocolBufferException() {
+      return new InvalidProtocolBufferException(Message);
+    }
+
+    /// <summary>
+    /// Constructs the description string for a given list of missing fields.
+    /// </summary>
+    private static string BuildDescription(IEnumerable<string> missingFields) {
+      StringBuilder description = new StringBuilder("Message missing required fields: ");
+      bool first = true;
+      foreach(string field in missingFields) {
+        if (first) {
+          first = false;
+        } else {
+          description.Append(", ");
+        }
+        description.Append(field);
+      }
+      return description.ToString();
+    }
+
+    /// <summary>
+    /// For Lite exceptions that do not known how to enumerate missing fields
+    /// </summary>
+    public UninitializedMessageException(IMessageLite message)
+      : base(String.Format("Message {0} is missing required fields", message.GetType())) {
+      missingFields = new List<string>();
+    }
+
+#if !LITE
+    public UninitializedMessageException(IMessage message)
+        : this(FindMissingFields(message)) {
+    }
+
+    /// <summary>
+    /// Returns a list of the full "paths" of missing required
+    /// fields in the specified message.
+    /// </summary>
+    private static IList<String> FindMissingFields(IMessage message) {
+      List<String> results = new List<String>();
+      FindMissingFields(message, "", results);
+      return results;
+    }
+
+    /// <summary>
+    /// Recursive helper implementing FindMissingFields.
+    /// </summary>
+    private static void FindMissingFields(IMessage message, String prefix, List<String> results) {
+      foreach (FieldDescriptor field in message.DescriptorForType.Fields) {
+        if (field.IsRequired && !message.HasField(field)) {
+          results.Add(prefix + field.Name);
+        }
+      }
+
+      foreach (KeyValuePair<FieldDescriptor, object> entry in message.AllFields) {
+        FieldDescriptor field = entry.Key;
+        object value = entry.Value;
+
+        if (field.MappedType == MappedType.Message) {
+          if (field.IsRepeated) {
+            int i = 0;
+            foreach (object element in (IEnumerable) value) {
+              if (element is IMessage) {
+                FindMissingFields((IMessage)element, SubMessagePrefix(prefix, field, i++), results);
+              } else {
+                results.Add(prefix + field.Name);
+              }
+            }
+          } else {
+            if (message.HasField(field)) {
+              if (value is IMessage) {
+                FindMissingFields((IMessage)value, SubMessagePrefix(prefix, field, -1), results);
+              } else {
+                results.Add(prefix + field.Name);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    private static String SubMessagePrefix(String prefix, FieldDescriptor field, int index) {
+      StringBuilder result = new StringBuilder(prefix);
+      if (field.IsExtension) {
+        result.Append('(')
+              .Append(field.FullName)
+              .Append(')');
+      } else {
+        result.Append(field.Name);
+      }
+      if (index != -1) {
+        result.Append('[')
+              .Append(index)
+              .Append(']');
+      }
+      result.Append('.');
+      return result.ToString();
+    }
+#endif
+  }
+}

src/ProtocolBuffers/UnknownField.cs

@@ -1,371 +1,371 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using Google.ProtocolBuffers.Collections;
-
-namespace Google.ProtocolBuffers {
-  /// <summary>
-  /// Represents a single field in an UnknownFieldSet.
-  /// 
-  /// An UnknownField consists of five lists of values. The lists correspond
-   /// to the five "wire types" used in the protocol buffer binary format.
-   /// The wire type of each field can be determined from the encoded form alone,
-   /// without knowing the field's declared type. So, we are able to parse
-   /// unknown values at least this far and separate them. Normally, only one
-   /// of the five lists will contain any values, since it is impossible to
-   /// define a valid message type that declares two different types for the
-   /// same field number. However, the code is designed to allow for the case
-   /// where the same unknown field number is encountered using multiple different
-   /// wire types.
-   /// 
-   /// UnknownField is an immutable class. To construct one, you must use an
-   /// UnknownField.Builder.
-  /// </summary>
-  public sealed class UnknownField {
-
-    private static readonly UnknownField defaultInstance = CreateBuilder().Build();
-    private readonly ReadOnlyCollection<ulong> varintList;
-    private readonly ReadOnlyCollection<uint> fixed32List;
-    private readonly ReadOnlyCollection<ulong> fixed64List;
-    private readonly ReadOnlyCollection<ByteString> lengthDelimitedList;
-    private readonly ReadOnlyCollection<UnknownFieldSet> groupList;
-
-    private UnknownField(ReadOnlyCollection<ulong> varintList,
-        ReadOnlyCollection<uint> fixed32List, 
-        ReadOnlyCollection<ulong> fixed64List, 
-        ReadOnlyCollection<ByteString> lengthDelimitedList, 
-        ReadOnlyCollection<UnknownFieldSet> groupList) {
-      this.varintList = varintList;
-      this.fixed32List = fixed32List;
-      this.fixed64List = fixed64List;
-      this.lengthDelimitedList = lengthDelimitedList;
-      this.groupList = groupList;
-    }
-
-    public static UnknownField DefaultInstance { 
-      get { return defaultInstance; } 
-    }
-
-    /// <summary>
-    /// The list of varint values for this field.
-    /// </summary>
-    public IList<ulong> VarintList {
-      get { return varintList; }
-    }
-
-    /// <summary>
-    /// The list of fixed32 values for this field.
-    /// </summary>
-    public IList<uint> Fixed32List {
-      get { return fixed32List; }
-    }
-
-    /// <summary>
-    /// The list of fixed64 values for this field.
-    /// </summary>
-    public IList<ulong> Fixed64List {
-      get { return fixed64List; }
-    }
-
-    /// <summary>
-    /// The list of length-delimited values for this field.
-    /// </summary>
-    public IList<ByteString> LengthDelimitedList {
-      get { return lengthDelimitedList; }
-    }
-
-    /// <summary>
-    /// The list of embedded group values for this field. These
-    /// are represented using UnknownFieldSets rather than Messages
-    /// since the group's type is presumably unknown.
-    /// </summary>
-    public IList<UnknownFieldSet> GroupList {
-      get { return groupList; }
-    }
-
-    public override bool Equals(object other) {
-      if (ReferenceEquals(this, other)) {
-        return true;
-      }
-      UnknownField otherField = other as UnknownField;
-      return otherField != null
-        && Lists.Equals(varintList, otherField.varintList)
-        && Lists.Equals(fixed32List, otherField.fixed32List)
-        && Lists.Equals(fixed64List, otherField.fixed64List)
-        && Lists.Equals(lengthDelimitedList, otherField.lengthDelimitedList)
-        && Lists.Equals(groupList, otherField.groupList);
-    }
-
-    public override int GetHashCode() {
-      int hash = 43;
-      hash = hash * 47 + Lists.GetHashCode(varintList);
-      hash = hash * 47 + Lists.GetHashCode(fixed32List);
-      hash = hash * 47 + Lists.GetHashCode(fixed64List);
-      hash = hash * 47 + Lists.GetHashCode(lengthDelimitedList);
-      hash = hash * 47 + Lists.GetHashCode(groupList);
-      return hash;
-    }
-
-    /// <summary>
-    /// Constructs a new Builder.
-    /// </summary>
-    public static Builder CreateBuilder() {
-      return new Builder();
-    }
-
-    /// <summary>
-    /// Constructs a new Builder and initializes it to a copy of <paramref name="copyFrom"/>.
-    /// </summary>
-    public static Builder CreateBuilder(UnknownField copyFrom) {
-      return new Builder().MergeFrom(copyFrom);
-    }
-   
-    /// <summary>
-    /// Serializes the field, including the field number, and writes it to
-    /// <paramref name="output"/>.
-    /// </summary>
-    public void WriteTo(int fieldNumber, CodedOutputStream output) {
-      foreach (ulong value in varintList) {
-        output.WriteUInt64(fieldNumber, value);
-      }
-      foreach (uint value in fixed32List) {
-        output.WriteFixed32(fieldNumber, value);
-      }
-      foreach (ulong value in fixed64List) {
-        output.WriteFixed64(fieldNumber, value);
-      }
-      foreach (ByteString value in lengthDelimitedList) {
-        output.WriteBytes(fieldNumber, value);
-      }
-      foreach (UnknownFieldSet value in groupList) {
-#pragma warning disable 0612
-        output.WriteUnknownGroup(fieldNumber, value);
-#pragma warning restore 0612
-      }
-    }
-
-    /// <summary>
-    /// Computes the number of bytes required to encode this field, including field
-    /// number.
-    /// </summary>
-    public int GetSerializedSize(int fieldNumber) {
-      int result = 0;
-      foreach (ulong value in varintList) {
-        result += CodedOutputStream.ComputeUInt64Size(fieldNumber, value);
-      }
-      foreach (uint value in fixed32List) {
-        result += CodedOutputStream.ComputeFixed32Size(fieldNumber, value);
-      }
-      foreach (ulong value in fixed64List) {
-        result += CodedOutputStream.ComputeFixed64Size(fieldNumber, value);
-      }
-      foreach (ByteString value in lengthDelimitedList) {
-        result += CodedOutputStream.ComputeBytesSize(fieldNumber, value);
-      }
-      foreach (UnknownFieldSet value in groupList) {
-#pragma warning disable 0612
-        result += CodedOutputStream.ComputeUnknownGroupSize(fieldNumber, value);
-#pragma warning restore 0612
-      }
-      return result;
-    }
-
-    /// <summary>
-    /// Serializes the length-delimited values of the field, including field
-    /// number, and writes them to <paramref name="output"/> using the MessageSet wire format.
-    /// </summary>
-    /// <param name="fieldNumber"></param>
-    /// <param name="output"></param>
-    public void WriteAsMessageSetExtensionTo(int fieldNumber, CodedOutputStream output) {
-      foreach (ByteString value in lengthDelimitedList) {
-        output.WriteRawMessageSetExtension(fieldNumber, value);
-      }
-    }
-
-    /// <summary>
-    /// Get the number of bytes required to encode this field, incuding field number,
-    /// using the MessageSet wire format.
-    /// </summary>
-    public int GetSerializedSizeAsMessageSetExtension(int fieldNumber) {
-      int result = 0;
-      foreach (ByteString value in lengthDelimitedList) {
-        result += CodedOutputStream.ComputeRawMessageSetExtensionSize(fieldNumber, value);
-      }
-      return result;
-    }
-
-    /// <summary>
-    /// Used to build instances of UnknownField.
-    /// </summary>
-    public sealed class Builder {
-
-      private List<ulong> varintList;
-      private List<uint> fixed32List;
-      private List<ulong> fixed64List;
-      private List<ByteString> lengthDelimitedList;
-      private List<UnknownFieldSet> groupList;
-
-      /// <summary>
-      /// Builds the field. After building, the builder is reset to an empty
-      /// state. (This is actually easier than making it unusable.)
-      /// </summary>
-      public UnknownField Build() {
-        return new UnknownField(MakeReadOnly(ref varintList),
-            MakeReadOnly(ref fixed32List),
-            MakeReadOnly(ref fixed64List),
-            MakeReadOnly(ref lengthDelimitedList),
-            MakeReadOnly(ref groupList));
-      }
-
-      /// <summary>
-      /// Merge the values in <paramref name="other" /> into this field.  For each list
-      /// of values, <paramref name="other"/>'s values are append to the ones in this
-      /// field.
-      /// </summary>
-      public Builder MergeFrom(UnknownField other) {
-        varintList = AddAll(varintList, other.VarintList);
-        fixed32List = AddAll(fixed32List, other.Fixed32List);
-        fixed64List = AddAll(fixed64List, other.Fixed64List);
-        lengthDelimitedList = AddAll(lengthDelimitedList, other.LengthDelimitedList);
-        groupList = AddAll(groupList, other.GroupList);
-        return this;
-      }
-
-      /// <summary>
-      /// Returns a new list containing all of the given specified values from
-      /// both the <paramref name="current"/> and <paramref name="extras"/> lists.
-      /// If <paramref name="current" /> is null and <paramref name="extras"/> is empty,
-      /// null is returned. Otherwise, either a new list is created (if <paramref name="current" />
-      /// is null) or the elements of <paramref name="extras"/> are added to <paramref name="current" />.
-      /// </summary>
-      private static List<T> AddAll<T>(List<T> current, IList<T> extras)
-      {
-        if (extras.Count == 0) {
-          return current;
-        }
-           if (current == null) {
-          current = new List<T>(extras);
-        } else {
-          current.AddRange(extras);
-        }
-        return current;
-      }
-
-      /// <summary>
-      /// Clears the contents of this builder.
-      /// </summary>
-      public Builder Clear() {
-        varintList = null;
-        fixed32List = null;
-        fixed64List = null;
-        lengthDelimitedList = null;
-        groupList = null;
-        return this;
-      }
-
-      /// <summary>
-      /// Adds a varint value.
-      /// </summary>
-      [CLSCompliant(false)]
-      public Builder AddVarint(ulong value) {
-        varintList = Add(varintList, value);
-        return this;
-      }
-
-      /// <summary>
-      /// Adds a fixed32 value.
-      /// </summary>
-      [CLSCompliant(false)]
-      public Builder AddFixed32(uint value) {
-        fixed32List = Add(fixed32List, value);
-        return this;
-      }
-
-      /// <summary>
-      /// Adds a fixed64 value.
-      /// </summary>
-      [CLSCompliant(false)]
-      public Builder AddFixed64(ulong value) {
-        fixed64List = Add(fixed64List, value);
-        return this;
-      }
-
-      /// <summary>
-      /// Adds a length-delimited value.
-      /// </summary>
-      public Builder AddLengthDelimited(ByteString value) {
-        lengthDelimitedList = Add(lengthDelimitedList, value);
-        return this;
-      }
-
-      /// <summary>
-      /// Adds an embedded group.
-      /// </summary>
-      /// <param name="value"></param>
-      /// <returns></returns>
-      public Builder AddGroup(UnknownFieldSet value) {
-        groupList = Add(groupList, value);
-        return this;
-      }
-
-      /// <summary>
-      /// Adds <paramref name="value"/> to the <paramref name="list"/>, creating
-      /// a new list if <paramref name="list"/> is null. The list is returned - either
-      /// the original reference or the new list.
-      /// </summary>
-      private static List<T> Add<T>(List<T> list, T value) {
-        if (list == null) {
-          list = new List<T>();
-        }
-        list.Add(value);
-        return list;
-      }
-
-      /// <summary>
-      /// Returns a read-only version of the given IList, and clears
-      /// the field used for <paramref name="list"/>. If the value
-      /// is null, an empty list is produced using Lists.Empty.
-      /// </summary>
-      /// <returns></returns>
-      private static ReadOnlyCollection<T> MakeReadOnly<T>(ref List<T> list) {
-        ReadOnlyCollection<T> ret = list == null ? Lists<T>.Empty : new ReadOnlyCollection<T>(list);
-           list = null;
-        return ret;
-      }
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Google.ProtocolBuffers.Collections;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Represents a single field in an UnknownFieldSet.
+  /// 
+  /// An UnknownField consists of five lists of values. The lists correspond
+   /// to the five "wire types" used in the protocol buffer binary format.
+   /// The wire type of each field can be determined from the encoded form alone,
+   /// without knowing the field's declared type. So, we are able to parse
+   /// unknown values at least this far and separate them. Normally, only one
+   /// of the five lists will contain any values, since it is impossible to
+   /// define a valid message type that declares two different types for the
+   /// same field number. However, the code is designed to allow for the case
+   /// where the same unknown field number is encountered using multiple different
+   /// wire types.
+   /// 
+   /// UnknownField is an immutable class. To construct one, you must use an
+   /// UnknownField.Builder.
+  /// </summary>
+  public sealed class UnknownField {
+
+    private static readonly UnknownField defaultInstance = CreateBuilder().Build();
+    private readonly ReadOnlyCollection<ulong> varintList;
+    private readonly ReadOnlyCollection<uint> fixed32List;
+    private readonly ReadOnlyCollection<ulong> fixed64List;
+    private readonly ReadOnlyCollection<ByteString> lengthDelimitedList;
+    private readonly ReadOnlyCollection<UnknownFieldSet> groupList;
+
+    private UnknownField(ReadOnlyCollection<ulong> varintList,
+        ReadOnlyCollection<uint> fixed32List, 
+        ReadOnlyCollection<ulong> fixed64List, 
+        ReadOnlyCollection<ByteString> lengthDelimitedList, 
+        ReadOnlyCollection<UnknownFieldSet> groupList) {
+      this.varintList = varintList;
+      this.fixed32List = fixed32List;
+      this.fixed64List = fixed64List;
+      this.lengthDelimitedList = lengthDelimitedList;
+      this.groupList = groupList;
+    }
+
+    public static UnknownField DefaultInstance { 
+      get { return defaultInstance; } 
+    }
+
+    /// <summary>
+    /// The list of varint values for this field.
+    /// </summary>
+    public IList<ulong> VarintList {
+      get { return varintList; }
+    }
+
+    /// <summary>
+    /// The list of fixed32 values for this field.
+    /// </summary>
+    public IList<uint> Fixed32List {
+      get { return fixed32List; }
+    }
+
+    /// <summary>
+    /// The list of fixed64 values for this field.
+    /// </summary>
+    public IList<ulong> Fixed64List {
+      get { return fixed64List; }
+    }
+
+    /// <summary>
+    /// The list of length-delimited values for this field.
+    /// </summary>
+    public IList<ByteString> LengthDelimitedList {
+      get { return lengthDelimitedList; }
+    }
+
+    /// <summary>
+    /// The list of embedded group values for this field. These
+    /// are represented using UnknownFieldSets rather than Messages
+    /// since the group's type is presumably unknown.
+    /// </summary>
+    public IList<UnknownFieldSet> GroupList {
+      get { return groupList; }
+    }
+
+    public override bool Equals(object other) {
+      if (ReferenceEquals(this, other)) {
+        return true;
+      }
+      UnknownField otherField = other as UnknownField;
+      return otherField != null
+        && Lists.Equals(varintList, otherField.varintList)
+        && Lists.Equals(fixed32List, otherField.fixed32List)
+        && Lists.Equals(fixed64List, otherField.fixed64List)
+        && Lists.Equals(lengthDelimitedList, otherField.lengthDelimitedList)
+        && Lists.Equals(groupList, otherField.groupList);
+    }
+
+    public override int GetHashCode() {
+      int hash = 43;
+      hash = hash * 47 + Lists.GetHashCode(varintList);
+      hash = hash * 47 + Lists.GetHashCode(fixed32List);
+      hash = hash * 47 + Lists.GetHashCode(fixed64List);
+      hash = hash * 47 + Lists.GetHashCode(lengthDelimitedList);
+      hash = hash * 47 + Lists.GetHashCode(groupList);
+      return hash;
+    }
+
+    /// <summary>
+    /// Constructs a new Builder.
+    /// </summary>
+    public static Builder CreateBuilder() {
+      return new Builder();
+    }
+
+    /// <summary>
+    /// Constructs a new Builder and initializes it to a copy of <paramref name="copyFrom"/>.
+    /// </summary>
+    public static Builder CreateBuilder(UnknownField copyFrom) {
+      return new Builder().MergeFrom(copyFrom);
+    }
+   
+    /// <summary>
+    /// Serializes the field, including the field number, and writes it to
+    /// <paramref name="output"/>.
+    /// </summary>
+    public void WriteTo(int fieldNumber, CodedOutputStream output) {
+      foreach (ulong value in varintList) {
+        output.WriteUInt64(fieldNumber, value);
+      }
+      foreach (uint value in fixed32List) {
+        output.WriteFixed32(fieldNumber, value);
+      }
+      foreach (ulong value in fixed64List) {
+        output.WriteFixed64(fieldNumber, value);
+      }
+      foreach (ByteString value in lengthDelimitedList) {
+        output.WriteBytes(fieldNumber, value);
+      }
+      foreach (UnknownFieldSet value in groupList) {
+#pragma warning disable 0612
+        output.WriteUnknownGroup(fieldNumber, value);
+#pragma warning restore 0612
+      }
+    }
+
+    /// <summary>
+    /// Computes the number of bytes required to encode this field, including field
+    /// number.
+    /// </summary>
+    public int GetSerializedSize(int fieldNumber) {
+      int result = 0;
+      foreach (ulong value in varintList) {
+        result += CodedOutputStream.ComputeUInt64Size(fieldNumber, value);
+      }
+      foreach (uint value in fixed32List) {
+        result += CodedOutputStream.ComputeFixed32Size(fieldNumber, value);
+      }
+      foreach (ulong value in fixed64List) {
+        result += CodedOutputStream.ComputeFixed64Size(fieldNumber, value);
+      }
+      foreach (ByteString value in lengthDelimitedList) {
+        result += CodedOutputStream.ComputeBytesSize(fieldNumber, value);
+      }
+      foreach (UnknownFieldSet value in groupList) {
+#pragma warning disable 0612
+        result += CodedOutputStream.ComputeUnknownGroupSize(fieldNumber, value);
+#pragma warning restore 0612
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Serializes the length-delimited values of the field, including field
+    /// number, and writes them to <paramref name="output"/> using the MessageSet wire format.
+    /// </summary>
+    /// <param name="fieldNumber"></param>
+    /// <param name="output"></param>
+    public void WriteAsMessageSetExtensionTo(int fieldNumber, CodedOutputStream output) {
+      foreach (ByteString value in lengthDelimitedList) {
+        output.WriteRawMessageSetExtension(fieldNumber, value);
+      }
+    }
+
+    /// <summary>
+    /// Get the number of bytes required to encode this field, incuding field number,
+    /// using the MessageSet wire format.
+    /// </summary>
+    public int GetSerializedSizeAsMessageSetExtension(int fieldNumber) {
+      int result = 0;
+      foreach (ByteString value in lengthDelimitedList) {
+        result += CodedOutputStream.ComputeRawMessageSetExtensionSize(fieldNumber, value);
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Used to build instances of UnknownField.
+    /// </summary>
+    public sealed class Builder {
+
+      private List<ulong> varintList;
+      private List<uint> fixed32List;
+      private List<ulong> fixed64List;
+      private List<ByteString> lengthDelimitedList;
+      private List<UnknownFieldSet> groupList;
+
+      /// <summary>
+      /// Builds the field. After building, the builder is reset to an empty
+      /// state. (This is actually easier than making it unusable.)
+      /// </summary>
+      public UnknownField Build() {
+        return new UnknownField(MakeReadOnly(ref varintList),
+            MakeReadOnly(ref fixed32List),
+            MakeReadOnly(ref fixed64List),
+            MakeReadOnly(ref lengthDelimitedList),
+            MakeReadOnly(ref groupList));
+      }
+
+      /// <summary>
+      /// Merge the values in <paramref name="other" /> into this field.  For each list
+      /// of values, <paramref name="other"/>'s values are append to the ones in this
+      /// field.
+      /// </summary>
+      public Builder MergeFrom(UnknownField other) {
+        varintList = AddAll(varintList, other.VarintList);
+        fixed32List = AddAll(fixed32List, other.Fixed32List);
+        fixed64List = AddAll(fixed64List, other.Fixed64List);
+        lengthDelimitedList = AddAll(lengthDelimitedList, other.LengthDelimitedList);
+        groupList = AddAll(groupList, other.GroupList);
+        return this;
+      }
+
+      /// <summary>
+      /// Returns a new list containing all of the given specified values from
+      /// both the <paramref name="current"/> and <paramref name="extras"/> lists.
+      /// If <paramref name="current" /> is null and <paramref name="extras"/> is empty,
+      /// null is returned. Otherwise, either a new list is created (if <paramref name="current" />
+      /// is null) or the elements of <paramref name="extras"/> are added to <paramref name="current" />.
+      /// </summary>
+      private static List<T> AddAll<T>(List<T> current, IList<T> extras)
+      {
+        if (extras.Count == 0) {
+          return current;
+        }
+           if (current == null) {
+          current = new List<T>(extras);
+        } else {
+          current.AddRange(extras);
+        }
+        return current;
+      }
+
+      /// <summary>
+      /// Clears the contents of this builder.
+      /// </summary>
+      public Builder Clear() {
+        varintList = null;
+        fixed32List = null;
+        fixed64List = null;
+        lengthDelimitedList = null;
+        groupList = null;
+        return this;
+      }
+
+      /// <summary>
+      /// Adds a varint value.
+      /// </summary>
+      [CLSCompliant(false)]
+      public Builder AddVarint(ulong value) {
+        varintList = Add(varintList, value);
+        return this;
+      }
+
+      /// <summary>
+      /// Adds a fixed32 value.
+      /// </summary>
+      [CLSCompliant(false)]
+      public Builder AddFixed32(uint value) {
+        fixed32List = Add(fixed32List, value);
+        return this;
+      }
+
+      /// <summary>
+      /// Adds a fixed64 value.
+      /// </summary>
+      [CLSCompliant(false)]
+      public Builder AddFixed64(ulong value) {
+        fixed64List = Add(fixed64List, value);
+        return this;
+      }
+
+      /// <summary>
+      /// Adds a length-delimited value.
+      /// </summary>
+      public Builder AddLengthDelimited(ByteString value) {
+        lengthDelimitedList = Add(lengthDelimitedList, value);
+        return this;
+      }
+
+      /// <summary>
+      /// Adds an embedded group.
+      /// </summary>
+      /// <param name="value"></param>
+      /// <returns></returns>
+      public Builder AddGroup(UnknownFieldSet value) {
+        groupList = Add(groupList, value);
+        return this;
+      }
+
+      /// <summary>
+      /// Adds <paramref name="value"/> to the <paramref name="list"/>, creating
+      /// a new list if <paramref name="list"/> is null. The list is returned - either
+      /// the original reference or the new list.
+      /// </summary>
+      private static List<T> Add<T>(List<T> list, T value) {
+        if (list == null) {
+          list = new List<T>();
+        }
+        list.Add(value);
+        return list;
+      }
+
+      /// <summary>
+      /// Returns a read-only version of the given IList, and clears
+      /// the field used for <paramref name="list"/>. If the value
+      /// is null, an empty list is produced using Lists.Empty.
+      /// </summary>
+      /// <returns></returns>
+      private static ReadOnlyCollection<T> MakeReadOnly<T>(ref List<T> list) {
+        ReadOnlyCollection<T> ret = list == null ? Lists<T>.Empty : new ReadOnlyCollection<T>(list);
+           list = null;
+        return ret;
+      }
+    }
+  }
+}

src/ProtocolBuffers/WireFormat.cs

@@ -1,56 +1,56 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-#if !LITE
-using Google.ProtocolBuffers.Descriptors;
-#endif
-
-namespace Google.ProtocolBuffers {
-  
-  /// <summary>
-  /// This class is used internally by the Protocol Buffer Library and generated
-  /// message implementations. It is public only for the sake of those generated
-  /// messages. Others should not use this class directly.
-  /// <para>
-  /// This class contains constants and helper functions useful for dealing with
-  /// the Protocol Buffer wire format.
-  /// </para>
-  /// </summary>
-  public static class WireFormat {
-
-#region Fixed sizes.
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+#if !LITE
+using Google.ProtocolBuffers.Descriptors;
+#endif
+
+namespace Google.ProtocolBuffers {
+  
+  /// <summary>
+  /// This class is used internally by the Protocol Buffer Library and generated
+  /// message implementations. It is public only for the sake of those generated
+  /// messages. Others should not use this class directly.
+  /// <para>
+  /// This class contains constants and helper functions useful for dealing with
+  /// the Protocol Buffer wire format.
+  /// </para>
+  /// </summary>
+  public static class WireFormat {
+
+#region Fixed sizes.
     // TODO(jonskeet): Move these somewhere else. They're messy. Consider making FieldType a smarter kind of enum
     public const int Fixed32Size = 4;
     public const int Fixed64Size = 8;
@@ -58,121 +58,121 @@ namespace Google.ProtocolBuffers {
     public const int SFixed64Size = 8;
     public const int FloatSize = 4;
     public const int DoubleSize = 8;
-    public const int BoolSize = 1;
-#endregion
-
-    [CLSCompliant(false)]
-    public enum WireType : uint {
-      Varint = 0,
-      Fixed64 = 1,
-      LengthDelimited = 2,
-      StartGroup = 3,
-      EndGroup = 4,
-      Fixed32 = 5
-    }
-
-    internal static class MessageSetField {
-      internal const int Item = 1;
-      internal const int TypeID = 2;
-      internal const int Message = 3;
-    }
-
-    internal static class MessageSetTag {
-      internal static readonly uint ItemStart = MakeTag(MessageSetField.Item, WireType.StartGroup);
-      internal static readonly uint ItemEnd = MakeTag(MessageSetField.Item, WireType.EndGroup);
-      internal static readonly uint TypeID = MakeTag(MessageSetField.TypeID, WireType.Varint);
-      internal static readonly uint Message = MakeTag(MessageSetField.Message, WireType.LengthDelimited);
-    }
-  
-    private const int TagTypeBits = 3;
-    private const uint TagTypeMask = (1 << TagTypeBits) - 1;
-
-    /// <summary>
-    /// Given a tag value, determines the wire type (lower 3 bits).
-    /// </summary>
-    [CLSCompliant(false)]
-    public static WireType GetTagWireType(uint tag) {
-      return (WireType) (tag & TagTypeMask);
-    }
-
-    [CLSCompliant(false)]
-    public static bool IsEndGroupTag(uint tag) {
-      return (WireType)(tag & TagTypeMask) == WireType.EndGroup;
-    }
-
-    /// <summary>
-    /// Given a tag value, determines the field number (the upper 29 bits).
-    /// </summary>
-    [CLSCompliant(false)]
-    public static int GetTagFieldNumber(uint tag) {
-      return (int) tag >> TagTypeBits;
-    }
-
-    /// <summary>
-    /// Makes a tag value given a field number and wire type.
-    /// TODO(jonskeet): Should we just have a Tag structure?
-    /// </summary>
-    [CLSCompliant(false)]
-    public static uint MakeTag(int fieldNumber, WireType wireType) {
-      return (uint) (fieldNumber << TagTypeBits) | (uint) wireType;
-    }
-
-#if !LITE
-    [CLSCompliant(false)]
-    public static uint MakeTag(FieldDescriptor field) {
-      return MakeTag(field.FieldNumber, GetWireType(field));
-    }
-
-    /// <summary>
-    /// Returns the wire type for the given field descriptor. This differs
-    /// from GetWireType(FieldType) for packed repeated fields.
-    /// </summary>
-    internal static WireType GetWireType(FieldDescriptor descriptor) {
-      return descriptor.IsPacked ? WireType.LengthDelimited : GetWireType(descriptor.FieldType);
-    }
-
-    /// <summary>
-    /// Converts a field type to its wire type. Done with a switch for the sake
-    /// of speed - this is significantly faster than a dictionary lookup.
-    /// </summary>
-    [CLSCompliant(false)]
-    public static WireType GetWireType(FieldType fieldType) {
-      switch (fieldType) {
-        case FieldType.Double:
-          return WireType.Fixed64;
-        case FieldType.Float:
-          return WireType.Fixed32;
-        case FieldType.Int64:
-        case FieldType.UInt64:
-        case FieldType.Int32:
-          return WireType.Varint;
-        case FieldType.Fixed64:
-          return WireType.Fixed64;
-        case FieldType.Fixed32:
-          return WireType.Fixed32;
-        case FieldType.Bool:
-          return WireType.Varint;
-        case FieldType.String:
-          return WireType.LengthDelimited;
-        case FieldType.Group:
-          return WireType.StartGroup;
-        case FieldType.Message:
-        case FieldType.Bytes:
-          return WireType.LengthDelimited;
-        case FieldType.UInt32:
-          return WireType.Varint;
-        case FieldType.SFixed32:
-          return WireType.Fixed32;
-        case FieldType.SFixed64:
-          return WireType.Fixed64;
-        case FieldType.SInt32:
-        case FieldType.SInt64:
-        case FieldType.Enum:
-          return WireType.Varint;
-        default:
-          throw new ArgumentOutOfRangeException("No such field type");
-      }
-    }
-#endif
-  }
-}
+    public const int BoolSize = 1;
+#endregion
+
+    [CLSCompliant(false)]
+    public enum WireType : uint {
+      Varint = 0,
+      Fixed64 = 1,
+      LengthDelimited = 2,
+      StartGroup = 3,
+      EndGroup = 4,
+      Fixed32 = 5
+    }
+
+    internal static class MessageSetField {
+      internal const int Item = 1;
+      internal const int TypeID = 2;
+      internal const int Message = 3;
+    }
+
+    internal static class MessageSetTag {
+      internal static readonly uint ItemStart = MakeTag(MessageSetField.Item, WireType.StartGroup);
+      internal static readonly uint ItemEnd = MakeTag(MessageSetField.Item, WireType.EndGroup);
+      internal static readonly uint TypeID = MakeTag(MessageSetField.TypeID, WireType.Varint);
+      internal static readonly uint Message = MakeTag(MessageSetField.Message, WireType.LengthDelimited);
+    }
+  
+    private const int TagTypeBits = 3;
+    private const uint TagTypeMask = (1 << TagTypeBits) - 1;
+
+    /// <summary>
+    /// Given a tag value, determines the wire type (lower 3 bits).
+    /// </summary>
+    [CLSCompliant(false)]
+    public static WireType GetTagWireType(uint tag) {
+      return (WireType) (tag & TagTypeMask);
+    }
+
+    [CLSCompliant(false)]
+    public static bool IsEndGroupTag(uint tag) {
+      return (WireType)(tag & TagTypeMask) == WireType.EndGroup;
+    }
+
+    /// <summary>
+    /// Given a tag value, determines the field number (the upper 29 bits).
+    /// </summary>
+    [CLSCompliant(false)]
+    public static int GetTagFieldNumber(uint tag) {
+      return (int) tag >> TagTypeBits;
+    }
+
+    /// <summary>
+    /// Makes a tag value given a field number and wire type.
+    /// TODO(jonskeet): Should we just have a Tag structure?
+    /// </summary>
+    [CLSCompliant(false)]
+    public static uint MakeTag(int fieldNumber, WireType wireType) {
+      return (uint) (fieldNumber << TagTypeBits) | (uint) wireType;
+    }
+
+#if !LITE
+    [CLSCompliant(false)]
+    public static uint MakeTag(FieldDescriptor field) {
+      return MakeTag(field.FieldNumber, GetWireType(field));
+    }
+
+    /// <summary>
+    /// Returns the wire type for the given field descriptor. This differs
+    /// from GetWireType(FieldType) for packed repeated fields.
+    /// </summary>
+    internal static WireType GetWireType(FieldDescriptor descriptor) {
+      return descriptor.IsPacked ? WireType.LengthDelimited : GetWireType(descriptor.FieldType);
+    }
+
+    /// <summary>
+    /// Converts a field type to its wire type. Done with a switch for the sake
+    /// of speed - this is significantly faster than a dictionary lookup.
+    /// </summary>
+    [CLSCompliant(false)]
+    public static WireType GetWireType(FieldType fieldType) {
+      switch (fieldType) {
+        case FieldType.Double:
+          return WireType.Fixed64;
+        case FieldType.Float:
+          return WireType.Fixed32;
+        case FieldType.Int64:
+        case FieldType.UInt64:
+        case FieldType.Int32:
+          return WireType.Varint;
+        case FieldType.Fixed64:
+          return WireType.Fixed64;
+        case FieldType.Fixed32:
+          return WireType.Fixed32;
+        case FieldType.Bool:
+          return WireType.Varint;
+        case FieldType.String:
+          return WireType.LengthDelimited;
+        case FieldType.Group:
+          return WireType.StartGroup;
+        case FieldType.Message:
+        case FieldType.Bytes:
+          return WireType.LengthDelimited;
+        case FieldType.UInt32:
+          return WireType.Varint;
+        case FieldType.SFixed32:
+          return WireType.Fixed32;
+        case FieldType.SFixed64:
+          return WireType.Fixed64;
+        case FieldType.SInt32:
+        case FieldType.SInt64:
+        case FieldType.Enum:
+          return WireType.Varint;
+        default:
+          throw new ArgumentOutOfRangeException("No such field type");
+      }
+    }
+#endif
+  }
+}

src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs

@@ -1,268 +1,268 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections.Generic;
-using System.IO;
-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());
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections.Generic;
+using System.IO;
+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());
+    }
+  }
+}

src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs

@@ -1,126 +1,126 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections.Generic;
-using System.IO;
-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]);
-    }
-
-    [Test]
-    public void TestMessageLiteToByteArray() {
-      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);
-    }
-
-    [Test]
-    public void TestMessageLiteWriteTo() {
-      TestRequiredLite msg = TestRequiredLite.CreateBuilder()
-        .SetD(42)
-        .SetEn(ExtraEnum.EXLITE_BAZ)
-        .Build();
-
-      MemoryStream ms = new MemoryStream();
-      msg.WriteTo(ms);
-      Assert.AreEqual(msg.ToByteArray(), ms.ToArray());
-    }
-
-    [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);
-    }
-
-    [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));
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections.Generic;
+using System.IO;
+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]);
+    }
+
+    [Test]
+    public void TestMessageLiteToByteArray() {
+      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);
+    }
+
+    [Test]
+    public void TestMessageLiteWriteTo() {
+      TestRequiredLite msg = TestRequiredLite.CreateBuilder()
+        .SetD(42)
+        .SetEn(ExtraEnum.EXLITE_BAZ)
+        .Build();
+
+      MemoryStream ms = new MemoryStream();
+      msg.WriteTo(ms);
+      Assert.AreEqual(msg.ToByteArray(), ms.ToArray());
+    }
+
+    [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);
+    }
+
+    [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));
+    }
+  }
+}

src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs

@@ -1,267 +1,267 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections;
-using System.Collections.Generic;
-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()
-    {
-        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);
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections;
+using System.Collections.Generic;
+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()
+    {
+        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);
+    }
+  }
+}

src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs

@@ -1,304 +1,304 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections.Generic;
-using System.Text;
-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();
-
-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
-
-      copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
-      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
-    }
-
-    [Test]
-    public void ExtensionWriterIsInitialized() {
-      Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized);
-      Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized);
-      Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension(
-        UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance)
-        .IsInitialized);
-    }
-
-    [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 })
-        ;
-
-      msg = builder.Build();
-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
-
-      copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
-      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
-
-      Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO, copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 1));
-    }
-
-    [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();
-
-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
-
-      TestAllExtensionsLite.Builder copyBuilder = TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
-      TestAllExtensionsLite copy = copyBuilder.Build();
-
-      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
-
-      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(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));
-    }
-
-    [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);
-
-      TestPackedExtensionsLite msg = builder.Build();
-
-      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
-      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
-
-      TestPackedExtensionsLite.Builder copyBuilder = TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
-      TestPackedExtensionsLite copy = copyBuilder.Build();
-
-      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
-
-      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));
-
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections.Generic;
+using System.Text;
+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();
+
+      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
+      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
+
+      copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
+      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
+    }
+
+    [Test]
+    public void ExtensionWriterIsInitialized() {
+      Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized);
+      Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized);
+      Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension(
+        UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance)
+        .IsInitialized);
+    }
+
+    [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 })
+        ;
+
+      msg = builder.Build();
+      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
+      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
+
+      copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
+      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
+
+      Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO, copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 1));
+    }
+
+    [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();
+
+      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
+      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
+
+      TestAllExtensionsLite.Builder copyBuilder = TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
+      TestAllExtensionsLite copy = copyBuilder.Build();
+
+      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
+
+      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(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));
+    }
+
+    [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);
+
+      TestPackedExtensionsLite msg = builder.Build();
+
+      ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
+      UnitTestLiteProtoFile.RegisterAllExtensions(registry);
+
+      TestPackedExtensionsLite.Builder copyBuilder = TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
+      TestPackedExtensionsLite copy = copyBuilder.Build();
+
+      Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
+
+      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));
+
+    }
+  }
+}

src/ProtocolBuffersLite.Test/InteropLiteTest.cs

@@ -1,162 +1,162 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections.Generic;
-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);
-    }
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections.Generic;
+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);
+    }
+  }
+}

src/ProtocolBuffersLite.Test/LiteTest.cs

@@ -1,112 +1,112 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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;
-using System.Collections.Generic;
-using System.IO;
-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.
-
-      TestAllTypesLite message =
-        TestAllTypesLite.CreateBuilder()
-                        .SetOptionalInt32(123)
-                        .AddRepeatedString("hello")
-                        .SetOptionalNestedMessage(
-                            TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7))
-                        .Build();
-
-      ByteString data = message.ToByteString();
-
-      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);
-    }
-
-    [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();
-
-      // 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);
-    }
-  }
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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;
+using System.Collections.Generic;
+using System.IO;
+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.
+
+      TestAllTypesLite message =
+        TestAllTypesLite.CreateBuilder()
+                        .SetOptionalInt32(123)
+                        .AddRepeatedString("hello")
+                        .SetOptionalNestedMessage(
+                            TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7))
+                        .Build();
+
+      ByteString data = message.ToByteString();
+
+      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);
+    }
+
+    [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();
+
+      // 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);
+    }
+  }
 }

src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs

@@ -1,219 +1,219 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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.IO;
-using NUnit.Framework;
-using System.Collections.Generic;
-using Google.ProtocolBuffers.TestProtos;
-
-namespace Google.ProtocolBuffers {
-    [TestFixture]
-    public class MissingFieldAndExtensionTest {
-        [Test]
-        public void TestRecoverMissingExtensions() {
-            const int optionalInt32 = 12345678;
-            TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
-            builder.SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32);
-            builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.1);
-            builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.2);
-            builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.3);
-            TestAllExtensions msg = builder.Build();
-
-            Assert.IsTrue(msg.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
-            Assert.AreEqual(3, msg.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
-
-            byte[] bits = msg.ToByteArray();
-            TestAllExtensions copy = TestAllExtensions.ParseFrom(bits);
-            Assert.IsFalse(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
-            Assert.AreEqual(0, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
-            Assert.AreNotEqual(msg, copy);
-
-            //Even though copy does not understand the typees they serialize correctly
-            byte[] copybits = copy.ToByteArray();
-            Assert.AreEqual(bits, copybits);
-
-            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
-            UnitTestProtoFile.RegisterAllExtensions(registry);
-
-            //Now we can take those copy bits and restore the full message with extensions
-            copy = TestAllExtensions.ParseFrom(copybits, registry);
-            Assert.IsTrue(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
-            Assert.AreEqual(3, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
-
-            Assert.AreEqual(msg, copy);
-            Assert.AreEqual(bits, copy.ToByteArray());
-
-            //If we modify the object this should all continue to work as before
-            copybits = copy.ToBuilder().Build().ToByteArray();
-            Assert.AreEqual(bits, copybits);
-
-            //If we replace extension the object this should all continue to work as before
-            copybits = copy.ToBuilder()
-                .SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32)
-                .Build().ToByteArray();
-            Assert.AreEqual(bits, copybits);
-        }
-
-        [Test]
-        public void TestRecoverMissingFields() {
-            TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder()
-                .SetId(1001)
-                .SetName("Name")
-                .SetEmail("missing@field.value")
-                .Build();
-
-            //serialize to type B and verify all fields exist
-            TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
-            Assert.AreEqual(1001, msgb.Id);
-            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());
-
-            //serializes exactly the same (at least for this simple example)
-            Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());
-            Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
-
-            //now re-create an exact copy of A from serialized B
-            TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
-            Assert.AreEqual(msga, copya);
-            Assert.AreEqual(1001, copya.Id);
-            Assert.AreEqual("Name", copya.Name);
-            Assert.AreEqual("missing@field.value", copya.Email);
-
-            //Now we modify B... and try again
-            msgb = msgb.ToBuilder().SetWebsite("http://new.missing.field").Build();
-            //Does B still have the missing field?
-            Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
-
-            //Convert back to A and see if all fields are there?
-            copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
-            Assert.AreNotEqual(msga, copya);
-            Assert.AreEqual(1001, copya.Id);
-            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());
-
-            //Lastly we can even still trip back to type B and see all fields:
-            TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
-            Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
-            Assert.AreEqual(1001, copyb.Id);
-            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());
-        }
-
-        [Test]
-        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")
-                .SetTestA(suba)
-                .Build();
-
-            //serialize to type B and verify all fields exist
-            TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
-            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());
-
-            //serializes exactly the same (at least for this simple example)
-            Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());
-            Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
-
-            //now re-create an exact copy of A from serialized B
-            TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
-            Assert.AreEqual(msga, copya);
-            Assert.AreEqual(1001, copya.Id);
-            Assert.AreEqual("Name", copya.Name);
-            Assert.AreEqual(suba, copya.TestA);
-
-            //Now we modify B... and try again
-            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);
-
-            //Convert back to A and see if all fields are there?
-            copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
-            Assert.AreNotEqual(msga, copya);
-            Assert.AreEqual(1001, copya.Id);
-            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());
-
-            //Lastly we can even still trip back to type B and see all fields:
-            TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
-            Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
-            Assert.AreEqual(1001, copyb.Id);
-            Assert.AreEqual("Name", copyb.Name);
-            Assert.AreEqual(subb, copyb.TestB);
-            Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count);
-        }
-
-        [Test]
-        public void TestRestoreFromOtherType() {
-            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);
-
-            TestEmptyMessage temp = TestEmptyMessage.ParseFrom(person.ToByteArray());
-            Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
-            temp = temp.ToBuilder().Build();
-            Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
-
-            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
-            UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);
-
-            TestInteropPerson copy = TestInteropPerson.ParseFrom(temp.ToByteArray(), registry);
-            Assert.AreEqual(person, copy);
-            Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
-        }
-    }
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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.IO;
+using NUnit.Framework;
+using System.Collections.Generic;
+using Google.ProtocolBuffers.TestProtos;
+
+namespace Google.ProtocolBuffers {
+    [TestFixture]
+    public class MissingFieldAndExtensionTest {
+        [Test]
+        public void TestRecoverMissingExtensions() {
+            const int optionalInt32 = 12345678;
+            TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+            builder.SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32);
+            builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.1);
+            builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.2);
+            builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.3);
+            TestAllExtensions msg = builder.Build();
+
+            Assert.IsTrue(msg.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
+            Assert.AreEqual(3, msg.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
+
+            byte[] bits = msg.ToByteArray();
+            TestAllExtensions copy = TestAllExtensions.ParseFrom(bits);
+            Assert.IsFalse(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
+            Assert.AreEqual(0, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
+            Assert.AreNotEqual(msg, copy);
+
+            //Even though copy does not understand the typees they serialize correctly
+            byte[] copybits = copy.ToByteArray();
+            Assert.AreEqual(bits, copybits);
+
+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
+            UnitTestProtoFile.RegisterAllExtensions(registry);
+
+            //Now we can take those copy bits and restore the full message with extensions
+            copy = TestAllExtensions.ParseFrom(copybits, registry);
+            Assert.IsTrue(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
+            Assert.AreEqual(3, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
+
+            Assert.AreEqual(msg, copy);
+            Assert.AreEqual(bits, copy.ToByteArray());
+
+            //If we modify the object this should all continue to work as before
+            copybits = copy.ToBuilder().Build().ToByteArray();
+            Assert.AreEqual(bits, copybits);
+
+            //If we replace extension the object this should all continue to work as before
+            copybits = copy.ToBuilder()
+                .SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32)
+                .Build().ToByteArray();
+            Assert.AreEqual(bits, copybits);
+        }
+
+        [Test]
+        public void TestRecoverMissingFields() {
+            TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder()
+                .SetId(1001)
+                .SetName("Name")
+                .SetEmail("missing@field.value")
+                .Build();
+
+            //serialize to type B and verify all fields exist
+            TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
+            Assert.AreEqual(1001, msgb.Id);
+            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());
+
+            //serializes exactly the same (at least for this simple example)
+            Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());
+            Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
+
+            //now re-create an exact copy of A from serialized B
+            TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
+            Assert.AreEqual(msga, copya);
+            Assert.AreEqual(1001, copya.Id);
+            Assert.AreEqual("Name", copya.Name);
+            Assert.AreEqual("missing@field.value", copya.Email);
+
+            //Now we modify B... and try again
+            msgb = msgb.ToBuilder().SetWebsite("http://new.missing.field").Build();
+            //Does B still have the missing field?
+            Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
+
+            //Convert back to A and see if all fields are there?
+            copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
+            Assert.AreNotEqual(msga, copya);
+            Assert.AreEqual(1001, copya.Id);
+            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());
+
+            //Lastly we can even still trip back to type B and see all fields:
+            TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
+            Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
+            Assert.AreEqual(1001, copyb.Id);
+            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());
+        }
+
+        [Test]
+        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")
+                .SetTestA(suba)
+                .Build();
+
+            //serialize to type B and verify all fields exist
+            TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
+            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());
+
+            //serializes exactly the same (at least for this simple example)
+            Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());
+            Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
+
+            //now re-create an exact copy of A from serialized B
+            TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
+            Assert.AreEqual(msga, copya);
+            Assert.AreEqual(1001, copya.Id);
+            Assert.AreEqual("Name", copya.Name);
+            Assert.AreEqual(suba, copya.TestA);
+
+            //Now we modify B... and try again
+            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);
+
+            //Convert back to A and see if all fields are there?
+            copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
+            Assert.AreNotEqual(msga, copya);
+            Assert.AreEqual(1001, copya.Id);
+            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());
+
+            //Lastly we can even still trip back to type B and see all fields:
+            TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
+            Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
+            Assert.AreEqual(1001, copyb.Id);
+            Assert.AreEqual("Name", copyb.Name);
+            Assert.AreEqual(subb, copyb.TestB);
+            Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count);
+        }
+
+        [Test]
+        public void TestRestoreFromOtherType() {
+            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);
+
+            TestEmptyMessage temp = TestEmptyMessage.ParseFrom(person.ToByteArray());
+            Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
+            temp = temp.ToBuilder().Build();
+            Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
+
+            ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
+            UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);
+
+            TestInteropPerson copy = TestInteropPerson.ParseFrom(temp.ToByteArray(), registry);
+            Assert.AreEqual(person, copy);
+            Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
+        }
+    }
 }

src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj

@@ -1,84 +1,84 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.30729</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{EE01ED24-3750-4567-9A23-1DB676A15610}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Google.ProtocolBuffers</RootNamespace>
-    <AssemblyName>Google.ProtocolBuffersLite.Test</AssemblyName>
-    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>..\..\keys\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile>
-    <FileUpgradeFlags>
-    </FileUpgradeFlags>
-    <OldToolsVersion>3.5</OldToolsVersion>
-    <UpgradeBackupLocation />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <NoStdLib>true</NoStdLib>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <NoStdLib>true</NoStdLib>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\NUnit 2.2.8.0\nunit.framework.dll</HintPath>
-    </Reference>
-    <Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\Rhino.Mocks.dll</HintPath>
-    </Reference>
-    <Reference Include="mscorlib" />
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\ProtocolBuffers.Test\Properties\AssemblyInfo.cs">
-      <Link>Properties\AssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="AbstractBuilderLiteTest.cs" />
-    <Compile Include="AbstractMessageLiteTest.cs" />
-    <Compile Include="ExtendableBuilderLiteTest.cs" />
-    <Compile Include="ExtendableMessageLiteTest.cs" />
-    <Compile Include="LiteTest.cs" />
-    <Compile Include="TestLiteByApi.cs" />
-    <Compile Include="TestProtos\UnitTestExtrasLiteProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestImportLiteProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestLiteProtoFile.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffersLite.csproj">
-      <Project>{6969BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
-      <Name>ProtocolBuffersLite</Name>
-      <Private>True</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EE01ED24-3750-4567-9A23-1DB676A15610}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Google.ProtocolBuffers</RootNamespace>
+    <AssemblyName>Google.ProtocolBuffersLite.Test</AssemblyName>
+    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\..\keys\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <NoStdLib>true</NoStdLib>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <NoStdLib>true</NoStdLib>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\NUnit 2.2.8.0\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\Rhino.Mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="mscorlib" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\ProtocolBuffers.Test\Properties\AssemblyInfo.cs">
+      <Link>Properties\AssemblyInfo.cs</Link>
+    </Compile>
+    <Compile Include="AbstractBuilderLiteTest.cs" />
+    <Compile Include="AbstractMessageLiteTest.cs" />
+    <Compile Include="ExtendableBuilderLiteTest.cs" />
+    <Compile Include="ExtendableMessageLiteTest.cs" />
+    <Compile Include="LiteTest.cs" />
+    <Compile Include="TestLiteByApi.cs" />
+    <Compile Include="TestProtos\UnitTestExtrasLiteProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestImportLiteProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestLiteProtoFile.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffersLite.csproj">
+      <Project>{6969BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
+      <Name>ProtocolBuffersLite</Name>
+      <Private>True</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
 </Project>

src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj

@@ -1,89 +1,89 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.30729</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{EEFFED24-3750-4567-9A23-1DB676A15610}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Google.ProtocolBuffers</RootNamespace>
-    <AssemblyName>Google.ProtocolBuffersMixedLite.Test</AssemblyName>
-    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>..\..\keys\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile>
-    <FileUpgradeFlags>
-    </FileUpgradeFlags>
-    <OldToolsVersion>3.5</OldToolsVersion>
-    <UpgradeBackupLocation />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <NoStdLib>true</NoStdLib>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <NoStdLib>true</NoStdLib>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\NUnit 2.2.8.0\nunit.framework.dll</HintPath>
-    </Reference>
-    <Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\Rhino.Mocks.dll</HintPath>
-    </Reference>
-    <Reference Include="mscorlib" />
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\ProtocolBuffers.Test\Properties\AssemblyInfo.cs">
-      <Link>Properties\AssemblyInfo.cs</Link>
-    </Compile>
-    <Compile Include="AbstractBuilderLiteTest.cs" />
-    <Compile Include="AbstractMessageLiteTest.cs" />
-    <Compile Include="ExtendableBuilderLiteTest.cs" />
-    <Compile Include="ExtendableMessageLiteTest.cs" />
-    <Compile Include="InteropLiteTest.cs" />
-    <Compile Include="LiteTest.cs" />
-    <Compile Include="MissingFieldAndExtensionTest.cs" />
-    <Compile Include="TestLiteByApi.cs" />
-    <Compile Include="TestProtos\UnitTestExtrasFullProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestExtrasLiteProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestImportLiteProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestImportProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestLiteImportNonLiteProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestLiteProtoFile.cs" />
-    <Compile Include="TestProtos\UnitTestProtoFile.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
-      <Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
-      <Name>ProtocolBuffers</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EEFFED24-3750-4567-9A23-1DB676A15610}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Google.ProtocolBuffers</RootNamespace>
+    <AssemblyName>Google.ProtocolBuffersMixedLite.Test</AssemblyName>
+    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\..\keys\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <NoStdLib>true</NoStdLib>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <NoStdLib>true</NoStdLib>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\NUnit 2.2.8.0\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\Rhino.Mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="mscorlib" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\ProtocolBuffers.Test\Properties\AssemblyInfo.cs">
+      <Link>Properties\AssemblyInfo.cs</Link>
+    </Compile>
+    <Compile Include="AbstractBuilderLiteTest.cs" />
+    <Compile Include="AbstractMessageLiteTest.cs" />
+    <Compile Include="ExtendableBuilderLiteTest.cs" />
+    <Compile Include="ExtendableMessageLiteTest.cs" />
+    <Compile Include="InteropLiteTest.cs" />
+    <Compile Include="LiteTest.cs" />
+    <Compile Include="MissingFieldAndExtensionTest.cs" />
+    <Compile Include="TestLiteByApi.cs" />
+    <Compile Include="TestProtos\UnitTestExtrasFullProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestExtrasLiteProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestImportLiteProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestImportProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestLiteImportNonLiteProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestLiteProtoFile.cs" />
+    <Compile Include="TestProtos\UnitTestProtoFile.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
+      <Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
+      <Name>ProtocolBuffers</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
 </Project>

src/ProtocolBuffersLite.Test/TestLiteByApi.cs

@@ -1,113 +1,113 @@
-#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/
-// Original C++/Java/Python code:
-// http://code.google.com/p/protobuf/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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));
-    }
-
-    [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 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());
-    }
-
-  }
-}
+#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/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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));
+    }
+
+    [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 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());
+    }
+
+  }
+}

testdata/text_format_unittest_data.txt

@@ -1,116 +1,116 @@
-optional_int32: 101
-optional_int64: 102
-optional_uint32: 103
-optional_uint64: 104
-optional_sint32: 105
-optional_sint64: 106
-optional_fixed32: 107
-optional_fixed64: 108
-optional_sfixed32: 109
-optional_sfixed64: 110
-optional_float: 111
-optional_double: 112
-optional_bool: true
-optional_string: "115"
-optional_bytes: "116"
-OptionalGroup {
-  a: 117
-}
-optional_nested_message {
-  bb: 118
-}
-optional_foreign_message {
-  c: 119
-}
-optional_import_message {
-  d: 120
-}
-optional_nested_enum: BAZ
-optional_foreign_enum: FOREIGN_BAZ
-optional_import_enum: IMPORT_BAZ
-optional_string_piece: "124"
-optional_cord: "125"
-repeated_int32: 201
-repeated_int32: 301
-repeated_int64: 202
-repeated_int64: 302
-repeated_uint32: 203
-repeated_uint32: 303
-repeated_uint64: 204
-repeated_uint64: 304
-repeated_sint32: 205
-repeated_sint32: 305
-repeated_sint64: 206
-repeated_sint64: 306
-repeated_fixed32: 207
-repeated_fixed32: 307
-repeated_fixed64: 208
-repeated_fixed64: 308
-repeated_sfixed32: 209
-repeated_sfixed32: 309
-repeated_sfixed64: 210
-repeated_sfixed64: 310
-repeated_float: 211
-repeated_float: 311
-repeated_double: 212
-repeated_double: 312
-repeated_bool: true
-repeated_bool: false
-repeated_string: "215"
-repeated_string: "315"
-repeated_bytes: "216"
-repeated_bytes: "316"
-RepeatedGroup {
-  a: 217
-}
-RepeatedGroup {
-  a: 317
-}
-repeated_nested_message {
-  bb: 218
-}
-repeated_nested_message {
-  bb: 318
-}
-repeated_foreign_message {
-  c: 219
-}
-repeated_foreign_message {
-  c: 319
-}
-repeated_import_message {
-  d: 220
-}
-repeated_import_message {
-  d: 320
-}
-repeated_nested_enum: BAR
-repeated_nested_enum: BAZ
-repeated_foreign_enum: FOREIGN_BAR
-repeated_foreign_enum: FOREIGN_BAZ
-repeated_import_enum: IMPORT_BAR
-repeated_import_enum: IMPORT_BAZ
-repeated_string_piece: "224"
-repeated_string_piece: "324"
-repeated_cord: "225"
-repeated_cord: "325"
-default_int32: 401
-default_int64: 402
-default_uint32: 403
-default_uint64: 404
-default_sint32: 405
-default_sint64: 406
-default_fixed32: 407
-default_fixed64: 408
-default_sfixed32: 409
-default_sfixed64: 410
-default_float: 411
-default_double: 412
-default_bool: false
-default_string: "415"
-default_bytes: "416"
-default_nested_enum: FOO
-default_foreign_enum: FOREIGN_FOO
-default_import_enum: IMPORT_FOO
-default_string_piece: "424"
-default_cord: "425"
+optional_int32: 101
+optional_int64: 102
+optional_uint32: 103
+optional_uint64: 104
+optional_sint32: 105
+optional_sint64: 106
+optional_fixed32: 107
+optional_fixed64: 108
+optional_sfixed32: 109
+optional_sfixed64: 110
+optional_float: 111
+optional_double: 112
+optional_bool: true
+optional_string: "115"
+optional_bytes: "116"
+OptionalGroup {
+  a: 117
+}
+optional_nested_message {
+  bb: 118
+}
+optional_foreign_message {
+  c: 119
+}
+optional_import_message {
+  d: 120
+}
+optional_nested_enum: BAZ
+optional_foreign_enum: FOREIGN_BAZ
+optional_import_enum: IMPORT_BAZ
+optional_string_piece: "124"
+optional_cord: "125"
+repeated_int32: 201
+repeated_int32: 301
+repeated_int64: 202
+repeated_int64: 302
+repeated_uint32: 203
+repeated_uint32: 303
+repeated_uint64: 204
+repeated_uint64: 304
+repeated_sint32: 205
+repeated_sint32: 305
+repeated_sint64: 206
+repeated_sint64: 306
+repeated_fixed32: 207
+repeated_fixed32: 307
+repeated_fixed64: 208
+repeated_fixed64: 308
+repeated_sfixed32: 209
+repeated_sfixed32: 309
+repeated_sfixed64: 210
+repeated_sfixed64: 310
+repeated_float: 211
+repeated_float: 311
+repeated_double: 212
+repeated_double: 312
+repeated_bool: true
+repeated_bool: false
+repeated_string: "215"
+repeated_string: "315"
+repeated_bytes: "216"
+repeated_bytes: "316"
+RepeatedGroup {
+  a: 217
+}
+RepeatedGroup {
+  a: 317
+}
+repeated_nested_message {
+  bb: 218
+}
+repeated_nested_message {
+  bb: 318
+}
+repeated_foreign_message {
+  c: 219
+}
+repeated_foreign_message {
+  c: 319
+}
+repeated_import_message {
+  d: 220
+}
+repeated_import_message {
+  d: 320
+}
+repeated_nested_enum: BAR
+repeated_nested_enum: BAZ
+repeated_foreign_enum: FOREIGN_BAR
+repeated_foreign_enum: FOREIGN_BAZ
+repeated_import_enum: IMPORT_BAR
+repeated_import_enum: IMPORT_BAZ
+repeated_string_piece: "224"
+repeated_string_piece: "324"
+repeated_cord: "225"
+repeated_cord: "325"
+default_int32: 401
+default_int64: 402
+default_uint32: 403
+default_uint64: 404
+default_sint32: 405
+default_sint64: 406
+default_fixed32: 407
+default_fixed64: 408
+default_sfixed32: 409
+default_sfixed64: 410
+default_float: 411
+default_double: 412
+default_bool: false
+default_string: "415"
+default_bytes: "416"
+default_nested_enum: FOO
+default_foreign_enum: FOREIGN_FOO
+default_import_enum: IMPORT_FOO
+default_string_piece: "424"
+default_cord: "425"

testdata/text_format_unittest_extensions_data.txt

@@ -1,116 +1,116 @@
-[protobuf_unittest.optional_int32_extension]: 101
-[protobuf_unittest.optional_int64_extension]: 102
-[protobuf_unittest.optional_uint32_extension]: 103
-[protobuf_unittest.optional_uint64_extension]: 104
-[protobuf_unittest.optional_sint32_extension]: 105
-[protobuf_unittest.optional_sint64_extension]: 106
-[protobuf_unittest.optional_fixed32_extension]: 107
-[protobuf_unittest.optional_fixed64_extension]: 108
-[protobuf_unittest.optional_sfixed32_extension]: 109
-[protobuf_unittest.optional_sfixed64_extension]: 110
-[protobuf_unittest.optional_float_extension]: 111
-[protobuf_unittest.optional_double_extension]: 112
-[protobuf_unittest.optional_bool_extension]: true
-[protobuf_unittest.optional_string_extension]: "115"
-[protobuf_unittest.optional_bytes_extension]: "116"
-[protobuf_unittest.optionalgroup_extension] {
-  a: 117
-}
-[protobuf_unittest.optional_nested_message_extension] {
-  bb: 118
-}
-[protobuf_unittest.optional_foreign_message_extension] {
-  c: 119
-}
-[protobuf_unittest.optional_import_message_extension] {
-  d: 120
-}
-[protobuf_unittest.optional_nested_enum_extension]: BAZ
-[protobuf_unittest.optional_foreign_enum_extension]: FOREIGN_BAZ
-[protobuf_unittest.optional_import_enum_extension]: IMPORT_BAZ
-[protobuf_unittest.optional_string_piece_extension]: "124"
-[protobuf_unittest.optional_cord_extension]: "125"
-[protobuf_unittest.repeated_int32_extension]: 201
-[protobuf_unittest.repeated_int32_extension]: 301
-[protobuf_unittest.repeated_int64_extension]: 202
-[protobuf_unittest.repeated_int64_extension]: 302
-[protobuf_unittest.repeated_uint32_extension]: 203
-[protobuf_unittest.repeated_uint32_extension]: 303
-[protobuf_unittest.repeated_uint64_extension]: 204
-[protobuf_unittest.repeated_uint64_extension]: 304
-[protobuf_unittest.repeated_sint32_extension]: 205
-[protobuf_unittest.repeated_sint32_extension]: 305
-[protobuf_unittest.repeated_sint64_extension]: 206
-[protobuf_unittest.repeated_sint64_extension]: 306
-[protobuf_unittest.repeated_fixed32_extension]: 207
-[protobuf_unittest.repeated_fixed32_extension]: 307
-[protobuf_unittest.repeated_fixed64_extension]: 208
-[protobuf_unittest.repeated_fixed64_extension]: 308
-[protobuf_unittest.repeated_sfixed32_extension]: 209
-[protobuf_unittest.repeated_sfixed32_extension]: 309
-[protobuf_unittest.repeated_sfixed64_extension]: 210
-[protobuf_unittest.repeated_sfixed64_extension]: 310
-[protobuf_unittest.repeated_float_extension]: 211
-[protobuf_unittest.repeated_float_extension]: 311
-[protobuf_unittest.repeated_double_extension]: 212
-[protobuf_unittest.repeated_double_extension]: 312
-[protobuf_unittest.repeated_bool_extension]: true
-[protobuf_unittest.repeated_bool_extension]: false
-[protobuf_unittest.repeated_string_extension]: "215"
-[protobuf_unittest.repeated_string_extension]: "315"
-[protobuf_unittest.repeated_bytes_extension]: "216"
-[protobuf_unittest.repeated_bytes_extension]: "316"
-[protobuf_unittest.repeatedgroup_extension] {
-  a: 217
-}
-[protobuf_unittest.repeatedgroup_extension] {
-  a: 317
-}
-[protobuf_unittest.repeated_nested_message_extension] {
-  bb: 218
-}
-[protobuf_unittest.repeated_nested_message_extension] {
-  bb: 318
-}
-[protobuf_unittest.repeated_foreign_message_extension] {
-  c: 219
-}
-[protobuf_unittest.repeated_foreign_message_extension] {
-  c: 319
-}
-[protobuf_unittest.repeated_import_message_extension] {
-  d: 220
-}
-[protobuf_unittest.repeated_import_message_extension] {
-  d: 320
-}
-[protobuf_unittest.repeated_nested_enum_extension]: BAR
-[protobuf_unittest.repeated_nested_enum_extension]: BAZ
-[protobuf_unittest.repeated_foreign_enum_extension]: FOREIGN_BAR
-[protobuf_unittest.repeated_foreign_enum_extension]: FOREIGN_BAZ
-[protobuf_unittest.repeated_import_enum_extension]: IMPORT_BAR
-[protobuf_unittest.repeated_import_enum_extension]: IMPORT_BAZ
-[protobuf_unittest.repeated_string_piece_extension]: "224"
-[protobuf_unittest.repeated_string_piece_extension]: "324"
-[protobuf_unittest.repeated_cord_extension]: "225"
-[protobuf_unittest.repeated_cord_extension]: "325"
-[protobuf_unittest.default_int32_extension]: 401
-[protobuf_unittest.default_int64_extension]: 402
-[protobuf_unittest.default_uint32_extension]: 403
-[protobuf_unittest.default_uint64_extension]: 404
-[protobuf_unittest.default_sint32_extension]: 405
-[protobuf_unittest.default_sint64_extension]: 406
-[protobuf_unittest.default_fixed32_extension]: 407
-[protobuf_unittest.default_fixed64_extension]: 408
-[protobuf_unittest.default_sfixed32_extension]: 409
-[protobuf_unittest.default_sfixed64_extension]: 410
-[protobuf_unittest.default_float_extension]: 411
-[protobuf_unittest.default_double_extension]: 412
-[protobuf_unittest.default_bool_extension]: false
-[protobuf_unittest.default_string_extension]: "415"
-[protobuf_unittest.default_bytes_extension]: "416"
-[protobuf_unittest.default_nested_enum_extension]: FOO
-[protobuf_unittest.default_foreign_enum_extension]: FOREIGN_FOO
-[protobuf_unittest.default_import_enum_extension]: IMPORT_FOO
-[protobuf_unittest.default_string_piece_extension]: "424"
-[protobuf_unittest.default_cord_extension]: "425"
+[protobuf_unittest.optional_int32_extension]: 101
+[protobuf_unittest.optional_int64_extension]: 102
+[protobuf_unittest.optional_uint32_extension]: 103
+[protobuf_unittest.optional_uint64_extension]: 104
+[protobuf_unittest.optional_sint32_extension]: 105
+[protobuf_unittest.optional_sint64_extension]: 106
+[protobuf_unittest.optional_fixed32_extension]: 107
+[protobuf_unittest.optional_fixed64_extension]: 108
+[protobuf_unittest.optional_sfixed32_extension]: 109
+[protobuf_unittest.optional_sfixed64_extension]: 110
+[protobuf_unittest.optional_float_extension]: 111
+[protobuf_unittest.optional_double_extension]: 112
+[protobuf_unittest.optional_bool_extension]: true
+[protobuf_unittest.optional_string_extension]: "115"
+[protobuf_unittest.optional_bytes_extension]: "116"
+[protobuf_unittest.optionalgroup_extension] {
+  a: 117
+}
+[protobuf_unittest.optional_nested_message_extension] {
+  bb: 118
+}
+[protobuf_unittest.optional_foreign_message_extension] {
+  c: 119
+}
+[protobuf_unittest.optional_import_message_extension] {
+  d: 120
+}
+[protobuf_unittest.optional_nested_enum_extension]: BAZ
+[protobuf_unittest.optional_foreign_enum_extension]: FOREIGN_BAZ
+[protobuf_unittest.optional_import_enum_extension]: IMPORT_BAZ
+[protobuf_unittest.optional_string_piece_extension]: "124"
+[protobuf_unittest.optional_cord_extension]: "125"
+[protobuf_unittest.repeated_int32_extension]: 201
+[protobuf_unittest.repeated_int32_extension]: 301
+[protobuf_unittest.repeated_int64_extension]: 202
+[protobuf_unittest.repeated_int64_extension]: 302
+[protobuf_unittest.repeated_uint32_extension]: 203
+[protobuf_unittest.repeated_uint32_extension]: 303
+[protobuf_unittest.repeated_uint64_extension]: 204
+[protobuf_unittest.repeated_uint64_extension]: 304
+[protobuf_unittest.repeated_sint32_extension]: 205
+[protobuf_unittest.repeated_sint32_extension]: 305
+[protobuf_unittest.repeated_sint64_extension]: 206
+[protobuf_unittest.repeated_sint64_extension]: 306
+[protobuf_unittest.repeated_fixed32_extension]: 207
+[protobuf_unittest.repeated_fixed32_extension]: 307
+[protobuf_unittest.repeated_fixed64_extension]: 208
+[protobuf_unittest.repeated_fixed64_extension]: 308
+[protobuf_unittest.repeated_sfixed32_extension]: 209
+[protobuf_unittest.repeated_sfixed32_extension]: 309
+[protobuf_unittest.repeated_sfixed64_extension]: 210
+[protobuf_unittest.repeated_sfixed64_extension]: 310
+[protobuf_unittest.repeated_float_extension]: 211
+[protobuf_unittest.repeated_float_extension]: 311
+[protobuf_unittest.repeated_double_extension]: 212
+[protobuf_unittest.repeated_double_extension]: 312
+[protobuf_unittest.repeated_bool_extension]: true
+[protobuf_unittest.repeated_bool_extension]: false
+[protobuf_unittest.repeated_string_extension]: "215"
+[protobuf_unittest.repeated_string_extension]: "315"
+[protobuf_unittest.repeated_bytes_extension]: "216"
+[protobuf_unittest.repeated_bytes_extension]: "316"
+[protobuf_unittest.repeatedgroup_extension] {
+  a: 217
+}
+[protobuf_unittest.repeatedgroup_extension] {
+  a: 317
+}
+[protobuf_unittest.repeated_nested_message_extension] {
+  bb: 218
+}
+[protobuf_unittest.repeated_nested_message_extension] {
+  bb: 318
+}
+[protobuf_unittest.repeated_foreign_message_extension] {
+  c: 219
+}
+[protobuf_unittest.repeated_foreign_message_extension] {
+  c: 319
+}
+[protobuf_unittest.repeated_import_message_extension] {
+  d: 220
+}
+[protobuf_unittest.repeated_import_message_extension] {
+  d: 320
+}
+[protobuf_unittest.repeated_nested_enum_extension]: BAR
+[protobuf_unittest.repeated_nested_enum_extension]: BAZ
+[protobuf_unittest.repeated_foreign_enum_extension]: FOREIGN_BAR
+[protobuf_unittest.repeated_foreign_enum_extension]: FOREIGN_BAZ
+[protobuf_unittest.repeated_import_enum_extension]: IMPORT_BAR
+[protobuf_unittest.repeated_import_enum_extension]: IMPORT_BAZ
+[protobuf_unittest.repeated_string_piece_extension]: "224"
+[protobuf_unittest.repeated_string_piece_extension]: "324"
+[protobuf_unittest.repeated_cord_extension]: "225"
+[protobuf_unittest.repeated_cord_extension]: "325"
+[protobuf_unittest.default_int32_extension]: 401
+[protobuf_unittest.default_int64_extension]: 402
+[protobuf_unittest.default_uint32_extension]: 403
+[protobuf_unittest.default_uint64_extension]: 404
+[protobuf_unittest.default_sint32_extension]: 405
+[protobuf_unittest.default_sint64_extension]: 406
+[protobuf_unittest.default_fixed32_extension]: 407
+[protobuf_unittest.default_fixed64_extension]: 408
+[protobuf_unittest.default_sfixed32_extension]: 409
+[protobuf_unittest.default_sfixed64_extension]: 410
+[protobuf_unittest.default_float_extension]: 411
+[protobuf_unittest.default_double_extension]: 412
+[protobuf_unittest.default_bool_extension]: false
+[protobuf_unittest.default_string_extension]: "415"
+[protobuf_unittest.default_bytes_extension]: "416"
+[protobuf_unittest.default_nested_enum_extension]: FOO
+[protobuf_unittest.default_foreign_enum_extension]: FOREIGN_FOO
+[protobuf_unittest.default_import_enum_extension]: IMPORT_FOO
+[protobuf_unittest.default_string_piece_extension]: "424"
+[protobuf_unittest.default_cord_extension]: "425"

todo.txt

@@ -1,16 +1,16 @@
-Current task list (not in order)
-
-- Remove multifile support
-- Docs
-- Clean up protogen code
-- Avoid using reflection for messages which don't need it (is this
-  possible?)
-- Bring service generation into line with Java
-- Build protoc as a dll and use directly from protogen
-- Check copyright is everywhere
-- Work out how to unit test Silverlight code
-- Reformat code
-- Change generated format
-- Add regions to copyright
-- Build and publish binaries
-- Work out why the Compact Framework 3.5 build fails under VS2010
+Current task list (not in order)
+
+- Remove multifile support
+- Docs
+- Clean up protogen code
+- Avoid using reflection for messages which don't need it (is this
+  possible?)
+- Bring service generation into line with Java
+- Build protoc as a dll and use directly from protogen
+- Check copyright is everywhere
+- Work out how to unit test Silverlight code
+- Reformat code
+- Change generated format
+- Add regions to copyright
+- Build and publish binaries
+- Work out why the Compact Framework 3.5 build fails under VS2010