Chiebot-Mirror
/
protobuf
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

line-ending-to-crlf

Browse Source
pull/288/head
csharptest 14 years ago committed by rogerk
parent 62ce3a625e
commit d965c666ec
25 changed files with 6794 additions and 6794 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 142
      src/ProtocolBuffers/RpcUtil.cs
  2. 104
      src/ProtocolBuffers/SilverlightCompatibility.cs
  3. 342
      src/ProtocolBuffers/SortedList.cs
  4. 1366
      src/ProtocolBuffers/TextFormat.cs
  5. 286
      src/ProtocolBuffers/TextGenerator.cs
  6. 824
      src/ProtocolBuffers/TextTokenizer.cs
  7. 146
      src/ProtocolBuffers/ThrowHelper.cs
  8. 340
      src/ProtocolBuffers/UninitializedMessageException.cs
  9. 742
      src/ProtocolBuffers/UnknownField.cs
  10. 1536
      src/ProtocolBuffers/UnknownFieldSet.cs
  11. 342
      src/ProtocolBuffers/WireFormat.cs
  12. 536
      src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
  13. 252
      src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs
  14. 534
      src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs
  15. 608
      src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs
  16. 324
      src/ProtocolBuffersLite.Test/InteropLiteTest.cs
  17. 222
      src/ProtocolBuffersLite.Test/LiteTest.cs
  18. 436
      src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs
  19. 166
      src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj
  20. 176
      src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj
  21. 226
      src/ProtocolBuffersLite.Test/TestLiteByApi.cs
  22. 3442
      src/ProtocolBuffersLite.Test/TestProtos/UnitTestExtrasLiteProtoFile.cs
  23. 232
      testdata/text_format_unittest_data.txt
  24. 232
      testdata/text_format_unittest_extensions_data.txt
  25. 32
      todo.txt

142
src/ProtocolBuffers/RpcUtil.cs
Unescape View File

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

104
src/ProtocolBuffers/SilverlightCompatibility.cs
Unescape View File

@ -1,52 +1,52 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
namespace Google.ProtocolBuffers namespace Google.ProtocolBuffers
{ {
/// <summary> /// <summary>
/// Class containing helpful workarounds for Silverlight compatibility /// Class containing helpful workarounds for Silverlight compatibility
/// </summary> /// </summary>
internal static class SilverlightCompatibility internal static class SilverlightCompatibility
{ {
#if SILVERLIGHT2 #if SILVERLIGHT2
internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.None; internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.None;
#else #else
internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.Compiled; internal const RegexOptions CompiledRegexWhereAvailable = RegexOptions.Compiled;
#endif #endif
} }
} }

342
src/ProtocolBuffers/SortedList.cs
Unescape View File

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

1366
src/ProtocolBuffers/TextFormat.cs
View File

File diff suppressed because it is too large Load Diff

286
src/ProtocolBuffers/TextGenerator.cs
Unescape View File

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

824
src/ProtocolBuffers/TextTokenizer.cs
Unescape View File

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

146
src/ProtocolBuffers/ThrowHelper.cs
Unescape View File

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

340
src/ProtocolBuffers/UninitializedMessageException.cs
Unescape View File

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

742
src/ProtocolBuffers/UnknownField.cs
Unescape View File

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

1536
src/ProtocolBuffers/UnknownFieldSet.cs
View File

File diff suppressed because it is too large Load Diff

342
src/ProtocolBuffers/WireFormat.cs
Unescape View File

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

536
src/ProtocolBuffersLite.Test/AbstractBuilderLiteTest.cs
Unescape View File

