| #region Copyright notice and license |
| // Protocol Buffers - Google's data interchange format |
| // Copyright 2015 Google Inc. All rights reserved. |
| // https://developers.google.com/protocol-buffers/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| #endregion |
| |
| using System; |
| using System.Collections; |
| using System.Collections.Generic; |
| using System.Collections.ObjectModel; |
| using System.IO; |
| using System.Linq; |
| using System.Text; |
| using Google.Protobuf.TestProtos; |
| using Google.Protobuf.WellKnownTypes; |
| using NUnit.Framework; |
| |
| namespace Google.Protobuf.Collections |
| { |
| public class RepeatedFieldTest |
| { |
| [Test] |
| public void NullValuesRejected() |
| { |
| var list = new RepeatedField<string>(); |
| Assert.Throws<ArgumentNullException>(() => list.Add((string)null)); |
| Assert.Throws<ArgumentNullException>(() => list.Add((IEnumerable<string>)null)); |
| Assert.Throws<ArgumentNullException>(() => list.Add((RepeatedField<string>)null)); |
| Assert.Throws<ArgumentNullException>(() => list.Contains(null)); |
| Assert.Throws<ArgumentNullException>(() => list.IndexOf(null)); |
| } |
| |
| [Test] |
| public void Add_SingleItem() |
| { |
| var list = new RepeatedField<string>(); |
| list.Add("foo"); |
| Assert.AreEqual(1, list.Count); |
| Assert.AreEqual("foo", list[0]); |
| } |
| |
| [Test] |
| public void Add_Sequence() |
| { |
| var list = new RepeatedField<string>(); |
| list.Add(new[] { "foo", "bar" }); |
| Assert.AreEqual(2, list.Count); |
| Assert.AreEqual("foo", list[0]); |
| Assert.AreEqual("bar", list[1]); |
| } |
| |
| [Test] |
| public void AddRange_SlowPath() |
| { |
| var list = new RepeatedField<string>(); |
| list.AddRange(new[] { "foo", "bar" }.Select(x => x)); |
| Assert.AreEqual(2, list.Count); |
| Assert.AreEqual("foo", list[0]); |
| Assert.AreEqual("bar", list[1]); |
| } |
| |
| [Test] |
| public void AddRange_SlowPath_NullsProhibited_ReferenceType() |
| { |
| var list = new RepeatedField<string>(); |
| // It's okay for this to throw ArgumentNullException if necessary. |
| // It's not ideal, but not awful. |
| Assert.Catch<ArgumentException>(() => list.AddRange(new[] { "foo", null }.Select(x => x))); |
| } |
| |
| [Test] |
| public void AddRange_SlowPath_NullsProhibited_NullableValueType() |
| { |
| var list = new RepeatedField<int?>(); |
| // It's okay for this to throw ArgumentNullException if necessary. |
| // It's not ideal, but not awful. |
| Assert.Catch<ArgumentException>(() => list.AddRange(new[] { 20, (int?)null }.Select(x => x))); |
| } |
| |
| [Test] |
| public void AddRange_Optimized_NonNullableValueType() |
| { |
| var list = new RepeatedField<int>(); |
| list.AddRange(new List<int> { 20, 30 }); |
| Assert.AreEqual(2, list.Count); |
| Assert.AreEqual(20, list[0]); |
| Assert.AreEqual(30, list[1]); |
| } |
| |
| [Test] |
| public void AddRange_Optimized_ReferenceType() |
| { |
| var list = new RepeatedField<string>(); |
| list.AddRange(new List<string> { "foo", "bar" }); |
| Assert.AreEqual(2, list.Count); |
| Assert.AreEqual("foo", list[0]); |
| Assert.AreEqual("bar", list[1]); |
| } |
| |
| [Test] |
| public void AddRange_Optimized_NullableValueType() |
| { |
| var list = new RepeatedField<int?>(); |
| list.AddRange(new List<int?> { 20, 30 }); |
| Assert.AreEqual(2, list.Count); |
| Assert.AreEqual((int?) 20, list[0]); |
| Assert.AreEqual((int?) 30, list[1]); |
| } |
| |
| [Test] |
| public void AddRange_Optimized_NullsProhibited_ReferenceType() |
| { |
| // We don't just trust that a collection with a nullable element type doesn't contain nulls |
| var list = new RepeatedField<string>(); |
| // It's okay for this to throw ArgumentNullException if necessary. |
| // It's not ideal, but not awful. |
| Assert.Catch<ArgumentException>(() => list.AddRange(new List<string> { "foo", null })); |
| } |
| |
| [Test] |
| public void AddRange_Optimized_NullsProhibited_NullableValueType() |
| { |
| // We don't just trust that a collection with a nullable element type doesn't contain nulls |
| var list = new RepeatedField<int?>(); |
| // It's okay for this to throw ArgumentNullException if necessary. |
| // It's not ideal, but not awful. |
| Assert.Catch<ArgumentException>(() => list.AddRange(new List<int?> { 20, null })); |
| } |
| |
| [Test] |
| public void AddRange_AlreadyNotEmpty() |
| { |
| var list = new RepeatedField<int> { 1, 2, 3 }; |
| list.AddRange(new List<int> { 4, 5, 6 }); |
| CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5, 6 }, list); |
| } |
| |
| [Test] |
| public void AddRange_RepeatedField() |
| { |
| var list = new RepeatedField<string> { "original" }; |
| list.AddRange(new RepeatedField<string> { "foo", "bar" }); |
| Assert.AreEqual(3, list.Count); |
| Assert.AreEqual("original", list[0]); |
| Assert.AreEqual("foo", list[1]); |
| Assert.AreEqual("bar", list[2]); |
| } |
| |
| [Test] |
| public void RemoveAt_Valid() |
| { |
| var list = new RepeatedField<string> { "first", "second", "third" }; |
| list.RemoveAt(1); |
| CollectionAssert.AreEqual(new[] { "first", "third" }, list); |
| // Just check that these don't throw... |
| list.RemoveAt(list.Count - 1); // Now the count will be 1... |
| list.RemoveAt(0); |
| Assert.AreEqual(0, list.Count); |
| } |
| |
| [Test] |
| public void RemoveAt_Invalid() |
| { |
| var list = new RepeatedField<string> { "first", "second", "third" }; |
| Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(-1)); |
| Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(3)); |
| } |
| |
| [Test] |
| public void Insert_Valid() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| list.Insert(1, "middle"); |
| CollectionAssert.AreEqual(new[] { "first", "middle", "second" }, list); |
| list.Insert(3, "end"); |
| CollectionAssert.AreEqual(new[] { "first", "middle", "second", "end" }, list); |
| list.Insert(0, "start"); |
| CollectionAssert.AreEqual(new[] { "start", "first", "middle", "second", "end" }, list); |
| } |
| |
| [Test] |
| public void Insert_Invalid() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, "foo")); |
| Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(3, "foo")); |
| Assert.Throws<ArgumentNullException>(() => list.Insert(0, null)); |
| } |
| |
| [Test] |
| public void Equals_RepeatedField() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| Assert.IsFalse(list.Equals((RepeatedField<string>) null)); |
| Assert.IsTrue(list.Equals(list)); |
| Assert.IsFalse(list.Equals(new RepeatedField<string> { "first", "third" })); |
| Assert.IsFalse(list.Equals(new RepeatedField<string> { "first" })); |
| Assert.IsTrue(list.Equals(new RepeatedField<string> { "first", "second" })); |
| } |
| |
| [Test] |
| public void Equals_Object() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| Assert.IsFalse(list.Equals((object) null)); |
| Assert.IsTrue(list.Equals((object) list)); |
| Assert.IsFalse(list.Equals((object) new RepeatedField<string> { "first", "third" })); |
| Assert.IsFalse(list.Equals((object) new RepeatedField<string> { "first" })); |
| Assert.IsTrue(list.Equals((object) new RepeatedField<string> { "first", "second" })); |
| Assert.IsFalse(list.Equals(new object())); |
| } |
| |
| [Test] |
| public void GetEnumerator_GenericInterface() |
| { |
| IEnumerable<string> list = new RepeatedField<string> { "first", "second" }; |
| // Select gets rid of the optimizations in ToList... |
| CollectionAssert.AreEqual(new[] { "first", "second" }, list.Select(x => x).ToList()); |
| } |
| |
| [Test] |
| public void GetEnumerator_NonGenericInterface() |
| { |
| IEnumerable list = new RepeatedField<string> { "first", "second" }; |
| CollectionAssert.AreEqual(new[] { "first", "second" }, list.Cast<object>().ToList()); |
| } |
| |
| [Test] |
| public void CopyTo() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| string[] stringArray = new string[4]; |
| list.CopyTo(stringArray, 1); |
| CollectionAssert.AreEqual(new[] { null, "first", "second", null }, stringArray); |
| } |
| |
| [Test] |
| public void Indexer_Get() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| Assert.AreEqual("first", list[0]); |
| Assert.AreEqual("second", list[1]); |
| Assert.Throws<ArgumentOutOfRangeException>(() => list[-1].GetHashCode()); |
| Assert.Throws<ArgumentOutOfRangeException>(() => list[2].GetHashCode()); |
| } |
| |
| [Test] |
| public void Indexer_Set() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| list[0] = "changed"; |
| Assert.AreEqual("changed", list[0]); |
| Assert.Throws<ArgumentNullException>(() => list[0] = null); |
| Assert.Throws<ArgumentOutOfRangeException>(() => list[-1] = "bad"); |
| Assert.Throws<ArgumentOutOfRangeException>(() => list[2] = "bad"); |
| } |
| |
| [Test] |
| public void Clone_ReturnsMutable() |
| { |
| var list = new RepeatedField<int> { 0 }; |
| var clone = list.Clone(); |
| clone[0] = 1; |
| } |
| |
| [Test] |
| public void Enumerator() |
| { |
| var list = new RepeatedField<string> { "first", "second" }; |
| using (var enumerator = list.GetEnumerator()) |
| { |
| Assert.IsTrue(enumerator.MoveNext()); |
| Assert.AreEqual("first", enumerator.Current); |
| Assert.IsTrue(enumerator.MoveNext()); |
| Assert.AreEqual("second", enumerator.Current); |
| Assert.IsFalse(enumerator.MoveNext()); |
| Assert.IsFalse(enumerator.MoveNext()); |
| } |
| } |
| |
| [Test] |
| public void AddEntriesFrom_PackedInt32() |
| { |
| uint packedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| var length = CodedOutputStream.ComputeInt32Size(10) |
| + CodedOutputStream.ComputeInt32Size(999) |
| + CodedOutputStream.ComputeInt32Size(-1000); |
| output.WriteTag(packedTag); |
| output.WriteRawVarint32((uint) length); |
| output.WriteInt32(10); |
| output.WriteInt32(999); |
| output.WriteInt32(-1000); |
| output.Flush(); |
| stream.Position = 0; |
| |
| // Deliberately "expecting" a non-packed tag, but we detect that the data is |
| // actually packed. |
| uint nonPackedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var field = new RepeatedField<int>(); |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(packedTag); |
| field.AddEntriesFrom(input, FieldCodec.ForInt32(nonPackedTag)); |
| CollectionAssert.AreEqual(new[] { 10, 999, -1000 }, field); |
| Assert.IsTrue(input.IsAtEnd); |
| } |
| |
| [Test] |
| public void AddEntriesFrom_NonPackedInt32() |
| { |
| uint nonPackedTag = WireFormat.MakeTag(10, WireFormat.WireType.Varint); |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| output.WriteTag(nonPackedTag); |
| output.WriteInt32(10); |
| output.WriteTag(nonPackedTag); |
| output.WriteInt32(999); |
| output.WriteTag(nonPackedTag); |
| output.WriteInt32(-1000); // Just for variety... |
| output.Flush(); |
| stream.Position = 0; |
| |
| // Deliberately "expecting" a packed tag, but we detect that the data is |
| // actually not packed. |
| uint packedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var field = new RepeatedField<int>(); |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(nonPackedTag); |
| field.AddEntriesFrom(input, FieldCodec.ForInt32(packedTag)); |
| CollectionAssert.AreEqual(new[] { 10, 999, -1000 }, field); |
| Assert.IsTrue(input.IsAtEnd); |
| } |
| |
| [Test] |
| public void AddEntriesFrom_String() |
| { |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| output.WriteTag(tag); |
| output.WriteString("Foo"); |
| output.WriteTag(tag); |
| output.WriteString(""); |
| output.WriteTag(tag); |
| output.WriteString("Bar"); |
| output.Flush(); |
| stream.Position = 0; |
| |
| var field = new RepeatedField<string>(); |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(tag); |
| field.AddEntriesFrom(input, FieldCodec.ForString(tag)); |
| CollectionAssert.AreEqual(new[] { "Foo", "", "Bar" }, field); |
| Assert.IsTrue(input.IsAtEnd); |
| } |
| |
| [Test] |
| public void AddEntriesFrom_Message() |
| { |
| var message1 = new ForeignMessage { C = 2000 }; |
| var message2 = new ForeignMessage { C = -250 }; |
| |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| output.WriteTag(tag); |
| output.WriteMessage(message1); |
| output.WriteTag(tag); |
| output.WriteMessage(message2); |
| output.Flush(); |
| stream.Position = 0; |
| |
| var field = new RepeatedField<ForeignMessage>(); |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(tag); |
| field.AddEntriesFrom(input, FieldCodec.ForMessage(tag, ForeignMessage.Parser)); |
| CollectionAssert.AreEqual(new[] { message1, message2}, field); |
| Assert.IsTrue(input.IsAtEnd); |
| } |
| |
| [Test] |
| public void WriteTo_PackedInt32() |
| { |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var field = new RepeatedField<int> { 10, 1000, 1000000 }; |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| field.WriteTo(output, FieldCodec.ForInt32(tag)); |
| output.Flush(); |
| stream.Position = 0; |
| |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(tag); |
| var length = input.ReadLength(); |
| Assert.AreEqual(10, input.ReadInt32()); |
| Assert.AreEqual(1000, input.ReadInt32()); |
| Assert.AreEqual(1000000, input.ReadInt32()); |
| Assert.IsTrue(input.IsAtEnd); |
| Assert.AreEqual(1 + CodedOutputStream.ComputeLengthSize(length) + length, stream.Length); |
| } |
| |
| [Test] |
| public void WriteTo_NonPackedInt32() |
| { |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.Varint); |
| var field = new RepeatedField<int> { 10, 1000, 1000000}; |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| field.WriteTo(output, FieldCodec.ForInt32(tag)); |
| output.Flush(); |
| stream.Position = 0; |
| |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(tag); |
| Assert.AreEqual(10, input.ReadInt32()); |
| input.AssertNextTag(tag); |
| Assert.AreEqual(1000, input.ReadInt32()); |
| input.AssertNextTag(tag); |
| Assert.AreEqual(1000000, input.ReadInt32()); |
| Assert.IsTrue(input.IsAtEnd); |
| } |
| |
| [Test] |
| public void WriteTo_String() |
| { |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var field = new RepeatedField<string> { "Foo", "", "Bar" }; |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| field.WriteTo(output, FieldCodec.ForString(tag)); |
| output.Flush(); |
| stream.Position = 0; |
| |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(tag); |
| Assert.AreEqual("Foo", input.ReadString()); |
| input.AssertNextTag(tag); |
| Assert.AreEqual("", input.ReadString()); |
| input.AssertNextTag(tag); |
| Assert.AreEqual("Bar", input.ReadString()); |
| Assert.IsTrue(input.IsAtEnd); |
| } |
| |
| [Test] |
| public void WriteTo_Message() |
| { |
| var message1 = new ForeignMessage { C = 20 }; |
| var message2 = new ForeignMessage { C = 25 }; |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var field = new RepeatedField<ForeignMessage> { message1, message2 }; |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| field.WriteTo(output, FieldCodec.ForMessage(tag, ForeignMessage.Parser)); |
| output.Flush(); |
| stream.Position = 0; |
| |
| var input = new CodedInputStream(stream); |
| input.AssertNextTag(tag); |
| Assert.AreEqual(message1, input.ReadMessage(ForeignMessage.Parser)); |
| input.AssertNextTag(tag); |
| Assert.AreEqual(message2, input.ReadMessage(ForeignMessage.Parser)); |
| Assert.IsTrue(input.IsAtEnd); |
| } |
| |
| [Test] |
| public void CalculateSize_VariableSizeNonPacked() |
| { |
| var list = new RepeatedField<int> { 1, 500, 1 }; |
| var tag = WireFormat.MakeTag(1, WireFormat.WireType.Varint); |
| // 2 bytes for the first entry, 3 bytes for the second, 2 bytes for the third |
| Assert.AreEqual(7, list.CalculateSize(FieldCodec.ForInt32(tag))); |
| } |
| |
| [Test] |
| public void CalculateSize_FixedSizeNonPacked() |
| { |
| var list = new RepeatedField<int> { 1, 500, 1 }; |
| var tag = WireFormat.MakeTag(1, WireFormat.WireType.Fixed32); |
| // 5 bytes for the each entry |
| Assert.AreEqual(15, list.CalculateSize(FieldCodec.ForSFixed32(tag))); |
| } |
| |
| [Test] |
| public void CalculateSize_VariableSizePacked() |
| { |
| var list = new RepeatedField<int> { 1, 500, 1}; |
| var tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); |
| // 1 byte for the tag, 1 byte for the length, |
| // 1 byte for the first entry, 2 bytes for the second, 1 byte for the third |
| Assert.AreEqual(6, list.CalculateSize(FieldCodec.ForInt32(tag))); |
| } |
| |
| [Test] |
| public void CalculateSize_FixedSizePacked() |
| { |
| var list = new RepeatedField<int> { 1, 500, 1 }; |
| var tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); |
| // 1 byte for the tag, 1 byte for the length, 4 bytes per entry |
| Assert.AreEqual(14, list.CalculateSize(FieldCodec.ForSFixed32(tag))); |
| } |
| |
| [Test] |
| public void TestNegativeEnumArray() |
| { |
| int arraySize = 1 + 1 + (11 * 5); |
| int msgSize = arraySize; |
| byte[] bytes = new byte[msgSize]; |
| CodedOutputStream output = new CodedOutputStream(bytes); |
| uint tag = WireFormat.MakeTag(8, WireFormat.WireType.Varint); |
| for (int i = 0; i >= -5; i--) |
| { |
| output.WriteTag(tag); |
| output.WriteEnum(i); |
| } |
| |
| Assert.AreEqual(0, output.SpaceLeft); |
| |
| CodedInputStream input = new CodedInputStream(bytes); |
| tag = input.ReadTag(); |
| |
| RepeatedField<SampleEnum> values = new RepeatedField<SampleEnum>(); |
| values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x)); |
| |
| Assert.AreEqual(6, values.Count); |
| Assert.AreEqual(SampleEnum.None, values[0]); |
| Assert.AreEqual(((SampleEnum)(-1)), values[1]); |
| Assert.AreEqual(SampleEnum.NegativeValue, values[2]); |
| Assert.AreEqual(((SampleEnum)(-3)), values[3]); |
| Assert.AreEqual(((SampleEnum)(-4)), values[4]); |
| Assert.AreEqual(((SampleEnum)(-5)), values[5]); |
| } |
| |
| |
| [Test] |
| public void TestNegativeEnumPackedArray() |
| { |
| int arraySize = 1 + (10 * 5); |
| int msgSize = 1 + 1 + arraySize; |
| byte[] bytes = new byte[msgSize]; |
| CodedOutputStream output = new CodedOutputStream(bytes); |
| // Length-delimited to show we want the packed representation |
| uint tag = WireFormat.MakeTag(8, WireFormat.WireType.LengthDelimited); |
| output.WriteTag(tag); |
| int size = 0; |
| for (int i = 0; i >= -5; i--) |
| { |
| size += CodedOutputStream.ComputeEnumSize(i); |
| } |
| output.WriteRawVarint32((uint)size); |
| for (int i = 0; i >= -5; i--) |
| { |
| output.WriteEnum(i); |
| } |
| Assert.AreEqual(0, output.SpaceLeft); |
| |
| CodedInputStream input = new CodedInputStream(bytes); |
| tag = input.ReadTag(); |
| |
| RepeatedField<SampleEnum> values = new RepeatedField<SampleEnum>(); |
| values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x)); |
| |
| Assert.AreEqual(6, values.Count); |
| Assert.AreEqual(SampleEnum.None, values[0]); |
| Assert.AreEqual(((SampleEnum)(-1)), values[1]); |
| Assert.AreEqual(SampleEnum.NegativeValue, values[2]); |
| Assert.AreEqual(((SampleEnum)(-3)), values[3]); |
| Assert.AreEqual(((SampleEnum)(-4)), values[4]); |
| Assert.AreEqual(((SampleEnum)(-5)), values[5]); |
| } |
| |
| [Test] |
| public void TestPackedRepeatedFieldCollectionNonDivisibleLength() |
| { |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var codec = FieldCodec.ForFixed32(tag); |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| output.WriteTag(tag); |
| output.WriteString("A long string"); |
| output.WriteTag(codec.Tag); |
| output.WriteRawVarint32((uint)codec.FixedSize - 1); // Length not divisible by FixedSize |
| output.WriteFixed32(uint.MaxValue); |
| output.Flush(); |
| stream.Position = 0; |
| |
| var input = new CodedInputStream(stream); |
| input.ReadTag(); |
| input.ReadString(); |
| input.ReadTag(); |
| var field = new RepeatedField<uint>(); |
| Assert.Throws<InvalidProtocolBufferException>(() => field.AddEntriesFrom(input, codec)); |
| |
| // Collection was not pre-initialized |
| Assert.AreEqual(0, field.Count); |
| } |
| |
| [Test] |
| public void TestPackedRepeatedFieldCollectionNotAllocatedWhenLengthExceedsBuffer() |
| { |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var codec = FieldCodec.ForFixed32(tag); |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| output.WriteTag(tag); |
| output.WriteString("A long string"); |
| output.WriteTag(codec.Tag); |
| output.WriteRawVarint32((uint)codec.FixedSize); |
| // Note that there is no content for the packed field. |
| // The field length exceeds the remaining length of content. |
| output.Flush(); |
| stream.Position = 0; |
| |
| var input = new CodedInputStream(stream); |
| input.ReadTag(); |
| input.ReadString(); |
| input.ReadTag(); |
| var field = new RepeatedField<uint>(); |
| Assert.Throws<InvalidProtocolBufferException>(() => field.AddEntriesFrom(input, codec)); |
| |
| // Collection was not pre-initialized |
| Assert.AreEqual(0, field.Count); |
| } |
| |
| [Test] |
| public void TestPackedRepeatedFieldCollectionNotAllocatedWhenLengthExceedsRemainingData() |
| { |
| uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); |
| var codec = FieldCodec.ForFixed32(tag); |
| var stream = new MemoryStream(); |
| var output = new CodedOutputStream(stream); |
| output.WriteTag(tag); |
| output.WriteString("A long string"); |
| output.WriteTag(codec.Tag); |
| output.WriteRawVarint32((uint)codec.FixedSize); |
| // Note that there is no content for the packed field. |
| // The field length exceeds the remaining length of the buffer. |
| output.Flush(); |
| stream.Position = 0; |
| |
| var sequence = ReadOnlySequenceFactory.CreateWithContent(stream.ToArray()); |
| ParseContext.Initialize(sequence, out ParseContext ctx); |
| |
| ctx.ReadTag(); |
| ctx.ReadString(); |
| ctx.ReadTag(); |
| var field = new RepeatedField<uint>(); |
| try |
| { |
| field.AddEntriesFrom(ref ctx, codec); |
| Assert.Fail(); |
| } |
| catch (InvalidProtocolBufferException) |
| { |
| } |
| |
| // Collection was not pre-initialized |
| Assert.AreEqual(0, field.Count); |
| } |
| |
| // Fairly perfunctory tests for the non-generic IList implementation |
| [Test] |
| public void IList_Indexer() |
| { |
| var field = new RepeatedField<string> { "first", "second" }; |
| IList list = field; |
| Assert.AreEqual("first", list[0]); |
| list[1] = "changed"; |
| Assert.AreEqual("changed", field[1]); |
| } |
| |
| [Test] |
| public void IList_Contains() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| Assert.IsTrue(list.Contains("second")); |
| Assert.IsFalse(list.Contains("third")); |
| Assert.IsFalse(list.Contains(new object())); |
| } |
| |
| [Test] |
| public void IList_Add() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| list.Add("third"); |
| CollectionAssert.AreEqual(new[] { "first", "second", "third" }, list); |
| } |
| |
| [Test] |
| public void IList_Remove() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| list.Remove("third"); // No-op, no exception |
| list.Remove(new object()); // No-op, no exception |
| list.Remove("first"); |
| CollectionAssert.AreEqual(new[] { "second" }, list); |
| } |
| |
| [Test] |
| public void IList_IsFixedSize() |
| { |
| var field = new RepeatedField<string> { "first", "second" }; |
| IList list = field; |
| Assert.IsFalse(list.IsFixedSize); |
| } |
| |
| [Test] |
| public void IList_IndexOf() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| Assert.AreEqual(1, list.IndexOf("second")); |
| Assert.AreEqual(-1, list.IndexOf("third")); |
| Assert.AreEqual(-1, list.IndexOf(new object())); |
| } |
| |
| [Test] |
| public void IList_SyncRoot() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| Assert.AreSame(list, list.SyncRoot); |
| } |
| |
| [Test] |
| public void IList_CopyTo() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| string[] stringArray = new string[4]; |
| list.CopyTo(stringArray, 1); |
| CollectionAssert.AreEqual(new[] { null, "first", "second", null }, stringArray); |
| |
| object[] objectArray = new object[4]; |
| list.CopyTo(objectArray, 1); |
| CollectionAssert.AreEqual(new[] { null, "first", "second", null }, objectArray); |
| |
| Assert.Throws<ArrayTypeMismatchException>(() => list.CopyTo(new StringBuilder[4], 1)); |
| Assert.Throws<ArrayTypeMismatchException>(() => list.CopyTo(new int[4], 1)); |
| } |
| |
| [Test] |
| public void IList_IsSynchronized() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| Assert.IsFalse(list.IsSynchronized); |
| } |
| |
| [Test] |
| public void IList_Insert() |
| { |
| IList list = new RepeatedField<string> { "first", "second" }; |
| list.Insert(1, "middle"); |
| CollectionAssert.AreEqual(new[] { "first", "middle", "second" }, list); |
| } |
| |
| [Test] |
| public void ToString_Integers() |
| { |
| var list = new RepeatedField<int> { 5, 10, 20 }; |
| var text = list.ToString(); |
| Assert.AreEqual("[ 5, 10, 20 ]", text); |
| } |
| |
| [Test] |
| public void ToString_Strings() |
| { |
| var list = new RepeatedField<string> { "x", "y", "z" }; |
| var text = list.ToString(); |
| Assert.AreEqual("[ \"x\", \"y\", \"z\" ]", text); |
| } |
| |
| [Test] |
| public void ToString_Messages() |
| { |
| var list = new RepeatedField<TestAllTypes> { new TestAllTypes { SingleDouble = 1.5 }, new TestAllTypes { SingleInt32 = 10 } }; |
| var text = list.ToString(); |
| Assert.AreEqual("[ { \"singleDouble\": 1.5 }, { \"singleInt32\": 10 } ]", text); |
| } |
| |
| [Test] |
| public void ToString_Empty() |
| { |
| var list = new RepeatedField<TestAllTypes> { }; |
| var text = list.ToString(); |
| Assert.AreEqual("[ ]", text); |
| } |
| |
| [Test] |
| public void ToString_InvalidElementType() |
| { |
| var list = new RepeatedField<decimal> { 15m }; |
| Assert.Throws<ArgumentException>(() => list.ToString()); |
| } |
| |
| [Test] |
| public void ToString_Timestamp() |
| { |
| var list = new RepeatedField<Timestamp> { Timestamp.FromDateTime(new DateTime(2015, 10, 1, 12, 34, 56, DateTimeKind.Utc)) }; |
| var text = list.ToString(); |
| Assert.AreEqual("[ \"2015-10-01T12:34:56Z\" ]", text); |
| } |
| |
| [Test] |
| public void ToString_Struct() |
| { |
| var message = new Struct { Fields = { { "foo", new Value { NumberValue = 20 } } } }; |
| var list = new RepeatedField<Struct> { message }; |
| var text = list.ToString(); |
| Assert.AreEqual(text, "[ { \"foo\": 20 } ]", message.ToString()); |
| } |
| |
| [Test] |
| public void NaNValuesComparedBitwise() |
| { |
| var list1 = new RepeatedField<double> { SampleNaNs.Regular, SampleNaNs.SignallingFlipped }; |
| var list2 = new RepeatedField<double> { SampleNaNs.Regular, SampleNaNs.PayloadFlipped }; |
| var list3 = new RepeatedField<double> { SampleNaNs.Regular, SampleNaNs.SignallingFlipped }; |
| |
| // All SampleNaNs have the same hashcode under certain targets (e.g. netcoreapp2.1) |
| EqualityTester.AssertInequality(list1, list2, checkHashcode: false); |
| EqualityTester.AssertEquality(list1, list3); |
| Assert.True(list1.Contains(SampleNaNs.SignallingFlipped)); |
| Assert.False(list2.Contains(SampleNaNs.SignallingFlipped)); |
| } |
| |
| [Test] |
| public void Capacity_Increase() |
| { |
| // Unfortunately this case tests implementation details of RepeatedField. This is necessary |
| |
| var list = new RepeatedField<int>() { 1, 2, 3 }; |
| |
| Assert.AreEqual(8, list.Capacity); |
| Assert.AreEqual(3, list.Count); |
| |
| list.Capacity = 10; // Set capacity to a larger value to trigger growth |
| Assert.AreEqual(10, list.Capacity, "Capacity increased"); |
| Assert.AreEqual(3, list.Count); |
| |
| CollectionAssert.AreEqual(new int[] {1, 2, 3}, list.ToArray(), "We didn't lose our data in the resize"); |
| } |
| |
| [Test] |
| public void Capacity_Decrease() |
| { |
| var list = new RepeatedField<int>() { 1, 2, 3 }; |
| |
| Assert.AreEqual(8, list.Capacity); |
| Assert.DoesNotThrow(() => list.Capacity = 5, "Can decrease capacity if new capacity is greater than list.Count"); |
| Assert.AreEqual(5, list.Capacity); |
| |
| Assert.DoesNotThrow(() => list.Capacity = 3, "Can set capacity exactly to list.Count" ); |
| |
| Assert.Throws<ArgumentOutOfRangeException>(() => list.Capacity = 2, "Can't set the capacity smaller than list.Count" ); |
| |
| Assert.Throws<ArgumentOutOfRangeException>(() => list.Capacity = 0, "Can't set the capacity to zero" ); |
| |
| Assert.Throws<ArgumentOutOfRangeException>(() => list.Capacity = -1, "Can't set the capacity to negative" ); |
| } |
| |
| [Test] |
| public void Capacity_Zero() |
| { |
| var list = new RepeatedField<int>() { 1 }; |
| list.RemoveAt(0); |
| Assert.AreEqual(0, list.Count); |
| Assert.AreEqual(8, list.Capacity); |
| |
| Assert.DoesNotThrow(() => list.Capacity = 0, "Can set Capacity to 0"); |
| Assert.AreEqual(0, list.Capacity); |
| } |
| } |
| } |
