From a105eac521b6a810b9c40db2febba412e316d0b2 Mon Sep 17 00:00:00 2001 From: csharptest Date: Fri, 9 Sep 2011 13:39:54 -0500 Subject: Added support for negative enum values and tests --- src/ProtocolBuffers.Test/CodedInputStreamTest.cs | 73 ++++ src/ProtocolBuffers.Test/CodedOutputStreamTest.cs | 79 ++++ .../ProtocolBuffers.Test.csproj | 1 + src/ProtocolBuffers.Test/TestCornerCases.cs | 38 ++ .../TestProtos/UnitTestExtrasIssuesProtoFile.cs | 416 ++++++++++++++++++++- .../CodedOutputStream.ComputeSize.cs | 4 +- src/ProtocolBuffers/CodedOutputStream.cs | 4 +- 7 files changed, 608 insertions(+), 7 deletions(-) create mode 100644 src/ProtocolBuffers.Test/TestCornerCases.cs (limited to 'src') diff --git a/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/src/ProtocolBuffers.Test/CodedInputStreamTest.cs index c3ca0a10..64656b19 100644 --- a/src/ProtocolBuffers.Test/CodedInputStreamTest.cs +++ b/src/ProtocolBuffers.Test/CodedInputStreamTest.cs @@ -35,6 +35,7 @@ #endregion using System; +using System.Collections.Generic; using System.IO; using Google.ProtocolBuffers.TestProtos; using NUnit.Framework; @@ -532,5 +533,77 @@ namespace Google.ProtocolBuffers return base.Read(buffer, offset, Math.Min(count, blockSize)); } } + + enum TestNegEnum { None = 0, Value = -2 } + + [Test] + public void TestNegativeEnum() + { + byte[] bytes = new byte[10] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 }; + CodedInputStream input = CodedInputStream.CreateInstance(bytes); + object unk; + TestNegEnum val = TestNegEnum.None; + + Assert.IsTrue(input.ReadEnum(ref val, out unk)); + Assert.IsTrue(input.IsAtEnd); + Assert.AreEqual(TestNegEnum.Value, val); + } + + [Test] + public void TestNegativeEnumPackedArray() + { + int arraySize = 1 + (10 * 5); + int msgSize = 1 + 1 + arraySize; + byte[] bytes = new byte[msgSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + output.WritePackedInt32Array(8, "", arraySize, new int[] { 0, -1, -2, -3, -4, -5 }); + + Assert.AreEqual(0, output.SpaceLeft); + + CodedInputStream input = CodedInputStream.CreateInstance(bytes); + uint tag; + string name; + Assert.IsTrue(input.ReadTag(out tag, out name)); + + List values = new List(); + ICollection unk; + input.ReadEnumArray(tag, name, values, out unk); + + Assert.AreEqual(2, values.Count); + Assert.AreEqual(TestNegEnum.None, values[0]); + Assert.AreEqual(TestNegEnum.Value, values[1]); + + Assert.IsNotNull(unk); + Assert.AreEqual(4, unk.Count); + } + + [Test] + public void TestNegativeEnumArray() + { + int arraySize = 1 + 1 + (11 * 5); + int msgSize = arraySize; + byte[] bytes = new byte[msgSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + output.WriteInt32Array(8, "", new int[] { 0, -1, -2, -3, -4, -5 }); + + Assert.AreEqual(0, output.SpaceLeft); + + CodedInputStream input = CodedInputStream.CreateInstance(bytes); + uint tag; + string name; + Assert.IsTrue(input.ReadTag(out tag, out name)); + + List values = new List(); + ICollection unk; + input.ReadEnumArray(tag, name, values, out unk); + + Assert.AreEqual(2, values.Count); + Assert.AreEqual(TestNegEnum.None, values[0]); + Assert.AreEqual(TestNegEnum.Value, values[1]); + + Assert.IsNotNull(unk); + Assert.AreEqual(4, unk.Count); + } + } } \ No newline at end of file diff --git a/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs index 3dd2e0c3..d041d3f0 100644 --- a/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs +++ b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs @@ -34,6 +34,8 @@ #endregion +using System; +using System.Collections.Generic; using System.IO; using Google.ProtocolBuffers.TestProtos; using NUnit.Framework; @@ -288,5 +290,82 @@ namespace Google.ProtocolBuffers Assert.AreEqual(-75123905439571256L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L))); } + + [Test] + public void TestNegativeEnumNoTag() + { + Assert.AreEqual(10, CodedOutputStream.ComputeInt32SizeNoTag(-2)); + Assert.AreEqual(10, CodedOutputStream.ComputeEnumSizeNoTag(-2)); + + byte[] bytes = new byte[10]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + output.WriteEnumNoTag(-2); + + Assert.AreEqual(0, output.SpaceLeft); + Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes)); + } + + [Test] + public void TestNegativeEnumWithTag() + { + Assert.AreEqual(11, CodedOutputStream.ComputeInt32Size(8, -2)); + Assert.AreEqual(11, CodedOutputStream.ComputeEnumSize(8, -2)); + + byte[] bytes = new byte[11]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + output.WriteEnum(8, "", -2, -2); + + Assert.AreEqual(0, output.SpaceLeft); + //fyi, 0x40 == 0x08 << 3 + 0, field num + wire format shift + Assert.AreEqual("40-FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes)); + } + + [Test] + public void TestNegativeEnumArrayPacked() + { + int arraySize = 1 + (10 * 5); + int msgSize = 1 + 1 + arraySize; + byte[] bytes = new byte[msgSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + output.WritePackedEnumArray(8, "", arraySize, new int[] { 0, -1, -2, -3, -4, -5 }); + + Assert.AreEqual(0, output.SpaceLeft); + + CodedInputStream input = CodedInputStream.CreateInstance(bytes); + uint tag; + string name; + Assert.IsTrue(input.ReadTag(out tag, out name)); + + List values = new List(); + input.ReadInt32Array(tag, name, values); + + Assert.AreEqual(6, values.Count); + for (int i = 0; i > -6; i--) + Assert.AreEqual(i, values[Math.Abs(i)]); + } + + [Test] + public void TestNegativeEnumArray() + { + int arraySize = 1 + 1 + (11 * 5); + int msgSize = arraySize; + byte[] bytes = new byte[msgSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + output.WriteEnumArray(8, "", new int[] { 0, -1, -2, -3, -4, -5 }); + + Assert.AreEqual(0, output.SpaceLeft); + + CodedInputStream input = CodedInputStream.CreateInstance(bytes); + uint tag; + string name; + Assert.IsTrue(input.ReadTag(out tag, out name)); + + List values = new List(); + input.ReadInt32Array(tag, name, values); + + Assert.AreEqual(6, values.Count); + for (int i = 0; i > -6; i--) + Assert.AreEqual(i, values[Math.Abs(i)]); + } } } \ No newline at end of file diff --git a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 95ab0b9c..50838172 100644 --- a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -106,6 +106,7 @@ + diff --git a/src/ProtocolBuffers.Test/TestCornerCases.cs b/src/ProtocolBuffers.Test/TestCornerCases.cs new file mode 100644 index 00000000..8a3fe051 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestCornerCases.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NUnit.Framework; +using UnitTest.Issues.TestProtos; + +namespace Google.ProtocolBuffers +{ + [TestFixture] + public class TestCornerCases + { + [Test] + public void TestRoundTripNegativeEnums() + { + NegativeEnumMessage msg = NegativeEnumMessage.CreateBuilder() + .SetValue(NegativeEnum.MinusOne) //11 + .AddValues(NegativeEnum.Zero) //2 + .AddValues(NegativeEnum.MinusOne) //11 + .AddValues(NegativeEnum.FiveBelow) //11 + //2 + .AddPackedValues(NegativeEnum.Zero) //1 + .AddPackedValues(NegativeEnum.MinusOne) //10 + .AddPackedValues(NegativeEnum.FiveBelow) //10 + .Build(); + + Assert.AreEqual(58, msg.SerializedSize); + + byte[] bytes = new byte[58]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + + msg.WriteTo(output); + Assert.AreEqual(0, output.SpaceLeft); + + NegativeEnumMessage copy = NegativeEnumMessage.ParseFrom(bytes); + Assert.AreEqual(msg, copy); + } + } +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestExtrasIssuesProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestExtrasIssuesProtoFile.cs index db56e8b9..3ea55b88 100644 --- a/src/ProtocolBuffers.Test/TestProtos/UnitTestExtrasIssuesProtoFile.cs +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestExtrasIssuesProtoFile.cs @@ -26,6 +26,8 @@ namespace UnitTest.Issues.TestProtos { internal static pb::FieldAccess.FieldAccessorTable internal__static_unittest_issues_AB__FieldAccessorTable; internal static pbd::MessageDescriptor internal__static_unittest_issues_NumberField__Descriptor; internal static pb::FieldAccess.FieldAccessorTable internal__static_unittest_issues_NumberField__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_unittest_issues_NegativeEnumMessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable internal__static_unittest_issues_NegativeEnumMessage__FieldAccessorTable; #endregion #region Descriptor public static pbd::FileDescriptor Descriptor { @@ -38,9 +40,14 @@ namespace UnitTest.Issues.TestProtos { "ChxleHRlc3QvdW5pdHRlc3RfaXNzdWVzLnByb3RvEg91bml0dGVzdF9pc3N1" + "ZXMaJGdvb2dsZS9wcm90b2J1Zi9jc2hhcnBfb3B0aW9ucy5wcm90byIPCgFB" + "EgoKAl9BGAEgASgFIg8KAUISCgoCQl8YASABKAUiEQoCQUISCwoDYV9iGAEg" + - "ASgFIhoKC051bWJlckZpZWxkEgsKA18wMRgBIAEoBUJASAHCPjsKGlVuaXRU" + - "ZXN0Lklzc3Vlcy5UZXN0UHJvdG9zEh1Vbml0VGVzdEV4dHJhc0lzc3Vlc1By" + - "b3RvRmlsZQ=="); + "ASgFIhoKC051bWJlckZpZWxkEgsKA18wMRgBIAEoBSKsAQoTTmVnYXRpdmVF" + + "bnVtTWVzc2FnZRIsCgV2YWx1ZRgBIAEoDjIdLnVuaXR0ZXN0X2lzc3Vlcy5O" + + "ZWdhdGl2ZUVudW0SLQoGdmFsdWVzGAIgAygOMh0udW5pdHRlc3RfaXNzdWVz" + + "Lk5lZ2F0aXZlRW51bRI4Cg1wYWNrZWRfdmFsdWVzGAMgAygOMh0udW5pdHRl" + + "c3RfaXNzdWVzLk5lZ2F0aXZlRW51bUICEAEqRwoMTmVnYXRpdmVFbnVtEhYK" + + "CUZpdmVCZWxvdxD7//////////8BEhUKCE1pbnVzT25lEP///////////wES" + + "CAoEWmVybxAAQkBIAcI+OwoaVW5pdFRlc3QuSXNzdWVzLlRlc3RQcm90b3MS" + + "HVVuaXRUZXN0RXh0cmFzSXNzdWVzUHJvdG9GaWxl"); pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { descriptor = root; internal__static_unittest_issues_A__Descriptor = Descriptor.MessageTypes[0]; @@ -59,6 +66,10 @@ namespace UnitTest.Issues.TestProtos { internal__static_unittest_issues_NumberField__FieldAccessorTable = new pb::FieldAccess.FieldAccessorTable(internal__static_unittest_issues_NumberField__Descriptor, new string[] { "_01", }); + internal__static_unittest_issues_NegativeEnumMessage__Descriptor = Descriptor.MessageTypes[4]; + internal__static_unittest_issues_NegativeEnumMessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable(internal__static_unittest_issues_NegativeEnumMessage__Descriptor, + new string[] { "Value", "Values", "PackedValues", }); pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance(); RegisterAllExtensions(registry); global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.RegisterAllExtensions(registry); @@ -72,6 +83,17 @@ namespace UnitTest.Issues.TestProtos { #endregion } + #region Enums + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] + public enum NegativeEnum { + FiveBelow = -5, + MinusOne = -1, + Zero = 0, + } + + #endregion + #region Messages [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] @@ -1033,6 +1055,394 @@ namespace UnitTest.Issues.TestProtos { } } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] + public sealed partial class NegativeEnumMessage : pb::GeneratedMessage { + private static readonly NegativeEnumMessage defaultInstance = new Builder().BuildPartial(); + private static readonly string[] _negativeEnumMessageFieldNames = new string[] { "packed_values", "value", "values" }; + private static readonly uint[] _negativeEnumMessageFieldTags = new uint[] { 26, 8, 16 }; + public static NegativeEnumMessage DefaultInstance { + get { return defaultInstance; } + } + + public override NegativeEnumMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NegativeEnumMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::UnitTest.Issues.TestProtos.UnitTestExtrasIssuesProtoFile.internal__static_unittest_issues_NegativeEnumMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::UnitTest.Issues.TestProtos.UnitTestExtrasIssuesProtoFile.internal__static_unittest_issues_NegativeEnumMessage__FieldAccessorTable; } + } + + public const int ValueFieldNumber = 1; + private bool hasValue; + private global::UnitTest.Issues.TestProtos.NegativeEnum value_ = global::UnitTest.Issues.TestProtos.NegativeEnum.FiveBelow; + public bool HasValue { + get { return hasValue; } + } + public global::UnitTest.Issues.TestProtos.NegativeEnum Value { + get { return value_; } + } + + public const int ValuesFieldNumber = 2; + private pbc::PopsicleList values_ = new pbc::PopsicleList(); + public scg::IList ValuesList { + get { return pbc::Lists.AsReadOnly(values_); } + } + public int ValuesCount { + get { return values_.Count; } + } + public global::UnitTest.Issues.TestProtos.NegativeEnum GetValues(int index) { + return values_[index]; + } + + public const int PackedValuesFieldNumber = 3; + private int packedValuesMemoizedSerializedSize; + private pbc::PopsicleList packedValues_ = new pbc::PopsicleList(); + public scg::IList PackedValuesList { + get { return pbc::Lists.AsReadOnly(packedValues_); } + } + public int PackedValuesCount { + get { return packedValues_.Count; } + } + public global::UnitTest.Issues.TestProtos.NegativeEnum GetPackedValues(int index) { + return packedValues_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::ICodedOutputStream output) { + int size = SerializedSize; + string[] field_names = _negativeEnumMessageFieldNames; + if (hasValue) { + output.WriteEnum(1, field_names[1], (int) Value, Value); + } + if (values_.Count > 0) { + output.WriteEnumArray(2, field_names[2], values_); + } + if (packedValues_.Count > 0) { + output.WritePackedEnumArray(3, field_names[0], packedValuesMemoizedSerializedSize, packedValues_); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (hasValue) { + size += pb::CodedOutputStream.ComputeEnumSize(1, (int) Value); + } + { + int dataSize = 0; + if (values_.Count > 0) { + foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in values_) { + dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element); + } + size += dataSize; + size += 1 * values_.Count; + } + } + { + int dataSize = 0; + if (packedValues_.Count > 0) { + foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in packedValues_) { + dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element); + } + size += dataSize; + size += 1; + size += pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); + } + packedValuesMemoizedSerializedSize = dataSize; + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NegativeEnumMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NegativeEnumMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NegativeEnumMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NegativeEnumMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NegativeEnumMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NegativeEnumMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NegativeEnumMessage ParseDelimitedFrom(global::System.IO.Stream input) { + return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); + } + public static NegativeEnumMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); + } + public static NegativeEnumMessage ParseFrom(pb::ICodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NegativeEnumMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder ToBuilder() { return CreateBuilder(this); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NegativeEnumMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NegativeEnumMessage result = new NegativeEnumMessage(); + + protected override NegativeEnumMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NegativeEnumMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return global::UnitTest.Issues.TestProtos.NegativeEnumMessage.Descriptor; } + } + + public override NegativeEnumMessage DefaultInstanceForType { + get { return global::UnitTest.Issues.TestProtos.NegativeEnumMessage.DefaultInstance; } + } + + public override NegativeEnumMessage BuildPartial() { + if (result == null) { + throw new global::System.InvalidOperationException("build() has already been called on this Builder"); + } + result.values_.MakeReadOnly(); + result.packedValues_.MakeReadOnly(); + NegativeEnumMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NegativeEnumMessage) { + return MergeFrom((NegativeEnumMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NegativeEnumMessage other) { + if (other == global::UnitTest.Issues.TestProtos.NegativeEnumMessage.DefaultInstance) return this; + if (other.HasValue) { + Value = other.Value; + } + if (other.values_.Count != 0) { + base.AddRange(other.values_, result.values_); + } + if (other.packedValues_.Count != 0) { + base.AddRange(other.packedValues_, result.packedValues_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::ICodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = null; + uint tag; + string field_name; + while (input.ReadTag(out tag, out field_name)) { + if(tag == 0 && field_name != null) { + int field_ordinal = global::System.Array.BinarySearch(_negativeEnumMessageFieldNames, field_name, global::System.StringComparer.Ordinal); + if(field_ordinal >= 0) + tag = _negativeEnumMessageFieldTags[field_ordinal]; + else { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + continue; + } + } + switch (tag) { + case 0: { + throw pb::InvalidProtocolBufferException.InvalidTag(); + } + default: { + if (pb::WireFormat.IsEndGroupTag(tag)) { + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name); + break; + } + case 8: { + object unknown; + if(input.ReadEnum(ref result.value_, out unknown)) { + result.hasValue = true; + } else if(unknown is int) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + unknownFields.MergeVarintField(1, (ulong)(int)unknown); + } + break; + } + case 18: + case 16: { + scg::ICollection unknownItems; + input.ReadEnumArray(tag, field_name, result.values_, out unknownItems); + if (unknownItems != null) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + foreach (object rawValue in unknownItems) + if (rawValue is int) + unknownFields.MergeVarintField(2, (ulong)(int)rawValue); + } + break; + } + case 26: + case 24: { + scg::ICollection unknownItems; + input.ReadEnumArray(tag, field_name, result.packedValues_, out unknownItems); + if (unknownItems != null) { + if (unknownFields == null) { + unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + } + foreach (object rawValue in unknownItems) + if (rawValue is int) + unknownFields.MergeVarintField(3, (ulong)(int)rawValue); + } + break; + } + } + } + + if (unknownFields != null) { + this.UnknownFields = unknownFields.Build(); + } + return this; + } + + + public bool HasValue { + get { return result.hasValue; } + } + public global::UnitTest.Issues.TestProtos.NegativeEnum Value { + get { return result.Value; } + set { SetValue(value); } + } + public Builder SetValue(global::UnitTest.Issues.TestProtos.NegativeEnum value) { + result.hasValue = true; + result.value_ = value; + return this; + } + public Builder ClearValue() { + result.hasValue = false; + result.value_ = global::UnitTest.Issues.TestProtos.NegativeEnum.FiveBelow; + return this; + } + + public pbc::IPopsicleList ValuesList { + get { return result.values_; } + } + public int ValuesCount { + get { return result.ValuesCount; } + } + public global::UnitTest.Issues.TestProtos.NegativeEnum GetValues(int index) { + return result.GetValues(index); + } + public Builder SetValues(int index, global::UnitTest.Issues.TestProtos.NegativeEnum value) { + result.values_[index] = value; + return this; + } + public Builder AddValues(global::UnitTest.Issues.TestProtos.NegativeEnum value) { + result.values_.Add(value); + return this; + } + public Builder AddRangeValues(scg::IEnumerable values) { + base.AddRange(values, result.values_); + return this; + } + public Builder ClearValues() { + result.values_.Clear(); + return this; + } + + public pbc::IPopsicleList PackedValuesList { + get { return result.packedValues_; } + } + public int PackedValuesCount { + get { return result.PackedValuesCount; } + } + public global::UnitTest.Issues.TestProtos.NegativeEnum GetPackedValues(int index) { + return result.GetPackedValues(index); + } + public Builder SetPackedValues(int index, global::UnitTest.Issues.TestProtos.NegativeEnum value) { + result.packedValues_[index] = value; + return this; + } + public Builder AddPackedValues(global::UnitTest.Issues.TestProtos.NegativeEnum value) { + result.packedValues_.Add(value); + return this; + } + public Builder AddRangePackedValues(scg::IEnumerable values) { + base.AddRange(values, result.packedValues_); + return this; + } + public Builder ClearPackedValues() { + result.packedValues_.Clear(); + return this; + } + } + static NegativeEnumMessage() { + object.ReferenceEquals(global::UnitTest.Issues.TestProtos.UnitTestExtrasIssuesProtoFile.Descriptor, null); + } + } + #endregion } diff --git a/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs b/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs index 50bf28d2..2da0080e 100644 --- a/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs +++ b/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs @@ -202,7 +202,7 @@ namespace Google.ProtocolBuffers /// public static int ComputeEnumSize(int fieldNumber, int value) { - return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint) value); + return ComputeTagSize(fieldNumber) + ComputeEnumSizeNoTag(value); } /// @@ -391,7 +391,7 @@ namespace Google.ProtocolBuffers /// public static int ComputeEnumSizeNoTag(int value) { - return ComputeRawVarint32Size((uint) value); + return ComputeInt32SizeNoTag(value); } /// diff --git a/src/ProtocolBuffers/CodedOutputStream.cs b/src/ProtocolBuffers/CodedOutputStream.cs index c14f5e0d..09099ee3 100644 --- a/src/ProtocolBuffers/CodedOutputStream.cs +++ b/src/ProtocolBuffers/CodedOutputStream.cs @@ -373,7 +373,7 @@ namespace Google.ProtocolBuffers public void WriteEnum(int fieldNumber, string fieldName, int value, object rawValue) { WriteTag(fieldNumber, WireFormat.WireType.Varint); - WriteRawVarint32((uint) value); + WriteInt32NoTag(value); } public void WriteSFixed32(int fieldNumber, string fieldName, int value) @@ -648,7 +648,7 @@ namespace Google.ProtocolBuffers public void WriteEnumNoTag(int value) { - WriteRawVarint32((uint) value); + WriteInt32NoTag(value); } public void WriteSFixed32NoTag(int value) -- cgit v1.2.3