@ -1,268 +1,268 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using Google.ProtocolBuffers; using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework; using NUnit.Framework;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
[TestFixture] [TestFixture]
public class AbstractBuilderLiteTest { public class AbstractBuilderLiteTest {
[Test] [Test]
public void TestMergeFromCodedInputStream() { public void TestMergeFromCodedInputStream() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalUint32(uint.MaxValue).Build(); .SetOptionalUint32(uint.MaxValue).Build();
copy = TestAllTypesLite.DefaultInstance; copy = TestAllTypesLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
using (MemoryStream ms = new MemoryStream(msg.ToByteArray())) { using (MemoryStream ms = new MemoryStream(msg.ToByteArray())) {
CodedInputStream ci = CodedInputStream.CreateInstance(ms); CodedInputStream ci = CodedInputStream.CreateInstance(ms);
copy = copy.ToBuilder().MergeFrom(ci).Build(); copy = copy.ToBuilder().MergeFrom(ci).Build();
} }
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestIBuilderLiteWeakClear() { public void TestIBuilderLiteWeakClear() {
TestAllTypesLite copy, msg = TestAllTypesLite.DefaultInstance; TestAllTypesLite copy, msg = TestAllTypesLite.DefaultInstance;
copy = msg.ToBuilder().SetOptionalString("Should be removed.").Build(); copy = msg.ToBuilder().SetOptionalString("Should be removed.").Build();
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakClear().WeakBuild(); copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakClear().WeakBuild();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestBuilderLiteMergeFromCodedInputStream() { public void TestBuilderLiteMergeFromCodedInputStream() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalString("Should be merged.").Build(); .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance; copy = TestAllTypesLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = copy.ToBuilder().MergeFrom(CodedInputStream.CreateInstance(new MemoryStream(msg.ToByteArray()))).Build(); copy = copy.ToBuilder().MergeFrom(CodedInputStream.CreateInstance(new MemoryStream(msg.ToByteArray()))).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestBuilderLiteMergeDelimitedFrom() { public void TestBuilderLiteMergeDelimitedFrom() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalString("Should be merged.").Build(); .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance; copy = TestAllTypesLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream(); Stream s = new MemoryStream();
msg.WriteDelimitedTo(s); msg.WriteDelimitedTo(s);
s.Position = 0; s.Position = 0;
copy = copy.ToBuilder().MergeDelimitedFrom(s).Build(); copy = copy.ToBuilder().MergeDelimitedFrom(s).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestBuilderLiteMergeDelimitedFromExtensions() { public void TestBuilderLiteMergeDelimitedFromExtensions() {
TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build(); .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build();
copy = TestAllExtensionsLite.DefaultInstance; copy = TestAllExtensionsLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream(); Stream s = new MemoryStream();
msg.WriteDelimitedTo(s); msg.WriteDelimitedTo(s);
s.Position = 0; s.Position = 0;
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestLiteProtoFile.RegisterAllExtensions(registry); UnitTestLiteProtoFile.RegisterAllExtensions(registry);
copy = copy.ToBuilder().MergeDelimitedFrom(s, registry).Build(); copy = copy.ToBuilder().MergeDelimitedFrom(s, registry).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite)); Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));
} }
[Test] [Test]
public void TestBuilderLiteMergeFromStream() { public void TestBuilderLiteMergeFromStream() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalString("Should be merged.").Build(); .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance; copy = TestAllTypesLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream(); Stream s = new MemoryStream();
msg.WriteTo(s); msg.WriteTo(s);
s.Position = 0; s.Position = 0;
copy = copy.ToBuilder().MergeFrom(s).Build(); copy = copy.ToBuilder().MergeFrom(s).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestBuilderLiteMergeFromStreamExtensions() { public void TestBuilderLiteMergeFromStreamExtensions() {
TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build(); .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build();
copy = TestAllExtensionsLite.DefaultInstance; copy = TestAllExtensionsLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
Stream s = new MemoryStream(); Stream s = new MemoryStream();
msg.WriteTo(s); msg.WriteTo(s);
s.Position = 0; s.Position = 0;
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestLiteProtoFile.RegisterAllExtensions(registry); UnitTestLiteProtoFile.RegisterAllExtensions(registry);
copy = copy.ToBuilder().MergeFrom(s, registry).Build(); copy = copy.ToBuilder().MergeFrom(s, registry).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite)); Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));
} }
[Test] [Test]
public void TestIBuilderLiteWeakMergeFromIMessageLite() { public void TestIBuilderLiteWeakMergeFromIMessageLite() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalString("Should be merged.").Build(); .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance; copy = TestAllTypesLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom((IMessageLite)msg).WeakBuild(); copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom((IMessageLite)msg).WeakBuild();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestIBuilderLiteWeakMergeFromByteString() { public void TestIBuilderLiteWeakMergeFromByteString() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalString("Should be merged.").Build(); .SetOptionalString("Should be merged.").Build();
copy = TestAllTypesLite.DefaultInstance; copy = TestAllTypesLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(msg.ToByteString()).WeakBuild(); copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(msg.ToByteString()).WeakBuild();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestIBuilderLiteWeakMergeFromByteStringExtensions() { public void TestIBuilderLiteWeakMergeFromByteStringExtensions() {
TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite copy, msg = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build(); .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Should be merged.").Build();
copy = TestAllExtensionsLite.DefaultInstance; copy = TestAllExtensionsLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
copy = (TestAllExtensionsLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), ExtensionRegistry.Empty).WeakBuild(); copy = (TestAllExtensionsLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), ExtensionRegistry.Empty).WeakBuild();
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestLiteProtoFile.RegisterAllExtensions(registry); UnitTestLiteProtoFile.RegisterAllExtensions(registry);
copy = (TestAllExtensionsLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), registry).WeakBuild(); copy = (TestAllExtensionsLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(msg.ToByteString(), registry).WeakBuild();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite)); Assert.AreEqual("Should be merged.", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));
} }
[Test] [Test]
public void TestIBuilderLiteWeakMergeFromCodedInputStream() { public void TestIBuilderLiteWeakMergeFromCodedInputStream() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalUint32(uint.MaxValue).Build(); .SetOptionalUint32(uint.MaxValue).Build();
copy = TestAllTypesLite.DefaultInstance; copy = TestAllTypesLite.DefaultInstance;
Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreNotEqual(msg.ToByteArray(), copy.ToByteArray());
using (MemoryStream ms = new MemoryStream(msg.ToByteArray())) { using (MemoryStream ms = new MemoryStream(msg.ToByteArray())) {
CodedInputStream ci = CodedInputStream.CreateInstance(ms); CodedInputStream ci = CodedInputStream.CreateInstance(ms);
copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(ci).WeakBuild(); copy = (TestAllTypesLite)((IBuilderLite)copy.ToBuilder()).WeakMergeFrom(ci).WeakBuild();
} }
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestIBuilderLiteWeakBuildPartial() { public void TestIBuilderLiteWeakBuildPartial() {
IBuilderLite builder = TestRequiredLite.CreateBuilder(); IBuilderLite builder = TestRequiredLite.CreateBuilder();
Assert.IsFalse(builder.IsInitialized); Assert.IsFalse(builder.IsInitialized);
IMessageLite msg = builder.WeakBuildPartial(); IMessageLite msg = builder.WeakBuildPartial();
Assert.IsFalse(msg.IsInitialized); Assert.IsFalse(msg.IsInitialized);
Assert.AreEqual(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), TestRequiredLite.DefaultInstance.ToByteArray());
} }
[Test, ExpectedException(typeof(UninitializedMessageException ))] [Test, ExpectedException(typeof(UninitializedMessageException ))]
public void TestIBuilderLiteWeakBuildUninitialized() { public void TestIBuilderLiteWeakBuildUninitialized() {
IBuilderLite builder = TestRequiredLite.CreateBuilder(); IBuilderLite builder = TestRequiredLite.CreateBuilder();
Assert.IsFalse(builder.IsInitialized); Assert.IsFalse(builder.IsInitialized);
builder.WeakBuild(); builder.WeakBuild();
} }
[Test] [Test]
public void TestIBuilderLiteWeakBuild() { public void TestIBuilderLiteWeakBuild() {
IBuilderLite builder = TestRequiredLite.CreateBuilder() IBuilderLite builder = TestRequiredLite.CreateBuilder()
.SetD(0) .SetD(0)
.SetEn(ExtraEnum.EXLITE_BAZ); .SetEn(ExtraEnum.EXLITE_BAZ);
Assert.IsTrue(builder.IsInitialized); Assert.IsTrue(builder.IsInitialized);
builder.WeakBuild(); builder.WeakBuild();
} }
[Test] [Test]
public void TestIBuilderLiteWeakClone() { public void TestIBuilderLiteWeakClone() {
TestRequiredLite msg = TestRequiredLite.CreateBuilder() TestRequiredLite msg = TestRequiredLite.CreateBuilder()
.SetD(1).SetEn(ExtraEnum.EXLITE_BAR).Build(); .SetD(1).SetEn(ExtraEnum.EXLITE_BAR).Build();
Assert.IsTrue(msg.IsInitialized); Assert.IsTrue(msg.IsInitialized);
IMessageLite copy = ((IBuilderLite)msg.ToBuilder()).WeakClone().WeakBuild(); IMessageLite copy = ((IBuilderLite)msg.ToBuilder()).WeakClone().WeakBuild();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestIBuilderLiteWeakDefaultInstance() { public void TestIBuilderLiteWeakDefaultInstance() {
Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance, Assert.IsTrue(ReferenceEquals(TestRequiredLite.DefaultInstance,
((IBuilderLite)TestRequiredLite.CreateBuilder()).WeakDefaultInstanceForType)); ((IBuilderLite)TestRequiredLite.CreateBuilder()).WeakDefaultInstanceForType));
} }
[Test] [Test]
public void TestGeneratedBuilderLiteAddRange() { public void TestGeneratedBuilderLiteAddRange() {
TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite copy, msg = TestAllTypesLite.CreateBuilder()
.SetOptionalUint32(123) .SetOptionalUint32(123)
.AddRepeatedInt32(1) .AddRepeatedInt32(1)
.AddRepeatedInt32(2) .AddRepeatedInt32(2)
.AddRepeatedInt32(3) .AddRepeatedInt32(3)
.Build(); .Build();
copy = msg.DefaultInstanceForType.ToBuilder().MergeFrom(msg).Build(); copy = msg.DefaultInstanceForType.ToBuilder().MergeFrom(msg).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
} }
} }

252
src/ProtocolBuffersLite.Test/AbstractMessageLiteTest.cs
Unescape View File

