csharp/src/Google.Protobuf.Test/Collections/RepeatedFieldTest.cs - third_party/protobuf - Git at Google

 #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.IO;
 using System.Linq;
 using System.Text;
 using Google.Protobuf.TestProtos;
 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 Add_RepeatedField()
         {
             var list = new RepeatedField<string> { "original" };
             list.Add(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]);
         }

         // 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);
         }
     }
 }
	#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.IO;
	using System.Linq;
	using System.Text;
	using Google.Protobuf.TestProtos;
	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 Add_RepeatedField()
	{
	var list = new RepeatedField<string> { "original" };
	list.Add(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]);
	}

	// 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);
	}
	}
	}