@ -1,126 +1,126 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using Google.ProtocolBuffers; using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework; using NUnit.Framework;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
[TestFixture] [TestFixture]
public class AbstractMessageLiteTest { public class AbstractMessageLiteTest {
[Test] [Test]
public void TestMessageLiteToByteString() { public void TestMessageLiteToByteString() {
TestRequiredLite msg = TestRequiredLite.CreateBuilder() TestRequiredLite msg = TestRequiredLite.CreateBuilder()
.SetD(42) .SetD(42)
.SetEn(ExtraEnum.EXLITE_BAZ) .SetEn(ExtraEnum.EXLITE_BAZ)
.Build(); .Build();
ByteString b = msg.ToByteString(); ByteString b = msg.ToByteString();
Assert.AreEqual(4, b.Length); Assert.AreEqual(4, b.Length);
Assert.AreEqual(TestRequiredLite.DFieldNumber << 3, b[0]); Assert.AreEqual(TestRequiredLite.DFieldNumber << 3, b[0]);
Assert.AreEqual(42, b[1]); Assert.AreEqual(42, b[1]);
Assert.AreEqual(TestRequiredLite.EnFieldNumber << 3, b[2]); Assert.AreEqual(TestRequiredLite.EnFieldNumber << 3, b[2]);
Assert.AreEqual((int)ExtraEnum.EXLITE_BAZ, b[3]); Assert.AreEqual((int)ExtraEnum.EXLITE_BAZ, b[3]);
} }
[Test] [Test]
public void TestMessageLiteToByteArray() { public void TestMessageLiteToByteArray() {
TestRequiredLite msg = TestRequiredLite.CreateBuilder() TestRequiredLite msg = TestRequiredLite.CreateBuilder()
.SetD(42) .SetD(42)
.SetEn(ExtraEnum.EXLITE_BAZ) .SetEn(ExtraEnum.EXLITE_BAZ)
.Build(); .Build();
ByteString b = msg.ToByteString(); ByteString b = msg.ToByteString();
ByteString copy = ByteString.CopyFrom(msg.ToByteArray()); ByteString copy = ByteString.CopyFrom(msg.ToByteArray());
Assert.AreEqual(b, copy); Assert.AreEqual(b, copy);
} }
[Test] [Test]
public void TestMessageLiteWriteTo() { public void TestMessageLiteWriteTo() {
TestRequiredLite msg = TestRequiredLite.CreateBuilder() TestRequiredLite msg = TestRequiredLite.CreateBuilder()
.SetD(42) .SetD(42)
.SetEn(ExtraEnum.EXLITE_BAZ) .SetEn(ExtraEnum.EXLITE_BAZ)
.Build(); .Build();
MemoryStream ms = new MemoryStream(); MemoryStream ms = new MemoryStream();
msg.WriteTo(ms); msg.WriteTo(ms);
Assert.AreEqual(msg.ToByteArray(), ms.ToArray()); Assert.AreEqual(msg.ToByteArray(), ms.ToArray());
} }
[Test] [Test]
public void TestMessageLiteWriteDelimitedTo() { public void TestMessageLiteWriteDelimitedTo() {
TestRequiredLite msg = TestRequiredLite.CreateBuilder() TestRequiredLite msg = TestRequiredLite.CreateBuilder()
.SetD(42) .SetD(42)
.SetEn(ExtraEnum.EXLITE_BAZ) .SetEn(ExtraEnum.EXLITE_BAZ)
.Build(); .Build();
MemoryStream ms = new MemoryStream(); MemoryStream ms = new MemoryStream();
msg.WriteDelimitedTo(ms); msg.WriteDelimitedTo(ms);
byte[] buffer = ms.ToArray(); byte[] buffer = ms.ToArray();
Assert.AreEqual(5, buffer.Length); Assert.AreEqual(5, buffer.Length);
Assert.AreEqual(4, buffer[0]); Assert.AreEqual(4, buffer[0]);
byte[] msgBytes = new byte[4]; byte[] msgBytes = new byte[4];
Array.Copy(buffer, 1, msgBytes, 0, 4); Array.Copy(buffer, 1, msgBytes, 0, 4);
Assert.AreEqual(msg.ToByteArray(), msgBytes); Assert.AreEqual(msg.ToByteArray(), msgBytes);
} }
[Test] [Test]
public void TestIMessageLiteWeakCreateBuilderForType() { public void TestIMessageLiteWeakCreateBuilderForType() {
IMessageLite msg = TestRequiredLite.DefaultInstance; IMessageLite msg = TestRequiredLite.DefaultInstance;
Assert.AreEqual(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType()); Assert.AreEqual(typeof(TestRequiredLite.Builder), msg.WeakCreateBuilderForType().GetType());
} }
[Test] [Test]
public void TestMessageLiteWeakToBuilder() { public void TestMessageLiteWeakToBuilder() {
IMessageLite msg = TestRequiredLite.CreateBuilder() IMessageLite msg = TestRequiredLite.CreateBuilder()
.SetD(42) .SetD(42)
.SetEn(ExtraEnum.EXLITE_BAZ) .SetEn(ExtraEnum.EXLITE_BAZ)
.Build(); .Build();
IMessageLite copy = msg.WeakToBuilder().WeakBuild(); IMessageLite copy = msg.WeakToBuilder().WeakBuild();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestMessageLiteWeakDefaultInstanceForType() { public void TestMessageLiteWeakDefaultInstanceForType() {
IMessageLite msg = TestRequiredLite.DefaultInstance; IMessageLite msg = TestRequiredLite.DefaultInstance;
Assert.IsTrue(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType)); Assert.IsTrue(Object.ReferenceEquals(TestRequiredLite.DefaultInstance, msg.WeakDefaultInstanceForType));
} }
} }
} }

534
src/ProtocolBuffersLite.Test/ExtendableBuilderLiteTest.cs
Unescape View File

@ -1,267 +1,267 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using Google.ProtocolBuffers; using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework; using NUnit.Framework;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
[TestFixture] [TestFixture]
public class ExtendableBuilderLiteTest { public class ExtendableBuilderLiteTest {
[Test] [Test]
public void TestHasExtensionT() { public void TestHasExtensionT() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123); .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123);
Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
} }
[Test] [Test]
public void TestHasExtensionTMissing() { public void TestHasExtensionTMissing() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
} }
[Test] [Test]
public void TestGetExtensionCountT() { public void TestGetExtensionCountT() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3);
Assert.AreEqual(3, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(3, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
} }
[Test] [Test]
public void TestGetExtensionCountTEmpty() { public void TestGetExtensionCountTEmpty() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
} }
[Test] [Test]
public void TestGetExtensionTNull() { public void TestGetExtensionTNull() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
string value = builder.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite); string value = builder.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite);
Assert.IsNull(value); Assert.IsNull(value);
} }
[Test] [Test]
public void TestGetExtensionTValue() { public void TestGetExtensionTValue() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 3); .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 3);
Assert.AreEqual(3, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.AreEqual(3, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
} }
[Test] [Test]
public void TestGetExtensionTEmpty() { public void TestGetExtensionTEmpty() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
Assert.AreEqual(0, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite).Count); Assert.AreEqual(0, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite).Count);
} }
[Test] [Test]
public void TestGetExtensionTList() { public void TestGetExtensionTList() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 3);
IList<int> values = builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite); IList<int> values = builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite);
Assert.AreEqual(3, values.Count); Assert.AreEqual(3, values.Count);
} }
[Test] [Test]
public void TestGetExtensionTIndex() { public void TestGetExtensionTIndex() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2);
for(int i = 0; i < 3; i++ ) for(int i = 0; i < 3; i++ )
Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i)); Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));
} }
[Test,ExpectedException(typeof(ArgumentOutOfRangeException))] [Test,ExpectedException(typeof(ArgumentOutOfRangeException))]
public void TestGetExtensionTIndexOutOfRange() { public void TestGetExtensionTIndexOutOfRange() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0); builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);
} }
[Test] [Test]
public void TestSetExtensionTIndex() { public void TestSetExtensionTIndex() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i)); Assert.AreEqual(i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));
builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, 5); builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, 5);
builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1, 6); builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1, 6);
builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2, 7); builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 2, 7);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
Assert.AreEqual(5 + i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i)); Assert.AreEqual(5 + i, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, i));
} }
[Test, ExpectedException(typeof(ArgumentOutOfRangeException))] [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
public void TestSetExtensionTIndexOutOfRange() { public void TestSetExtensionTIndexOutOfRange() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, -1); builder.SetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0, -1);
} }
[Test] [Test]
public void TestClearExtensionTList() { public void TestClearExtensionTList() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);
Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
builder.ClearExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite); builder.ClearExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite);
Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
} }
[Test] [Test]
public void TestClearExtensionTValue() { public void TestClearExtensionTValue() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 0); .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 0);
Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
builder.ClearExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite); builder.ClearExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite);
Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
} }
[Test] [Test]
public void TestIndexedByDescriptor() { public void TestIndexedByDescriptor() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsFalse(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
builder[UnitTestLiteProtoFile.OptionalInt32ExtensionLite.Descriptor] = 123; builder[UnitTestLiteProtoFile.OptionalInt32ExtensionLite.Descriptor] = 123;
Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsTrue(builder.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
} }
[Test] [Test]
public void TestIndexedByDescriptorAndOrdinal() { public void TestIndexedByDescriptorAndOrdinal() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);
Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor; IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;
builder[f, 0] = 123; builder[f, 0] = 123;
Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)); Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0));
} }
[Test, ExpectedException(typeof(ArgumentOutOfRangeException))] [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
public void TestIndexedByDescriptorAndOrdinalOutOfRange() { public void TestIndexedByDescriptorAndOrdinalOutOfRange() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor; IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;
builder[f, 0] = 123; builder[f, 0] = 123;
} }
[Test] [Test]
public void TestClearFieldByDescriptor() { public void TestClearFieldByDescriptor() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);
Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor; IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;
builder.ClearField(f); builder.ClearField(f);
Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
} }
[Test] [Test]
public void TestAddRepeatedFieldByDescriptor() { public void TestAddRepeatedFieldByDescriptor() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0); .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);
Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor; IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;
builder.AddRepeatedField(f, 123); builder.AddRepeatedField(f, 123);
Assert.AreEqual(2, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); Assert.AreEqual(2, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1)); Assert.AreEqual(123, builder.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 1));
} }
[Test] [Test]
public void TestMissingExtensionsLite() public void TestMissingExtensionsLite()
{ {
const int optionalInt32 = 12345678; const int optionalInt32 = 12345678;
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
builder.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, optionalInt32); builder.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, optionalInt32);
builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.1); builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.1);
builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.2); builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.2);
builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.3); builder.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 1.3);
TestAllExtensionsLite msg = builder.Build(); TestAllExtensionsLite msg = builder.Build();
Assert.IsTrue(msg.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsTrue(msg.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
Assert.AreEqual(3, msg.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite)); Assert.AreEqual(3, msg.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite));
byte[] bits = msg.ToByteArray(); byte[] bits = msg.ToByteArray();
TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits); TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);
Assert.IsFalse(copy.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.IsFalse(copy.HasExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
Assert.AreEqual(0, copy.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite)); Assert.AreEqual(0, copy.GetExtensionCount(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite));
Assert.AreNotEqual(msg, copy); Assert.AreNotEqual(msg, copy);
//The lite runtime removes all unknown fields and extensions //The lite runtime removes all unknown fields and extensions
byte[] copybits = copy.ToByteArray(); byte[] copybits = copy.ToByteArray();
Assert.AreEqual(0, copybits.Length); Assert.AreEqual(0, copybits.Length);
} }
[Test] [Test]
public void TestMissingFieldsLite() public void TestMissingFieldsLite()
{ {
TestAllTypesLite msg = TestAllTypesLite.CreateBuilder() TestAllTypesLite msg = TestAllTypesLite.CreateBuilder()
.SetOptionalInt32(123) .SetOptionalInt32(123)
.SetOptionalString("123") .SetOptionalString("123")
.Build(); .Build();
byte[] bits = msg.ToByteArray(); byte[] bits = msg.ToByteArray();
TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits); TestAllExtensionsLite copy = TestAllExtensionsLite.ParseFrom(bits);
Assert.AreNotEqual(msg, copy); Assert.AreNotEqual(msg, copy);
//The lite runtime removes all unknown fields and extensions //The lite runtime removes all unknown fields and extensions
byte[] copybits = copy.ToByteArray(); byte[] copybits = copy.ToByteArray();
Assert.AreEqual(0, copybits.Length); Assert.AreEqual(0, copybits.Length);
} }
} }
} }

608
src/ProtocolBuffersLite.Test/ExtendableMessageLiteTest.cs
Unescape View File

@ -1,304 +1,304 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
using Google.ProtocolBuffers; using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework; using NUnit.Framework;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
[TestFixture] [TestFixture]
public class ExtendableMessageLiteTest { public class ExtendableMessageLiteTest {
[Test, Ignore("Not implemented, no assertion made"), ExpectedException(typeof(ArgumentException))] [Test, Ignore("Not implemented, no assertion made"), ExpectedException(typeof(ArgumentException))]
public void ExtensionWriterInvalidExtension() { public void ExtensionWriterInvalidExtension() {
TestPackedExtensionsLite.CreateBuilder()[UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite.Descriptor] = TestPackedExtensionsLite.CreateBuilder()[UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite.Descriptor] =
ForeignMessageLite.DefaultInstance; ForeignMessageLite.DefaultInstance;
} }
[Test] [Test]
public void ExtensionWriterTestMessages() { public void ExtensionWriterTestMessages() {
TestAllExtensionsLite.Builder b = TestAllExtensionsLite.CreateBuilder().SetExtension( TestAllExtensionsLite.Builder b = TestAllExtensionsLite.CreateBuilder().SetExtension(
UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.CreateBuilder().SetC(123).Build()); UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.CreateBuilder().SetC(123).Build());
TestAllExtensionsLite copy, msg = b.Build(); TestAllExtensionsLite copy, msg = b.Build();
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestLiteProtoFile.RegisterAllExtensions(registry); UnitTestLiteProtoFile.RegisterAllExtensions(registry);
copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry); copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void ExtensionWriterIsInitialized() { public void ExtensionWriterIsInitialized() {
Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized); Assert.IsTrue(ForeignMessageLite.DefaultInstance.IsInitialized);
Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized); Assert.IsTrue(TestPackedExtensionsLite.CreateBuilder().IsInitialized);
Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension( Assert.IsTrue(TestAllExtensionsLite.CreateBuilder().SetExtension(
UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance) UnitTestLiteProtoFile.OptionalForeignMessageExtensionLite, ForeignMessageLite.DefaultInstance)
.IsInitialized); .IsInitialized);
} }
[Test] [Test]
public void ExtensionWriterTestSetExtensionLists() { public void ExtensionWriterTestSetExtensionLists() {
TestAllExtensionsLite msg, copy; TestAllExtensionsLite msg, copy;
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, new[] { true, false }) .SetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, new[] { true, false })
.SetExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, new[] { "123", "456" }) .SetExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, new[] { "123", "456" })
.SetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, new[] { ForeignEnumLite.FOREIGN_LITE_BAZ, ForeignEnumLite.FOREIGN_LITE_FOO }) .SetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, new[] { ForeignEnumLite.FOREIGN_LITE_BAZ, ForeignEnumLite.FOREIGN_LITE_FOO })
; ;
msg = builder.Build(); msg = builder.Build();
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestLiteProtoFile.RegisterAllExtensions(registry); UnitTestLiteProtoFile.RegisterAllExtensions(registry);
copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry); copy = TestAllExtensionsLite.ParseFrom(msg.ToByteArray(), registry);
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO, copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 1)); Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_FOO, copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 1));
} }
[Test] [Test]
public void ExtensionWriterTest() { public void ExtensionWriterTest() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite, true) .SetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite, true)
.SetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite, ByteString.CopyFromUtf8("123")) .SetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite, ByteString.CopyFromUtf8("123"))
.SetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite, "123") .SetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite, "123")
.SetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite, 123u)
.SetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite, 123u)
.SetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ) .SetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)
.SetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ) .SetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)
.SetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO) .SetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO)
.SetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite, "123") .SetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite, "123")
.SetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite, "123") .SetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite, "123")
.SetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite, 123u)
.SetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite, 123u)
//Optional //Optional
.SetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite, true) .SetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite, true)
.SetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite, ByteString.CopyFromUtf8("123")) .SetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite, ByteString.CopyFromUtf8("123"))
.SetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite, "123") .SetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite, "123")
.SetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite, 123u)
.SetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite, 123u)
.SetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ) .SetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)
.SetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ) .SetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)
.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO) .SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO)
.SetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite, 123)
.SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "123") .SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "123")
.SetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite, "123") .SetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite, "123")
.SetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite, 123u)
.SetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite, 123u) .SetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite, 123u)
//Repeated //Repeated
.AddExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, true) .AddExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, true)
.AddExtension(UnitTestLiteProtoFile.RepeatedBytesExtensionLite, ByteString.CopyFromUtf8("123")) .AddExtension(UnitTestLiteProtoFile.RepeatedBytesExtensionLite, ByteString.CopyFromUtf8("123"))
.AddExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, "123") .AddExtension(UnitTestLiteProtoFile.RepeatedCordExtensionLite, "123")
.AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ) .AddExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ)
.AddExtension(UnitTestLiteProtoFile.RepeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ) .AddExtension(UnitTestLiteProtoFile.RepeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO) .AddExtension(UnitTestLiteProtoFile.RepeatedNestedEnumExtensionLite, TestAllTypesLite.Types.NestedEnum.FOO)
.AddExtension(UnitTestLiteProtoFile.RepeatedSfixed32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedSfixed32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "123") .AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "123")
.AddExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, "123") .AddExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, "123")
.AddExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 123u)
; ;
TestAllExtensionsLite msg = builder.Build(); TestAllExtensionsLite msg = builder.Build();
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestLiteProtoFile.RegisterAllExtensions(registry); UnitTestLiteProtoFile.RegisterAllExtensions(registry);
TestAllExtensionsLite.Builder copyBuilder = TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry); TestAllExtensionsLite.Builder copyBuilder = TestAllExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
TestAllExtensionsLite copy = copyBuilder.Build(); TestAllExtensionsLite copy = copyBuilder.Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite)); Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.DefaultBoolExtensionLite));
Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite)); Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.DefaultBytesExtensionLite));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultCordExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultDoubleExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed32ExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultFixed64ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultFloatExtensionLite));
Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite)); Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.DefaultForeignEnumExtensionLite));
Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite)); Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.DefaultImportEnumExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt32ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultInt64ExtensionLite));
Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite)); Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.DefaultNestedEnumExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed32ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSfixed64ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint32ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.DefaultSint64ExtensionLite));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringExtensionLite));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.DefaultStringPieceExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint32ExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.DefaultUint64ExtensionLite));
Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite)); Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.OptionalBoolExtensionLite));
Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite)); Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.OptionalBytesExtensionLite));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalCordExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalDoubleExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed32ExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalFixed64ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalFloatExtensionLite));
Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite)); Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.OptionalForeignEnumExtensionLite));
Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite)); Assert.AreEqual(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.OptionalImportEnumExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalInt64ExtensionLite));
Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite)); Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed32ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSfixed64ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint32ExtensionLite));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.OptionalSint64ExtensionLite));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.OptionalStringPieceExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint32ExtensionLite));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.OptionalUint64ExtensionLite));
Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, 0)); Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.RepeatedBoolExtensionLite, 0));
Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestLiteProtoFile.RepeatedBytesExtensionLite, 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.RepeatedCordExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedDoubleExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed32ExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFixed64ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedFloatExtensionLite, 0));
Assert.AreEqual(ForeignEnumLite.FOREIGN_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.RepeatedForeignEnumExtensionLite, 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(ImportEnumLite.IMPORT_LITE_BAZ, copy.GetExtension(UnitTestLiteProtoFile.RepeatedImportEnumExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedInt64ExtensionLite, 0));
Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.FOO, copy.GetExtension(UnitTestLiteProtoFile.RepeatedNestedEnumExtensionLite, 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.RepeatedSfixed32ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSfixed64ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint32ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.RepeatedSint64ExtensionLite, 0));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0));
Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, 0)); Assert.AreEqual("123", copy.GetExtension(UnitTestLiteProtoFile.RepeatedStringPieceExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint32ExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.RepeatedUint64ExtensionLite, 0));
} }
[Test] [Test]
public void ExtensionWriterTestPacked() { public void ExtensionWriterTestPacked() {
TestPackedExtensionsLite.Builder builder = TestPackedExtensionsLite.CreateBuilder() TestPackedExtensionsLite.Builder builder = TestPackedExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true) .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true)
.AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true) .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true)
.AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u)
.AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u); .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u);
TestPackedExtensionsLite msg = builder.Build(); TestPackedExtensionsLite msg = builder.Build();
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestLiteProtoFile.RegisterAllExtensions(registry); UnitTestLiteProtoFile.RegisterAllExtensions(registry);
TestPackedExtensionsLite.Builder copyBuilder = TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry); TestPackedExtensionsLite.Builder copyBuilder = TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry);
TestPackedExtensionsLite copy = copyBuilder.Build(); TestPackedExtensionsLite copy = copyBuilder.Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 0)); Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 0));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 0));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 0));
Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 1)); Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 1));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 1));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 1));
Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 1));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 1));
Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 1));
} }
} }
} }

324
src/ProtocolBuffersLite.Test/InteropLiteTest.cs
Unescape View File

@ -1,162 +1,162 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Google.ProtocolBuffers; using Google.ProtocolBuffers;
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework; using NUnit.Framework;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
[TestFixture] [TestFixture]
public class InteropLiteTest { public class InteropLiteTest {
[Test] [Test]
public void TestConvertFromFullMinimal() { public void TestConvertFromFullMinimal() {
TestInteropPerson person = TestInteropPerson.CreateBuilder() TestInteropPerson person = TestInteropPerson.CreateBuilder()
.SetId(123) .SetId(123)
.SetName("abc") .SetName("abc")
.Build(); .Build();
Assert.IsTrue(person.IsInitialized); Assert.IsTrue(person.IsInitialized);
TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray()); TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray());
Assert.AreEqual(person.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestConvertFromFullComplete() { public void TestConvertFromFullComplete() {
TestInteropPerson person = TestInteropPerson.CreateBuilder() TestInteropPerson person = TestInteropPerson.CreateBuilder()
.SetId(123) .SetId(123)
.SetName("abc") .SetName("abc")
.SetEmail("abc@123.com") .SetEmail("abc@123.com")
.AddRangeCodes(new[] { 1, 2, 3 }) .AddRangeCodes(new[] { 1, 2, 3 })
.AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build()) .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())
.AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").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()) .AddAddresses(TestInteropPerson.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())
.SetExtension(UnitTestExtrasFullProtoFile.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build()) .SetExtension(UnitTestExtrasFullProtoFile.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())
.Build(); .Build();
Assert.IsTrue(person.IsInitialized); Assert.IsTrue(person.IsInitialized);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestExtrasLiteProtoFile.RegisterAllExtensions(registry); UnitTestExtrasLiteProtoFile.RegisterAllExtensions(registry);
TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray(), registry); TestInteropPersonLite copy = TestInteropPersonLite.ParseFrom(person.ToByteArray(), registry);
Assert.AreEqual(person.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestConvertFromLiteMinimal() { public void TestConvertFromLiteMinimal() {
TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder() TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()
.SetId(123) .SetId(123)
.SetName("abc") .SetName("abc")
.Build(); .Build();
Assert.IsTrue(person.IsInitialized); Assert.IsTrue(person.IsInitialized);
TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray()); TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray());
Assert.AreEqual(person.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestConvertFromLiteComplete() { public void TestConvertFromLiteComplete() {
TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder() TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()
.SetId(123) .SetId(123)
.SetName("abc") .SetName("abc")
.SetEmail("abc@123.com") .SetEmail("abc@123.com")
.AddRangeCodes(new[] { 1, 2, 3 }) .AddRangeCodes(new[] { 1, 2, 3 })
.AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build()) .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())
.AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").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()) .AddAddresses(TestInteropPersonLite.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())
.SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build()) .SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())
.Build(); .Build();
Assert.IsTrue(person.IsInitialized); Assert.IsTrue(person.IsInitialized);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry); UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);
TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry); TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);
Assert.AreEqual(person.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
} }
public ByteString AllBytes { public ByteString AllBytes {
get { get {
byte[] bytes = new byte[256]; byte[] bytes = new byte[256];
for (int i = 0; i < bytes.Length; i++) for (int i = 0; i < bytes.Length; i++)
bytes[i] = (byte)i; bytes[i] = (byte)i;
return ByteString.CopyFrom(bytes); return ByteString.CopyFrom(bytes);
} }
} }
[Test] [Test]
public void TestCompareStringValues() { public void TestCompareStringValues() {
TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder() TestInteropPersonLite person = TestInteropPersonLite.CreateBuilder()
.SetId(123) .SetId(123)
.SetName("abc") .SetName("abc")
.SetEmail("abc@123.com") .SetEmail("abc@123.com")
.AddRangeCodes(new[] { 1, 2, 3 }) .AddRangeCodes(new[] { 1, 2, 3 })
.AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build()) .AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())
.AddPhone(TestInteropPersonLite.Types.PhoneNumber.CreateBuilder().SetNumber(System.Text.Encoding.ASCII.GetString(AllBytes.ToByteArray())).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()) .AddAddresses(TestInteropPersonLite.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())
.SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build()) .SetExtension(UnitTestExtrasLiteProtoFile.EmployeeIdLite, TestInteropEmployeeIdLite.CreateBuilder().SetNumber("123").Build())
.Build(); .Build();
Assert.IsTrue(person.IsInitialized); Assert.IsTrue(person.IsInitialized);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry); UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);
TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry); TestInteropPerson copy = TestInteropPerson.ParseFrom(person.ToByteArray(), registry);
Assert.AreEqual(person.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
TestInteropPerson.Builder copyBuilder = TestInteropPerson.CreateBuilder(); TestInteropPerson.Builder copyBuilder = TestInteropPerson.CreateBuilder();
TextFormat.Merge(person.ToString().Replace("[protobuf_unittest_extra.employee_id_lite]", "[protobuf_unittest_extra.employee_id]"), registry, copyBuilder); TextFormat.Merge(person.ToString().Replace("[protobuf_unittest_extra.employee_id_lite]", "[protobuf_unittest_extra.employee_id]"), registry, copyBuilder);
copy = copyBuilder.Build(); copy = copyBuilder.Build();
Assert.AreEqual(person.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
string liteText = person.ToString().TrimEnd().Replace("\r", ""); string liteText = person.ToString().TrimEnd().Replace("\r", "");
string fullText = copy.ToString().TrimEnd().Replace("\r", ""); string fullText = copy.ToString().TrimEnd().Replace("\r", "");
//map the extension type //map the extension type
liteText = liteText.Replace("[protobuf_unittest_extra.employee_id_lite]", "[protobuf_unittest_extra.employee_id]"); liteText = liteText.Replace("[protobuf_unittest_extra.employee_id_lite]", "[protobuf_unittest_extra.employee_id]");
//lite version does not indent //lite version does not indent
while (fullText.IndexOf("\n ") >= 0) while (fullText.IndexOf("\n ") >= 0)
fullText = fullText.Replace("\n ", "\n"); fullText = fullText.Replace("\n ", "\n");
Assert.AreEqual(fullText, liteText); Assert.AreEqual(fullText, liteText);
} }
} }
} }

222
src/ProtocolBuffersLite.Test/LiteTest.cs
Unescape View File

@ -1,112 +1,112 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework; using NUnit.Framework;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
/// <summary> /// <summary>
/// Miscellaneous tests for message operations that apply to both /// Miscellaneous tests for message operations that apply to both
/// generated and dynamic messages. /// generated and dynamic messages.
/// </summary> /// </summary>
[TestFixture] [TestFixture]
public class LiteTest { public class LiteTest {
[Test] [Test]
public void TestLite() { public void TestLite() {
// Since lite messages are a subset of regular messages, we can mostly // Since lite messages are a subset of regular messages, we can mostly
// assume that the functionality of lite messages is already thoroughly // assume that the functionality of lite messages is already thoroughly
// tested by the regular tests. All this test really verifies is that // tested by the regular tests. All this test really verifies is that
// a proto with optimize_for = LITE_RUNTIME compiles correctly when // a proto with optimize_for = LITE_RUNTIME compiles correctly when
// linked only against the lite library. That is all tested at compile // 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 // 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. // stuff to make sure the lite message is actually here and usable.
TestAllTypesLite message = TestAllTypesLite message =
TestAllTypesLite.CreateBuilder() TestAllTypesLite.CreateBuilder()
.SetOptionalInt32(123) .SetOptionalInt32(123)
.AddRepeatedString("hello") .AddRepeatedString("hello")
.SetOptionalNestedMessage( .SetOptionalNestedMessage(
TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7)) TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7))
.Build(); .Build();
ByteString data = message.ToByteString(); ByteString data = message.ToByteString();
TestAllTypesLite message2 = TestAllTypesLite.ParseFrom(data); TestAllTypesLite message2 = TestAllTypesLite.ParseFrom(data);
Assert.AreEqual(123, message2.OptionalInt32); Assert.AreEqual(123, message2.OptionalInt32);
Assert.AreEqual(1, message2.RepeatedStringCount); Assert.AreEqual(1, message2.RepeatedStringCount);
Assert.AreEqual("hello", message2.RepeatedStringList[0]); Assert.AreEqual("hello", message2.RepeatedStringList[0]);
Assert.AreEqual(7, message2.OptionalNestedMessage.Bb); Assert.AreEqual(7, message2.OptionalNestedMessage.Bb);
} }
[Test] [Test]
public void TestLiteExtensions() { public void TestLiteExtensions() {
// TODO(kenton): Unlike other features of the lite library, extensions are // TODO(kenton): Unlike other features of the lite library, extensions are
// implemented completely differently from the regular library. We // implemented completely differently from the regular library. We
// should probably test them more thoroughly. // should probably test them more thoroughly.
TestAllExtensionsLite message = TestAllExtensionsLite message =
TestAllExtensionsLite.CreateBuilder() TestAllExtensionsLite.CreateBuilder()
.SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123) .SetExtension(UnitTestLiteProtoFile.OptionalInt32ExtensionLite, 123)
.AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "hello") .AddExtension(UnitTestLiteProtoFile.RepeatedStringExtensionLite, "hello")
.SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite, .SetExtension(UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite,
TestAllTypesLite.Types.NestedEnum.BAZ) TestAllTypesLite.Types.NestedEnum.BAZ)
.SetExtension(UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite, .SetExtension(UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite,
TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7).Build()) TestAllTypesLite.Types.NestedMessage.CreateBuilder().SetBb(7).Build())
.Build(); .Build();
// Test copying a message, since coping extensions actually does use a // Test copying a message, since coping extensions actually does use a
// different code path between lite and regular libraries, and as of this // different code path between lite and regular libraries, and as of this
// writing, parsing hasn't been implemented yet. // writing, parsing hasn't been implemented yet.
TestAllExtensionsLite message2 = message.ToBuilder().Build(); TestAllExtensionsLite message2 = message.ToBuilder().Build();
Assert.AreEqual(123, (int)message2.GetExtension( Assert.AreEqual(123, (int)message2.GetExtension(
UnitTestLiteProtoFile.OptionalInt32ExtensionLite)); UnitTestLiteProtoFile.OptionalInt32ExtensionLite));
Assert.AreEqual(1, message2.GetExtensionCount( Assert.AreEqual(1, message2.GetExtensionCount(
UnitTestLiteProtoFile.RepeatedStringExtensionLite)); UnitTestLiteProtoFile.RepeatedStringExtensionLite));
Assert.AreEqual(1, message2.GetExtension( Assert.AreEqual(1, message2.GetExtension(
UnitTestLiteProtoFile.RepeatedStringExtensionLite).Count); UnitTestLiteProtoFile.RepeatedStringExtensionLite).Count);
Assert.AreEqual("hello", message2.GetExtension( Assert.AreEqual("hello", message2.GetExtension(
UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0)); UnitTestLiteProtoFile.RepeatedStringExtensionLite, 0));
Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension( Assert.AreEqual(TestAllTypesLite.Types.NestedEnum.BAZ, message2.GetExtension(
UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite)); UnitTestLiteProtoFile.OptionalNestedEnumExtensionLite));
Assert.AreEqual(7, message2.GetExtension( Assert.AreEqual(7, message2.GetExtension(
UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite).Bb); UnitTestLiteProtoFile.OptionalNestedMessageExtensionLite).Bb);
} }
} }
} }

436
src/ProtocolBuffersLite.Test/MissingFieldAndExtensionTest.cs
Unescape View File

@ -1,219 +1,219 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using System.IO; using System.IO;
using NUnit.Framework; using NUnit.Framework;
using System.Collections.Generic; using System.Collections.Generic;
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
[TestFixture] [TestFixture]
public class MissingFieldAndExtensionTest { public class MissingFieldAndExtensionTest {
[Test] [Test]
public void TestRecoverMissingExtensions() { public void TestRecoverMissingExtensions() {
const int optionalInt32 = 12345678; const int optionalInt32 = 12345678;
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
builder.SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32); builder.SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32);
builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.1); builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.1);
builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.2); builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.2);
builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.3); builder.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1.3);
TestAllExtensions msg = builder.Build(); TestAllExtensions msg = builder.Build();
Assert.IsTrue(msg.HasExtension(UnitTestProtoFile.OptionalInt32Extension)); Assert.IsTrue(msg.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
Assert.AreEqual(3, msg.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); Assert.AreEqual(3, msg.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
byte[] bits = msg.ToByteArray(); byte[] bits = msg.ToByteArray();
TestAllExtensions copy = TestAllExtensions.ParseFrom(bits); TestAllExtensions copy = TestAllExtensions.ParseFrom(bits);
Assert.IsFalse(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension)); Assert.IsFalse(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
Assert.AreEqual(0, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); Assert.AreEqual(0, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
Assert.AreNotEqual(msg, copy); Assert.AreNotEqual(msg, copy);
//Even though copy does not understand the typees they serialize correctly //Even though copy does not understand the typees they serialize correctly
byte[] copybits = copy.ToByteArray(); byte[] copybits = copy.ToByteArray();
Assert.AreEqual(bits, copybits); Assert.AreEqual(bits, copybits);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestProtoFile.RegisterAllExtensions(registry); UnitTestProtoFile.RegisterAllExtensions(registry);
//Now we can take those copy bits and restore the full message with extensions //Now we can take those copy bits and restore the full message with extensions
copy = TestAllExtensions.ParseFrom(copybits, registry); copy = TestAllExtensions.ParseFrom(copybits, registry);
Assert.IsTrue(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension)); Assert.IsTrue(copy.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
Assert.AreEqual(3, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); Assert.AreEqual(3, copy.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension));
Assert.AreEqual(msg, copy); Assert.AreEqual(msg, copy);
Assert.AreEqual(bits, copy.ToByteArray()); Assert.AreEqual(bits, copy.ToByteArray());
//If we modify the object this should all continue to work as before //If we modify the object this should all continue to work as before
copybits = copy.ToBuilder().Build().ToByteArray(); copybits = copy.ToBuilder().Build().ToByteArray();
Assert.AreEqual(bits, copybits); Assert.AreEqual(bits, copybits);
//If we replace extension the object this should all continue to work as before //If we replace extension the object this should all continue to work as before
copybits = copy.ToBuilder() copybits = copy.ToBuilder()
.SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32) .SetExtension(UnitTestProtoFile.OptionalInt32Extension, optionalInt32)
.Build().ToByteArray(); .Build().ToByteArray();
Assert.AreEqual(bits, copybits); Assert.AreEqual(bits, copybits);
} }
[Test] [Test]
public void TestRecoverMissingFields() { public void TestRecoverMissingFields() {
TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder() TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder()
.SetId(1001) .SetId(1001)
.SetName("Name") .SetName("Name")
.SetEmail("missing@field.value") .SetEmail("missing@field.value")
.Build(); .Build();
//serialize to type B and verify all fields exist //serialize to type B and verify all fields exist
TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray()); TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
Assert.AreEqual(1001, msgb.Id); Assert.AreEqual(1001, msgb.Id);
Assert.AreEqual("Name", msgb.Name); Assert.AreEqual("Name", msgb.Name);
Assert.IsFalse(msgb.HasWebsite); Assert.IsFalse(msgb.HasWebsite);
Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
Assert.AreEqual("missing@field.value", msgb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8()); Assert.AreEqual("missing@field.value", msgb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8());
//serializes exactly the same (at least for this simple example) //serializes exactly the same (at least for this simple example)
Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray()); Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());
Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray())); Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
//now re-create an exact copy of A from serialized B //now re-create an exact copy of A from serialized B
TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
Assert.AreEqual(msga, copya); Assert.AreEqual(msga, copya);
Assert.AreEqual(1001, copya.Id); Assert.AreEqual(1001, copya.Id);
Assert.AreEqual("Name", copya.Name); Assert.AreEqual("Name", copya.Name);
Assert.AreEqual("missing@field.value", copya.Email); Assert.AreEqual("missing@field.value", copya.Email);
//Now we modify B... and try again //Now we modify B... and try again
msgb = msgb.ToBuilder().SetWebsite("http://new.missing.field").Build(); msgb = msgb.ToBuilder().SetWebsite("http://new.missing.field").Build();
//Does B still have the missing field? //Does B still have the missing field?
Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
//Convert back to A and see if all fields are there? //Convert back to A and see if all fields are there?
copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
Assert.AreNotEqual(msga, copya); Assert.AreNotEqual(msga, copya);
Assert.AreEqual(1001, copya.Id); Assert.AreEqual(1001, copya.Id);
Assert.AreEqual("Name", copya.Name); Assert.AreEqual("Name", copya.Name);
Assert.AreEqual("missing@field.value", copya.Email); Assert.AreEqual("missing@field.value", copya.Email);
Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count);
Assert.AreEqual("http://new.missing.field", copya.UnknownFields[TestMissingFieldsB.WebsiteFieldNumber].LengthDelimitedList[0].ToStringUtf8()); Assert.AreEqual("http://new.missing.field", copya.UnknownFields[TestMissingFieldsB.WebsiteFieldNumber].LengthDelimitedList[0].ToStringUtf8());
//Lastly we can even still trip back to type B and see all fields: //Lastly we can even still trip back to type B and see all fields:
TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray()); TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order. Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
Assert.AreEqual(1001, copyb.Id); Assert.AreEqual(1001, copyb.Id);
Assert.AreEqual("Name", copyb.Name); Assert.AreEqual("Name", copyb.Name);
Assert.AreEqual("http://new.missing.field", copyb.Website); Assert.AreEqual("http://new.missing.field", copyb.Website);
Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count);
Assert.AreEqual("missing@field.value", copyb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8()); Assert.AreEqual("missing@field.value", copyb.UnknownFields[TestMissingFieldsA.EmailFieldNumber].LengthDelimitedList[0].ToStringUtf8());
} }
[Test] [Test]
public void TestRecoverMissingMessage() { public void TestRecoverMissingMessage() {
TestMissingFieldsA.Types.SubA suba = TestMissingFieldsA.Types.SubA.CreateBuilder().SetCount(3).AddValues("a").AddValues("b").AddValues("c").Build(); TestMissingFieldsA.Types.SubA suba = TestMissingFieldsA.Types.SubA.CreateBuilder().SetCount(3).AddValues("a").AddValues("b").AddValues("c").Build();
TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder() TestMissingFieldsA msga = TestMissingFieldsA.CreateBuilder()
.SetId(1001) .SetId(1001)
.SetName("Name") .SetName("Name")
.SetTestA(suba) .SetTestA(suba)
.Build(); .Build();
//serialize to type B and verify all fields exist //serialize to type B and verify all fields exist
TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray()); TestMissingFieldsB msgb = TestMissingFieldsB.ParseFrom(msga.ToByteArray());
Assert.AreEqual(1001, msgb.Id); Assert.AreEqual(1001, msgb.Id);
Assert.AreEqual("Name", msgb.Name); Assert.AreEqual("Name", msgb.Name);
Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
Assert.AreEqual(suba.ToString(), TestMissingFieldsA.Types.SubA.ParseFrom(msgb.UnknownFields[TestMissingFieldsA.TestAFieldNumber].LengthDelimitedList[0]).ToString()); Assert.AreEqual(suba.ToString(), TestMissingFieldsA.Types.SubA.ParseFrom(msgb.UnknownFields[TestMissingFieldsA.TestAFieldNumber].LengthDelimitedList[0]).ToString());
//serializes exactly the same (at least for this simple example) //serializes exactly the same (at least for this simple example)
Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray()); Assert.AreEqual(msga.ToByteArray(), msgb.ToByteArray());
Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray())); Assert.AreEqual(msga, TestMissingFieldsA.ParseFrom(msgb.ToByteArray()));
//now re-create an exact copy of A from serialized B //now re-create an exact copy of A from serialized B
TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); TestMissingFieldsA copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
Assert.AreEqual(msga, copya); Assert.AreEqual(msga, copya);
Assert.AreEqual(1001, copya.Id); Assert.AreEqual(1001, copya.Id);
Assert.AreEqual("Name", copya.Name); Assert.AreEqual("Name", copya.Name);
Assert.AreEqual(suba, copya.TestA); Assert.AreEqual(suba, copya.TestA);
//Now we modify B... and try again //Now we modify B... and try again
TestMissingFieldsB.Types.SubB subb = TestMissingFieldsB.Types.SubB.CreateBuilder().AddValues("test-b").Build(); TestMissingFieldsB.Types.SubB subb = TestMissingFieldsB.Types.SubB.CreateBuilder().AddValues("test-b").Build();
msgb = msgb.ToBuilder().SetTestB(subb).Build(); msgb = msgb.ToBuilder().SetTestB(subb).Build();
//Does B still have the missing field? //Does B still have the missing field?
Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, msgb.UnknownFields.FieldDictionary.Count);
//Convert back to A and see if all fields are there? //Convert back to A and see if all fields are there?
copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray()); copya = TestMissingFieldsA.ParseFrom(msgb.ToByteArray());
Assert.AreNotEqual(msga, copya); Assert.AreNotEqual(msga, copya);
Assert.AreEqual(1001, copya.Id); Assert.AreEqual(1001, copya.Id);
Assert.AreEqual("Name", copya.Name); Assert.AreEqual("Name", copya.Name);
Assert.AreEqual(suba, copya.TestA); Assert.AreEqual(suba, copya.TestA);
Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, copya.UnknownFields.FieldDictionary.Count);
Assert.AreEqual(subb.ToByteArray(), copya.UnknownFields[TestMissingFieldsB.TestBFieldNumber].LengthDelimitedList[0].ToByteArray()); Assert.AreEqual(subb.ToByteArray(), copya.UnknownFields[TestMissingFieldsB.TestBFieldNumber].LengthDelimitedList[0].ToByteArray());
//Lastly we can even still trip back to type B and see all fields: //Lastly we can even still trip back to type B and see all fields:
TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray()); TestMissingFieldsB copyb = TestMissingFieldsB.ParseFrom(copya.ToByteArray());
Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order. Assert.AreEqual(copya.ToByteArray().Length, copyb.ToByteArray().Length); //not exact order.
Assert.AreEqual(1001, copyb.Id); Assert.AreEqual(1001, copyb.Id);
Assert.AreEqual("Name", copyb.Name); Assert.AreEqual("Name", copyb.Name);
Assert.AreEqual(subb, copyb.TestB); Assert.AreEqual(subb, copyb.TestB);
Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count); Assert.AreEqual(1, copyb.UnknownFields.FieldDictionary.Count);
} }
[Test] [Test]
public void TestRestoreFromOtherType() { public void TestRestoreFromOtherType() {
TestInteropPerson person = TestInteropPerson.CreateBuilder() TestInteropPerson person = TestInteropPerson.CreateBuilder()
.SetId(123) .SetId(123)
.SetName("abc") .SetName("abc")
.SetEmail("abc@123.com") .SetEmail("abc@123.com")
.AddRangeCodes(new[] {1, 2, 3}) .AddRangeCodes(new[] {1, 2, 3})
.AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build()) .AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-1234").Build())
.AddPhone(TestInteropPerson.Types.PhoneNumber.CreateBuilder().SetNumber("555-5678").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()) .AddAddresses(TestInteropPerson.Types.Addresses.CreateBuilder().SetAddress("123 Seseme").SetCity("Wonderland").SetState("NA").SetZip(12345).Build())
.SetExtension(UnitTestExtrasFullProtoFile.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build()) .SetExtension(UnitTestExtrasFullProtoFile.EmployeeId, TestInteropEmployeeId.CreateBuilder().SetNumber("123").Build())
.Build(); .Build();
Assert.IsTrue(person.IsInitialized); Assert.IsTrue(person.IsInitialized);
TestEmptyMessage temp = TestEmptyMessage.ParseFrom(person.ToByteArray()); TestEmptyMessage temp = TestEmptyMessage.ParseFrom(person.ToByteArray());
Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count); Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
temp = temp.ToBuilder().Build(); temp = temp.ToBuilder().Build();
Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count); Assert.AreEqual(7, temp.UnknownFields.FieldDictionary.Count);
ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry); UnitTestExtrasFullProtoFile.RegisterAllExtensions(registry);
TestInteropPerson copy = TestInteropPerson.ParseFrom(temp.ToByteArray(), registry); TestInteropPerson copy = TestInteropPerson.ParseFrom(temp.ToByteArray(), registry);
Assert.AreEqual(person, copy); Assert.AreEqual(person, copy);
Assert.AreEqual(person.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(person.ToByteArray(), copy.ToByteArray());
} }
} }
} }

166
src/ProtocolBuffersLite.Test/ProtocolBuffersLite.Test.csproj
Unescape View File

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

176
src/ProtocolBuffersLite.Test/ProtocolBuffersLiteMixed.Test.csproj
Unescape View File

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

226
src/ProtocolBuffersLite.Test/TestLiteByApi.cs
Unescape View File

@ -1,113 +1,113 @@
#region Copyright notice and license #region Copyright notice and license
// Protocol Buffers - Google's data interchange format // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved. // Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/ // http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code: // Original C++/Java/Python code:
// http://code.google.com/p/protobuf/ // http://code.google.com/p/protobuf/
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
// //
// * Redistributions of source code must retain the above copyright // * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above // * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer // copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the // in the documentation and/or other materials provided with the
// distribution. // distribution.
// * Neither the name of Google Inc. nor the names of its // * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from // contributors may be used to endorse or promote products derived from
// this software without specific prior written permission. // this software without specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion #endregion
using Google.ProtocolBuffers.TestProtos; using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework; using NUnit.Framework;
namespace Google.ProtocolBuffers { namespace Google.ProtocolBuffers {
[TestFixture] [TestFixture]
public class TestLiteByApi { public class TestLiteByApi {
[Test] [Test]
public void TestAllTypesEquality() { public void TestAllTypesEquality() {
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
TestAllTypesLite copy = msg.ToBuilder().Build(); TestAllTypesLite copy = msg.ToBuilder().Build();
Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
Assert.IsTrue(msg.Equals(copy)); Assert.IsTrue(msg.Equals(copy));
msg = msg.ToBuilder().SetOptionalString("Hi").Build(); msg = msg.ToBuilder().SetOptionalString("Hi").Build();
Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode()); Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode());
Assert.IsFalse(msg.Equals(copy)); Assert.IsFalse(msg.Equals(copy));
copy = copy.ToBuilder().SetOptionalString("Hi").Build(); copy = copy.ToBuilder().SetOptionalString("Hi").Build();
Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
Assert.IsTrue(msg.Equals(copy)); Assert.IsTrue(msg.Equals(copy));
} }
[Test] [Test]
public void TestEqualityOnExtensions() { public void TestEqualityOnExtensions() {
TestAllExtensionsLite msg = TestAllExtensionsLite.DefaultInstance; TestAllExtensionsLite msg = TestAllExtensionsLite.DefaultInstance;
TestAllExtensionsLite copy = msg.ToBuilder().Build(); TestAllExtensionsLite copy = msg.ToBuilder().Build();
Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
Assert.IsTrue(msg.Equals(copy)); Assert.IsTrue(msg.Equals(copy));
msg = msg.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build(); msg = msg.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build();
Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode()); Assert.AreNotEqual(msg.GetHashCode(), copy.GetHashCode());
Assert.IsFalse(msg.Equals(copy)); Assert.IsFalse(msg.Equals(copy));
copy = copy.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build(); copy = copy.ToBuilder().SetExtension(UnitTestLiteProtoFile.OptionalStringExtensionLite, "Hi").Build();
Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode()); Assert.AreEqual(msg.GetHashCode(), copy.GetHashCode());
Assert.IsTrue(msg.Equals(copy)); Assert.IsTrue(msg.Equals(copy));
} }
[Test] [Test]
public void TestAllTypesToString() { public void TestAllTypesToString() {
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
TestAllTypesLite copy = msg.ToBuilder().Build(); TestAllTypesLite copy = msg.ToBuilder().Build();
Assert.AreEqual(msg.ToString(), copy.ToString()); Assert.AreEqual(msg.ToString(), copy.ToString());
Assert.IsEmpty(msg.ToString()); Assert.IsEmpty(msg.ToString());
msg = msg.ToBuilder().SetOptionalInt32(-1).Build(); msg = msg.ToBuilder().SetOptionalInt32(-1).Build();
Assert.AreEqual("optional_int32: -1", msg.ToString().TrimEnd()); Assert.AreEqual("optional_int32: -1", msg.ToString().TrimEnd());
msg = msg.ToBuilder().SetOptionalString("abc123").Build(); msg = msg.ToBuilder().SetOptionalString("abc123").Build();
Assert.AreEqual("optional_int32: -1\noptional_string: \"abc123\"", msg.ToString().Replace("\r", "").TrimEnd()); Assert.AreEqual("optional_int32: -1\noptional_string: \"abc123\"", msg.ToString().Replace("\r", "").TrimEnd());
} }
[Test] [Test]
public void TestAllTypesDefaultedRoundTrip() { public void TestAllTypesDefaultedRoundTrip() {
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
Assert.IsTrue(msg.IsInitialized); Assert.IsTrue(msg.IsInitialized);
TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build(); TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
[Test] [Test]
public void TestAllTypesModifiedRoundTrip() { public void TestAllTypesModifiedRoundTrip() {
TestAllTypesLite msg = TestAllTypesLite.DefaultInstance; TestAllTypesLite msg = TestAllTypesLite.DefaultInstance;
msg.ToBuilder() msg.ToBuilder()
.SetOptionalBool(true) .SetOptionalBool(true)
.SetOptionalCord("Hi") .SetOptionalCord("Hi")
.SetOptionalDouble(1.123) .SetOptionalDouble(1.123)
.SetOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_FOO) .SetOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_FOO)
.SetOptionalForeignMessage(ForeignMessageLite.CreateBuilder().SetC('c').Build()) .SetOptionalForeignMessage(ForeignMessageLite.CreateBuilder().SetC('c').Build())
.SetOptionalGroup(TestAllTypesLite.Types.OptionalGroup.CreateBuilder().SetA('a').Build()) .SetOptionalGroup(TestAllTypesLite.Types.OptionalGroup.CreateBuilder().SetA('a').Build())
.SetOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR) .SetOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR)
.SetOptionalInt32(32) .SetOptionalInt32(32)
.SetOptionalInt64(64) .SetOptionalInt64(64)
.SetOptionalNestedEnum(TestAllTypesLite.Types.NestedEnum.FOO) .SetOptionalNestedEnum(TestAllTypesLite.Types.NestedEnum.FOO)
.SetOptionalString("SetOptionalString") .SetOptionalString("SetOptionalString")
.AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('a').Build()) .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('a').Build())
.AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('A').Build()) .AddRepeatedGroup(TestAllTypesLite.Types.RepeatedGroup.CreateBuilder().SetA('A').Build())
; ;
TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build(); TestAllTypesLite copy = TestAllTypesLite.CreateBuilder().MergeFrom(msg.ToByteArray()).Build();
Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray());
} }
} }
} }

3442
src/ProtocolBuffersLite.Test/TestProtos/UnitTestExtrasLiteProtoFile.cs
View File

File diff suppressed because it is too large Load Diff

232
testdata/text_format_unittest_data.txt vendored
Unescape View File

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

232
testdata/text_format_unittest_extensions_data.txt vendored
Unescape View File

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

32
todo.txt
Unescape View File

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

Write Preview
Loading…
Cancel
Save