csharp/src/Google.Protobuf.Test/Collections/MapFieldTest.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.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 #endregion

 using System;
 using System.IO;
 using System.Collections.Generic;
 using Google.Protobuf.TestProtos;
 using NUnit.Framework;
 using System.Collections;
 using System.Linq;

 namespace Google.Protobuf.Collections
 {
     /// <summary>
     /// Tests for MapField which aren't reliant on the encoded format -
     /// tests for serialization/deserialization are part of GeneratedMessageTest.
     /// </summary>
     public class MapFieldTest
     {
         [Test]
         public void Clone_ClonesMessages()
         {
             var message = new ForeignMessage { C = 20 };
             var map = new MapField<string, ForeignMessage> { { "x", message } };
             var clone = map.Clone();
             map["x"].C = 30;
             Assert.AreEqual(20, clone["x"].C);
         }

         [Test]
         public void NullValuesProhibited()
         {
             TestNullValues<int?>(0);
             TestNullValues("");
             TestNullValues(new TestAllTypes());
         }

         private void TestNullValues<T>(T nonNullValue)
         {
             var map = new MapField<int, T>();
             var nullValue = (T) (object) null;
             Assert.Throws<ArgumentNullException>(() => map.Add(0, nullValue));
             Assert.Throws<ArgumentNullException>(() => map[0] = nullValue);
             map.Add(1, nonNullValue);
             map[1] = nonNullValue;
         }

         [Test]
         public void Add_ForbidsNullKeys()
         {
             var map = new MapField<string, ForeignMessage>();
             Assert.Throws<ArgumentNullException>(() => map.Add(null, new ForeignMessage()));
         }

         [Test]
         public void Indexer_ForbidsNullKeys()
         {
             var map = new MapField<string, ForeignMessage>();
             Assert.Throws<ArgumentNullException>(() => map[null] = new ForeignMessage());
         }

         [Test]
         public void AddPreservesInsertionOrder()
         {
             var map = new MapField<string, string>
             {
                 { "a", "v1" },
                 { "b", "v2" },
                 { "c", "v3" }
             };
             map.Remove("b");
             map.Add("d", "v4");
             CollectionAssert.AreEqual(new[] { "a", "c", "d" }, map.Keys);
             CollectionAssert.AreEqual(new[] { "v1", "v3", "v4" }, map.Values);
         }

         [Test]
         public void EqualityIsOrderInsensitive()
         {
             var map1 = new MapField<string, string>
             {
                 { "a", "v1" },
                 { "b", "v2" }
             };

             var map2 = new MapField<string, string>
             {
                 { "b", "v2" },
                 { "a", "v1" }
             };

             EqualityTester.AssertEquality(map1, map2);
         }

         [Test]
         public void EqualityIsKeySensitive()
         {
             var map1 = new MapField<string, string>
             {
                 { "first key", "v1" },
                 { "second key", "v2" }
             };

             var map2 = new MapField<string, string>
             {
                 { "third key", "v1" },
                 { "fourth key", "v2" }
             };

             EqualityTester.AssertInequality(map1, map2);
         }

         [Test]
         public void Equality_Simple()
         {
             var map = new MapField<string, string>();
             EqualityTester.AssertEquality(map, map);
             EqualityTester.AssertInequality(map, null);
             Assert.IsFalse(map.Equals(new object()));
         }

         [Test]
         public void EqualityIsValueSensitive()
         {
             // Note: Without some care, it's a little easier than one might
             // hope to see hash collisions, but only in some environments...
             var map1 = new MapField<string, string>
             {
                 { "a", "first value" },
                 { "b", "second value" }
             };

             var map2 = new MapField<string, string>
             {
                 { "a", "third value" },
                 { "b", "fourth value" }
             };

             EqualityTester.AssertInequality(map1, map2);
         }

         [Test]
         public void Add_Dictionary()
         {
             var map1 = new MapField<string, string>
             {
                 { "x", "y" },
                 { "a", "b" }
             };
             var map2 = new MapField<string, string>
             {
                 { "before", "" },
                 map1,
                 { "after", "" }
             };
             var expected = new MapField<string, string>
             {
                 { "before", "" },
                 { "x", "y" },
                 { "a", "b" },
                 { "after", "" }
             };
             Assert.AreEqual(expected, map2);
             CollectionAssert.AreEqual(new[] { "before", "x", "a", "after" }, map2.Keys);
         }

         // General IDictionary<TKey, TValue> behavior tests
         [Test]
         public void Add_KeyAlreadyExists()
         {
             var map = new MapField<string, string> { { "foo", "bar" } };
             Assert.Throws<ArgumentException>(() => map.Add("foo", "baz"));
         }

         [Test]
         public void Add_Pair()
         {
             var map = new MapField<string, string>();
             ICollection<KeyValuePair<string, string>> collection = map;
             collection.Add(NewKeyValuePair("x", "y"));
             Assert.AreEqual("y", map["x"]);
             Assert.Throws<ArgumentException>(() => collection.Add(NewKeyValuePair("x", "z")));
         }

         [Test]
         public void Contains_Pair()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             ICollection<KeyValuePair<string, string>> collection = map;
             Assert.IsTrue(collection.Contains(NewKeyValuePair("x", "y")));
             Assert.IsFalse(collection.Contains(NewKeyValuePair("x", "z")));
             Assert.IsFalse(collection.Contains(NewKeyValuePair("z", "y")));
         }

         [Test]
         public void Remove_Key()
         {
             var map = new MapField<string, string> { { "foo", "bar" } };
             Assert.AreEqual(1, map.Count);
             Assert.IsFalse(map.Remove("missing"));
             Assert.AreEqual(1, map.Count);
             Assert.IsTrue(map.Remove("foo"));
             Assert.AreEqual(0, map.Count);
             Assert.Throws<ArgumentNullException>(() => map.Remove(null));
         }

         [Test]
         public void Remove_Pair()
         {
             var map = new MapField<string, string> { { "foo", "bar" } };
             ICollection<KeyValuePair<string, string>> collection = map;
             Assert.AreEqual(1, map.Count);
             Assert.IsFalse(collection.Remove(NewKeyValuePair("wrong key", "bar")));
             Assert.AreEqual(1, map.Count);
             Assert.IsFalse(collection.Remove(NewKeyValuePair("foo", "wrong value")));
             Assert.AreEqual(1, map.Count);
             Assert.IsTrue(collection.Remove(NewKeyValuePair("foo", "bar")));
             Assert.AreEqual(0, map.Count);
             Assert.Throws<ArgumentException>(() => collection.Remove(new KeyValuePair<string, string>(null, "")));
         }

         [Test]
         public void CopyTo_Pair()
         {
             var map = new MapField<string, string> { { "foo", "bar" } };
             ICollection<KeyValuePair<string, string>> collection = map;
             KeyValuePair<string, string>[] array = new KeyValuePair<string, string>[3];
             collection.CopyTo(array, 1);
             Assert.AreEqual(NewKeyValuePair("foo", "bar"), array[1]);
         }

         [Test]
         public void Clear()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             Assert.AreEqual(1, map.Count);
             map.Clear();
             Assert.AreEqual(0, map.Count);
             map.Add("x", "y");
             Assert.AreEqual(1, map.Count);
         }

         [Test]
         public void Indexer_Get()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             Assert.AreEqual("y", map["x"]);
             Assert.Throws<KeyNotFoundException>(() => { var ignored = map["z"]; });
         }

         [Test]
         public void Indexer_Set()
         {
             var map = new MapField<string, string> { ["x"] = "y" };
             Assert.AreEqual("y", map["x"]);
             map["x"] = "z"; // This won't throw, unlike Add.
             Assert.AreEqual("z", map["x"]);
         }

         [Test]
         public void GetEnumerator_NonGeneric()
         {
             IEnumerable map = new MapField<string, string> { { "x", "y" } };
             CollectionAssert.AreEqual(new[] { new KeyValuePair<string, string>("x", "y") },
                 map.Cast<object>().ToList());
         }

         // Test for the explicitly-implemented non-generic IDictionary interface
         [Test]
         public void IDictionary_GetEnumerator()
         {
             IDictionary map = new MapField<string, string> { { "x", "y" } };
             var enumerator = map.GetEnumerator();

             // Commented assertions show an ideal situation - it looks like
             // the LinkedList enumerator doesn't throw when you ask for the current entry
             // at an inappropriate time; fixing this would be more work than it's worth.
             // Assert.Throws<InvalidOperationException>(() => enumerator.Current.GetHashCode());
             Assert.IsTrue(enumerator.MoveNext());
             Assert.AreEqual("x", enumerator.Key);
             Assert.AreEqual("y", enumerator.Value);
             Assert.AreEqual(new DictionaryEntry("x", "y"), enumerator.Current);
             Assert.AreEqual(new DictionaryEntry("x", "y"), enumerator.Entry);
             Assert.IsFalse(enumerator.MoveNext());
             // Assert.Throws<InvalidOperationException>(() => enumerator.Current.GetHashCode());
             enumerator.Reset();
             // Assert.Throws<InvalidOperationException>(() => enumerator.Current.GetHashCode());
             Assert.IsTrue(enumerator.MoveNext());
             Assert.AreEqual("x", enumerator.Key); // Assume the rest are okay
         }

         [Test]
         public void IDictionary_Add()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             IDictionary dictionary = map;
             dictionary.Add("a", "b");
             Assert.AreEqual("b", map["a"]);
             Assert.Throws<ArgumentException>(() => dictionary.Add("a", "duplicate"));
             Assert.Throws<InvalidCastException>(() => dictionary.Add(new object(), "key is bad"));
             Assert.Throws<InvalidCastException>(() => dictionary.Add("value is bad", new object()));
         }

         [Test]
         public void IDictionary_Contains()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             IDictionary dictionary = map;

             Assert.IsFalse(dictionary.Contains("a"));
             Assert.IsFalse(dictionary.Contains(5));
             // Surprising, but IDictionary.Contains is only about keys.
             Assert.IsFalse(dictionary.Contains(new DictionaryEntry("x", "y")));
             Assert.IsTrue(dictionary.Contains("x"));
         }

         [Test]
         public void IDictionary_Remove()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             IDictionary dictionary = map;
             dictionary.Remove("a");
             Assert.AreEqual(1, dictionary.Count);
             dictionary.Remove(5);
             Assert.AreEqual(1, dictionary.Count);
             dictionary.Remove(new DictionaryEntry("x", "y"));
             Assert.AreEqual(1, dictionary.Count);
             dictionary.Remove("x");
             Assert.AreEqual(0, dictionary.Count);
             Assert.Throws<ArgumentNullException>(() => dictionary.Remove(null));
         }

         [Test]
         public void IDictionary_CopyTo()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             IDictionary dictionary = map;
             var array = new DictionaryEntry[3];
             dictionary.CopyTo(array, 1);
             CollectionAssert.AreEqual(new[] { default, new DictionaryEntry("x", "y"), default }, array);
             var objectArray = new object[3];
             dictionary.CopyTo(objectArray, 1);
             CollectionAssert.AreEqual(new object[] { null, new DictionaryEntry("x", "y"), null }, objectArray);
         }

         [Test]
         public void IDictionary_IsFixedSize()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             IDictionary dictionary = map;
             Assert.IsFalse(dictionary.IsFixedSize);
         }

         [Test]
         public void IDictionary_Keys()
         {
             IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
             CollectionAssert.AreEqual(new[] { "x" }, dictionary.Keys);
         }

         [Test]
         public void IDictionary_Values()
         {
             IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
             CollectionAssert.AreEqual(new[] { "y" }, dictionary.Values);
         }

         [Test]
         public void IDictionary_IsSynchronized()
         {
             IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
             Assert.IsFalse(dictionary.IsSynchronized);
         }

         [Test]
         public void IDictionary_SyncRoot()
         {
             IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
             Assert.AreSame(dictionary, dictionary.SyncRoot);
         }

         [Test]
         public void IDictionary_Indexer_Get()
         {
             IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
             Assert.AreEqual("y", dictionary["x"]);
             Assert.IsNull(dictionary["a"]);
             Assert.IsNull(dictionary[5]);
             Assert.Throws<ArgumentNullException>(() => dictionary[null].GetHashCode());
         }

         [Test]
         public void IDictionary_Indexer_Set()
         {
             var map = new MapField<string, string> { { "x", "y" } };
             IDictionary dictionary = map;
             map["a"] = "b";
             Assert.AreEqual("b", map["a"]);
             map["a"] = "c";
             Assert.AreEqual("c", map["a"]);
             Assert.Throws<InvalidCastException>(() => dictionary[5] = "x");
             Assert.Throws<InvalidCastException>(() => dictionary["x"] = 5);
             Assert.Throws<ArgumentNullException>(() => dictionary[null] = "z");
             Assert.Throws<ArgumentNullException>(() => dictionary["x"] = null);
         }

         [Test]
         public void KeysReturnsLiveView()
         {
             var map = new MapField<string, string>();
             var keys = map.Keys;
             CollectionAssert.AreEqual(new string[0], keys);
             map["foo"] = "bar";
             map["x"] = "y";
             CollectionAssert.AreEqual(new[] { "foo", "x" }, keys);
         }

         [Test]
         public void ValuesReturnsLiveView()
         {
             var map = new MapField<string, string>();
             var values = map.Values;
             CollectionAssert.AreEqual(new string[0], values);
             map["foo"] = "bar";
             map["x"] = "y";
             CollectionAssert.AreEqual(new[] { "bar", "y" }, values);
         }

         // Just test keys - we know the implementation is the same for values
         [Test]
         public void ViewsAreReadOnly()
         {
             var map = new MapField<string, string>();
             var keys = map.Keys;
             Assert.IsTrue(keys.IsReadOnly);
             Assert.Throws<NotSupportedException>(() => keys.Clear());
             Assert.Throws<NotSupportedException>(() => keys.Remove("a"));
             Assert.Throws<NotSupportedException>(() => keys.Add("a"));
         }

         // Just test keys - we know the implementation is the same for values
         [Test]
         public void ViewCopyTo()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             var keys = map.Keys;
             var array = new string[4];
             Assert.Throws<ArgumentException>(() => keys.CopyTo(array, 3));
             Assert.Throws<ArgumentOutOfRangeException>(() => keys.CopyTo(array, -1));
             keys.CopyTo(array, 1);
             CollectionAssert.AreEqual(new[] { null, "foo", "x", null }, array);
         }

         // Just test keys - we know the implementation is the same for values
         [Test]
         public void NonGenericViewCopyTo()
         {
             IDictionary map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             ICollection keys = map.Keys;
             // Note the use of the Array type here rather than string[]
             Array array = new string[4];
             Assert.Throws<ArgumentException>(() => keys.CopyTo(array, 3));
             Assert.Throws<ArgumentOutOfRangeException>(() => keys.CopyTo(array, -1));
             keys.CopyTo(array, 1);
             CollectionAssert.AreEqual(new[] { null, "foo", "x", null }, array);
         }

         [Test]
         public void KeysContains()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             var keys = map.Keys;
             Assert.IsTrue(keys.Contains("foo"));
             Assert.IsFalse(keys.Contains("bar")); // It's a value!
             Assert.IsFalse(keys.Contains("1"));
             // Keys can't be null, so we should prevent contains check
             Assert.Throws<ArgumentNullException>(() => keys.Contains(null));
         }

         [Test]
         public void KeysCopyTo()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             var keys = map.Keys.ToArray(); // Uses CopyTo internally
             CollectionAssert.AreEquivalent(new[] { "foo", "x" }, keys);
         }

         [Test]
         public void ValuesContains()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             var values = map.Values;
             Assert.IsTrue(values.Contains("bar"));
             Assert.IsFalse(values.Contains("foo")); // It's a key!
             Assert.IsFalse(values.Contains("1"));
             // Values can be null, so this makes sense
             Assert.IsFalse(values.Contains(null));
         }

         [Test]
         public void ValuesCopyTo()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             var values = map.Values.ToArray(); // Uses CopyTo internally
             CollectionAssert.AreEquivalent(new[] { "bar", "y" }, values);
         }

         [Test]
         public void ToString_StringToString()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             Assert.AreEqual("{ \"foo\": \"bar\", \"x\": \"y\" }", map.ToString());
         }

         [Test]
         public void ToString_UnsupportedKeyType()
         {
             var map = new MapField<byte, string> { { 10, "foo" } };
             Assert.Throws<ArgumentException>(() => map.ToString());
         }

         [Test]
         public void NaNValuesComparedBitwise()
         {
             var map1 = new MapField<string, double>
             {
                 { "x", SampleNaNs.Regular },
                 { "y", SampleNaNs.SignallingFlipped }
             };

             var map2 = new MapField<string, double>
             {
                 { "x", SampleNaNs.Regular },
                 { "y", SampleNaNs.PayloadFlipped }
             };

             var map3 = new MapField<string, double>
             {
                 { "x", SampleNaNs.Regular },
                 { "y", SampleNaNs.SignallingFlipped }
             };

             EqualityTester.AssertInequality(map1, map2);
             EqualityTester.AssertEquality(map1, map3);
             Assert.True(map1.Values.Contains(SampleNaNs.SignallingFlipped));
             Assert.False(map2.Values.Contains(SampleNaNs.SignallingFlipped));
         }

         // This wouldn't usually happen, as protos can't use doubles as map keys,
         // but let's be consistent.
         [Test]
         public void NaNKeysComparedBitwise()
         {
             var map = new MapField<double, string>
             {
                 { SampleNaNs.Regular, "x" },
                 { SampleNaNs.SignallingFlipped, "y" }
             };
             Assert.AreEqual("x", map[SampleNaNs.Regular]);
             Assert.AreEqual("y", map[SampleNaNs.SignallingFlipped]);
             Assert.False(map.TryGetValue(SampleNaNs.PayloadFlipped, out _));
         }

         [Test]
         public void AddEntriesFrom_CodedInputStream()
         {
             // map will have string key and string value
             var keyTag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited);
             var valueTag = WireFormat.MakeTag(2, WireFormat.WireType.LengthDelimited);

             var memoryStream = new MemoryStream();
             var output = new CodedOutputStream(memoryStream);
             output.WriteLength(20);  // total of keyTag + key + valueTag + value
             output.WriteTag(keyTag);
             output.WriteString("the_key");
             output.WriteTag(valueTag);
             output.WriteString("the_value");
             output.Flush();

             var field = new MapField<string,string>();
             var mapCodec = new MapField<string,string>.Codec(FieldCodec.ForString(keyTag, ""), FieldCodec.ForString(valueTag, ""), 10);
             var input = new CodedInputStream(memoryStream.ToArray());

             // test the legacy overload of AddEntriesFrom that takes a CodedInputStream
             field.AddEntriesFrom(input, mapCodec);
             CollectionAssert.AreEquivalent(new[] { "the_key" }, field.Keys);
             CollectionAssert.AreEquivalent(new[] { "the_value" }, field.Values);
             Assert.IsTrue(input.IsAtEnd);
         }

         [Test]
         public void AddEntriesFrom_CodedInputStream_MissingKey()
         {
             // map will have string key and string value
             var keyTag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited);
             var valueTag = WireFormat.MakeTag(2, WireFormat.WireType.LengthDelimited);

             var memoryStream = new MemoryStream();
             var output = new CodedOutputStream(memoryStream);
             output.WriteLength(11);  // total of valueTag + value
             output.WriteTag(valueTag);
             output.WriteString("the_value");
             output.Flush();

             var field = new MapField<string, string>();
             var mapCodec = new MapField<string, string>.Codec(FieldCodec.ForString(keyTag, ""), FieldCodec.ForString(valueTag, ""), 10);
             var input = new CodedInputStream(memoryStream.ToArray());

             field.AddEntriesFrom(input, mapCodec);
             CollectionAssert.AreEquivalent(new[] { "" }, field.Keys);
             CollectionAssert.AreEquivalent(new[] { "the_value" }, field.Values);
             Assert.IsTrue(input.IsAtEnd);
         }

         [Test]
         public void IDictionaryKeys_Equals_IReadOnlyDictionaryKeys()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             CollectionAssert.AreEquivalent(((IDictionary<string, string>)map).Keys, ((IReadOnlyDictionary<string, string>)map).Keys);
         }

         [Test]
         public void IDictionaryValues_Equals_IReadOnlyDictionaryValues()
         {
             var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
             CollectionAssert.AreEquivalent(((IDictionary<string, string>)map).Values, ((IReadOnlyDictionary<string, string>)map).Values);
         }

         [Test]
         public void SortIntKeys_RandomOrder()
         {
             var map = new MapField<int, string>() { { 1, "val" }, { -1, "val"}, { 0, "val" } };
             var sortedList = map.GetSortedListCopy(map.ToList()).ToList();
             var sortedKeys = sortedList.Select(kvp => kvp.Key);
             CollectionAssert.AreEqual(new[] { -1, 0, 1 }, sortedKeys);
         }

         [Test]
         public void SortIntKeys_Empty()
         {
             var map = new MapField<int, string> { };
             var sortedList = map.GetSortedListCopy(map.ToList()).ToList();
             var sortedKeys = sortedList.Select(kvp => kvp.Key);
             Assert.IsEmpty(sortedKeys);
         }

         [Test]
         public void SortStringKeys_RandomOrder()
         {
             var map = new MapField<string, string> { { "a", "val" }, { "c", "val" }, { "b", "val" } };
             var sortedList = map.GetSortedListCopy(map.ToList()).ToList();
             var sortedKeys = sortedList.Select(kvp => kvp.Key);
             CollectionAssert.AreEqual(new[] { "a", "b", "c" }, sortedKeys);
         }

         [Test]
         public void SortStringKeys_EnsureOrdinalSort()
         {
             var map = new MapField<string, string>
             {
                 { "i", "val" } , { "I", "val" }, { "ı", "val" }, { "İ", "val" }
             };
             var sortedList = map.GetSortedListCopy(map.ToList());
             var sortedKeys = sortedList.Select(kvp => kvp.Key);
             // Assert Ordinal sort  I, i, ı, İ (Non-ordinal sort returns i, I, İ, ı)
             // I == 0x49 , i == 0x69 , İ == 0x130 , ı == 0x131
             CollectionAssert.AreEqual(new[] { "I", "i", "İ", "ı" }, sortedKeys);
         }

         [Test]
         public void SortBoolKeys()
         {
             var map = new MapField<bool, string>
             {
                 { true, "val" } , { false, "val" }
             };
             var sortedList = map.GetSortedListCopy(map.ToList());
             var sortedKeys = sortedList.Select(kvp => kvp.Key);
             CollectionAssert.AreEqual(new[] { false, true }, sortedKeys);
         }

         private static KeyValuePair<TKey, TValue> NewKeyValuePair<TKey, TValue>(TKey key, TValue value)
         {
             return new KeyValuePair<TKey, TValue>(key, value);
         }
     }
 }
	#region Copyright notice and license
	// Protocol Buffers - Google's data interchange format
	// Copyright 2015 Google Inc. All rights reserved.
	//
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file or at
	// https://developers.google.com/open-source/licenses/bsd
	#endregion

	using System;
	using System.IO;
	using System.Collections.Generic;
	using Google.Protobuf.TestProtos;
	using NUnit.Framework;
	using System.Collections;
	using System.Linq;

	namespace Google.Protobuf.Collections
	{
	/// <summary>
	/// Tests for MapField which aren't reliant on the encoded format -
	/// tests for serialization/deserialization are part of GeneratedMessageTest.
	/// </summary>
	public class MapFieldTest
	{
	[Test]
	public void Clone_ClonesMessages()
	{
	var message = new ForeignMessage { C = 20 };
	var map = new MapField<string, ForeignMessage> { { "x", message } };
	var clone = map.Clone();
	map["x"].C = 30;
	Assert.AreEqual(20, clone["x"].C);
	}

	[Test]
	public void NullValuesProhibited()
	{
	TestNullValues<int?>(0);
	TestNullValues("");
	TestNullValues(new TestAllTypes());
	}

	private void TestNullValues<T>(T nonNullValue)
	{
	var map = new MapField<int, T>();
	var nullValue = (T) (object) null;
	Assert.Throws<ArgumentNullException>(() => map.Add(0, nullValue));
	Assert.Throws<ArgumentNullException>(() => map[0] = nullValue);
	map.Add(1, nonNullValue);
	map[1] = nonNullValue;
	}

	[Test]
	public void Add_ForbidsNullKeys()
	{
	var map = new MapField<string, ForeignMessage>();
	Assert.Throws<ArgumentNullException>(() => map.Add(null, new ForeignMessage()));
	}

	[Test]
	public void Indexer_ForbidsNullKeys()
	{
	var map = new MapField<string, ForeignMessage>();
	Assert.Throws<ArgumentNullException>(() => map[null] = new ForeignMessage());
	}

	[Test]
	public void AddPreservesInsertionOrder()
	{
	var map = new MapField<string, string>
	{
	{ "a", "v1" },
	{ "b", "v2" },
	{ "c", "v3" }
	};
	map.Remove("b");
	map.Add("d", "v4");
	CollectionAssert.AreEqual(new[] { "a", "c", "d" }, map.Keys);
	CollectionAssert.AreEqual(new[] { "v1", "v3", "v4" }, map.Values);
	}

	[Test]
	public void EqualityIsOrderInsensitive()
	{
	var map1 = new MapField<string, string>
	{
	{ "a", "v1" },
	{ "b", "v2" }
	};

	var map2 = new MapField<string, string>
	{
	{ "b", "v2" },
	{ "a", "v1" }
	};

	EqualityTester.AssertEquality(map1, map2);
	}

	[Test]
	public void EqualityIsKeySensitive()
	{
	var map1 = new MapField<string, string>
	{
	{ "first key", "v1" },
	{ "second key", "v2" }
	};

	var map2 = new MapField<string, string>
	{
	{ "third key", "v1" },
	{ "fourth key", "v2" }
	};

	EqualityTester.AssertInequality(map1, map2);
	}

	[Test]
	public void Equality_Simple()
	{
	var map = new MapField<string, string>();
	EqualityTester.AssertEquality(map, map);
	EqualityTester.AssertInequality(map, null);
	Assert.IsFalse(map.Equals(new object()));
	}

	[Test]
	public void EqualityIsValueSensitive()
	{
	// Note: Without some care, it's a little easier than one might
	// hope to see hash collisions, but only in some environments...
	var map1 = new MapField<string, string>
	{
	{ "a", "first value" },
	{ "b", "second value" }
	};

	var map2 = new MapField<string, string>
	{
	{ "a", "third value" },
	{ "b", "fourth value" }
	};

	EqualityTester.AssertInequality(map1, map2);
	}

	[Test]
	public void Add_Dictionary()
	{
	var map1 = new MapField<string, string>
	{
	{ "x", "y" },
	{ "a", "b" }
	};
	var map2 = new MapField<string, string>
	{
	{ "before", "" },
	map1,
	{ "after", "" }
	};
	var expected = new MapField<string, string>
	{
	{ "before", "" },
	{ "x", "y" },
	{ "a", "b" },
	{ "after", "" }
	};
	Assert.AreEqual(expected, map2);
	CollectionAssert.AreEqual(new[] { "before", "x", "a", "after" }, map2.Keys);
	}

	// General IDictionary<TKey, TValue> behavior tests
	[Test]
	public void Add_KeyAlreadyExists()
	{
	var map = new MapField<string, string> { { "foo", "bar" } };
	Assert.Throws<ArgumentException>(() => map.Add("foo", "baz"));
	}

	[Test]
	public void Add_Pair()
	{
	var map = new MapField<string, string>();
	ICollection<KeyValuePair<string, string>> collection = map;
	collection.Add(NewKeyValuePair("x", "y"));
	Assert.AreEqual("y", map["x"]);
	Assert.Throws<ArgumentException>(() => collection.Add(NewKeyValuePair("x", "z")));
	}

	[Test]
	public void Contains_Pair()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	ICollection<KeyValuePair<string, string>> collection = map;
	Assert.IsTrue(collection.Contains(NewKeyValuePair("x", "y")));
	Assert.IsFalse(collection.Contains(NewKeyValuePair("x", "z")));
	Assert.IsFalse(collection.Contains(NewKeyValuePair("z", "y")));
	}

	[Test]
	public void Remove_Key()
	{
	var map = new MapField<string, string> { { "foo", "bar" } };
	Assert.AreEqual(1, map.Count);
	Assert.IsFalse(map.Remove("missing"));
	Assert.AreEqual(1, map.Count);
	Assert.IsTrue(map.Remove("foo"));
	Assert.AreEqual(0, map.Count);
	Assert.Throws<ArgumentNullException>(() => map.Remove(null));
	}

	[Test]
	public void Remove_Pair()
	{
	var map = new MapField<string, string> { { "foo", "bar" } };
	ICollection<KeyValuePair<string, string>> collection = map;
	Assert.AreEqual(1, map.Count);
	Assert.IsFalse(collection.Remove(NewKeyValuePair("wrong key", "bar")));
	Assert.AreEqual(1, map.Count);
	Assert.IsFalse(collection.Remove(NewKeyValuePair("foo", "wrong value")));
	Assert.AreEqual(1, map.Count);
	Assert.IsTrue(collection.Remove(NewKeyValuePair("foo", "bar")));
	Assert.AreEqual(0, map.Count);
	Assert.Throws<ArgumentException>(() => collection.Remove(new KeyValuePair<string, string>(null, "")));
	}

	[Test]
	public void CopyTo_Pair()
	{
	var map = new MapField<string, string> { { "foo", "bar" } };
	ICollection<KeyValuePair<string, string>> collection = map;
	KeyValuePair<string, string>[] array = new KeyValuePair<string, string>[3];
	collection.CopyTo(array, 1);
	Assert.AreEqual(NewKeyValuePair("foo", "bar"), array[1]);
	}

	[Test]
	public void Clear()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	Assert.AreEqual(1, map.Count);
	map.Clear();
	Assert.AreEqual(0, map.Count);
	map.Add("x", "y");
	Assert.AreEqual(1, map.Count);
	}

	[Test]
	public void Indexer_Get()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	Assert.AreEqual("y", map["x"]);
	Assert.Throws<KeyNotFoundException>(() => { var ignored = map["z"]; });
	}

	[Test]
	public void Indexer_Set()
	{
	var map = new MapField<string, string> { ["x"] = "y" };
	Assert.AreEqual("y", map["x"]);
	map["x"] = "z"; // This won't throw, unlike Add.
	Assert.AreEqual("z", map["x"]);
	}

	[Test]
	public void GetEnumerator_NonGeneric()
	{
	IEnumerable map = new MapField<string, string> { { "x", "y" } };
	CollectionAssert.AreEqual(new[] { new KeyValuePair<string, string>("x", "y") },
	map.Cast<object>().ToList());
	}

	// Test for the explicitly-implemented non-generic IDictionary interface
	[Test]
	public void IDictionary_GetEnumerator()
	{
	IDictionary map = new MapField<string, string> { { "x", "y" } };
	var enumerator = map.GetEnumerator();

	// Commented assertions show an ideal situation - it looks like
	// the LinkedList enumerator doesn't throw when you ask for the current entry
	// at an inappropriate time; fixing this would be more work than it's worth.
	// Assert.Throws<InvalidOperationException>(() => enumerator.Current.GetHashCode());
	Assert.IsTrue(enumerator.MoveNext());
	Assert.AreEqual("x", enumerator.Key);
	Assert.AreEqual("y", enumerator.Value);
	Assert.AreEqual(new DictionaryEntry("x", "y"), enumerator.Current);
	Assert.AreEqual(new DictionaryEntry("x", "y"), enumerator.Entry);
	Assert.IsFalse(enumerator.MoveNext());
	// Assert.Throws<InvalidOperationException>(() => enumerator.Current.GetHashCode());
	enumerator.Reset();
	// Assert.Throws<InvalidOperationException>(() => enumerator.Current.GetHashCode());
	Assert.IsTrue(enumerator.MoveNext());
	Assert.AreEqual("x", enumerator.Key); // Assume the rest are okay
	}

	[Test]
	public void IDictionary_Add()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	IDictionary dictionary = map;
	dictionary.Add("a", "b");
	Assert.AreEqual("b", map["a"]);
	Assert.Throws<ArgumentException>(() => dictionary.Add("a", "duplicate"));
	Assert.Throws<InvalidCastException>(() => dictionary.Add(new object(), "key is bad"));
	Assert.Throws<InvalidCastException>(() => dictionary.Add("value is bad", new object()));
	}

	[Test]
	public void IDictionary_Contains()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	IDictionary dictionary = map;

	Assert.IsFalse(dictionary.Contains("a"));
	Assert.IsFalse(dictionary.Contains(5));
	// Surprising, but IDictionary.Contains is only about keys.
	Assert.IsFalse(dictionary.Contains(new DictionaryEntry("x", "y")));
	Assert.IsTrue(dictionary.Contains("x"));
	}

	[Test]
	public void IDictionary_Remove()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	IDictionary dictionary = map;
	dictionary.Remove("a");
	Assert.AreEqual(1, dictionary.Count);
	dictionary.Remove(5);
	Assert.AreEqual(1, dictionary.Count);
	dictionary.Remove(new DictionaryEntry("x", "y"));
	Assert.AreEqual(1, dictionary.Count);
	dictionary.Remove("x");
	Assert.AreEqual(0, dictionary.Count);
	Assert.Throws<ArgumentNullException>(() => dictionary.Remove(null));
	}

	[Test]
	public void IDictionary_CopyTo()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	IDictionary dictionary = map;
	var array = new DictionaryEntry[3];
	dictionary.CopyTo(array, 1);
	CollectionAssert.AreEqual(new[] { default, new DictionaryEntry("x", "y"), default }, array);
	var objectArray = new object[3];
	dictionary.CopyTo(objectArray, 1);
	CollectionAssert.AreEqual(new object[] { null, new DictionaryEntry("x", "y"), null }, objectArray);
	}

	[Test]
	public void IDictionary_IsFixedSize()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	IDictionary dictionary = map;
	Assert.IsFalse(dictionary.IsFixedSize);
	}

	[Test]
	public void IDictionary_Keys()
	{
	IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
	CollectionAssert.AreEqual(new[] { "x" }, dictionary.Keys);
	}

	[Test]
	public void IDictionary_Values()
	{
	IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
	CollectionAssert.AreEqual(new[] { "y" }, dictionary.Values);
	}

	[Test]
	public void IDictionary_IsSynchronized()
	{
	IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
	Assert.IsFalse(dictionary.IsSynchronized);
	}

	[Test]
	public void IDictionary_SyncRoot()
	{
	IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
	Assert.AreSame(dictionary, dictionary.SyncRoot);
	}

	[Test]
	public void IDictionary_Indexer_Get()
	{
	IDictionary dictionary = new MapField<string, string> { { "x", "y" } };
	Assert.AreEqual("y", dictionary["x"]);
	Assert.IsNull(dictionary["a"]);
	Assert.IsNull(dictionary[5]);
	Assert.Throws<ArgumentNullException>(() => dictionary[null].GetHashCode());
	}

	[Test]
	public void IDictionary_Indexer_Set()
	{
	var map = new MapField<string, string> { { "x", "y" } };
	IDictionary dictionary = map;
	map["a"] = "b";
	Assert.AreEqual("b", map["a"]);
	map["a"] = "c";
	Assert.AreEqual("c", map["a"]);
	Assert.Throws<InvalidCastException>(() => dictionary[5] = "x");
	Assert.Throws<InvalidCastException>(() => dictionary["x"] = 5);
	Assert.Throws<ArgumentNullException>(() => dictionary[null] = "z");
	Assert.Throws<ArgumentNullException>(() => dictionary["x"] = null);
	}

	[Test]
	public void KeysReturnsLiveView()
	{
	var map = new MapField<string, string>();
	var keys = map.Keys;
	CollectionAssert.AreEqual(new string[0], keys);
	map["foo"] = "bar";
	map["x"] = "y";
	CollectionAssert.AreEqual(new[] { "foo", "x" }, keys);
	}

	[Test]
	public void ValuesReturnsLiveView()
	{
	var map = new MapField<string, string>();
	var values = map.Values;
	CollectionAssert.AreEqual(new string[0], values);
	map["foo"] = "bar";
	map["x"] = "y";
	CollectionAssert.AreEqual(new[] { "bar", "y" }, values);
	}

	// Just test keys - we know the implementation is the same for values
	[Test]
	public void ViewsAreReadOnly()
	{
	var map = new MapField<string, string>();
	var keys = map.Keys;
	Assert.IsTrue(keys.IsReadOnly);
	Assert.Throws<NotSupportedException>(() => keys.Clear());
	Assert.Throws<NotSupportedException>(() => keys.Remove("a"));
	Assert.Throws<NotSupportedException>(() => keys.Add("a"));
	}

	// Just test keys - we know the implementation is the same for values
	[Test]
	public void ViewCopyTo()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	var keys = map.Keys;
	var array = new string[4];
	Assert.Throws<ArgumentException>(() => keys.CopyTo(array, 3));
	Assert.Throws<ArgumentOutOfRangeException>(() => keys.CopyTo(array, -1));
	keys.CopyTo(array, 1);
	CollectionAssert.AreEqual(new[] { null, "foo", "x", null }, array);
	}

	// Just test keys - we know the implementation is the same for values
	[Test]
	public void NonGenericViewCopyTo()
	{
	IDictionary map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	ICollection keys = map.Keys;
	// Note the use of the Array type here rather than string[]
	Array array = new string[4];
	Assert.Throws<ArgumentException>(() => keys.CopyTo(array, 3));
	Assert.Throws<ArgumentOutOfRangeException>(() => keys.CopyTo(array, -1));
	keys.CopyTo(array, 1);
	CollectionAssert.AreEqual(new[] { null, "foo", "x", null }, array);
	}

	[Test]
	public void KeysContains()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	var keys = map.Keys;
	Assert.IsTrue(keys.Contains("foo"));
	Assert.IsFalse(keys.Contains("bar")); // It's a value!
	Assert.IsFalse(keys.Contains("1"));
	// Keys can't be null, so we should prevent contains check
	Assert.Throws<ArgumentNullException>(() => keys.Contains(null));
	}

	[Test]
	public void KeysCopyTo()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	var keys = map.Keys.ToArray(); // Uses CopyTo internally
	CollectionAssert.AreEquivalent(new[] { "foo", "x" }, keys);
	}

	[Test]
	public void ValuesContains()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	var values = map.Values;
	Assert.IsTrue(values.Contains("bar"));
	Assert.IsFalse(values.Contains("foo")); // It's a key!
	Assert.IsFalse(values.Contains("1"));
	// Values can be null, so this makes sense
	Assert.IsFalse(values.Contains(null));
	}

	[Test]
	public void ValuesCopyTo()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	var values = map.Values.ToArray(); // Uses CopyTo internally
	CollectionAssert.AreEquivalent(new[] { "bar", "y" }, values);
	}

	[Test]
	public void ToString_StringToString()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	Assert.AreEqual("{ \"foo\": \"bar\", \"x\": \"y\" }", map.ToString());
	}

	[Test]
	public void ToString_UnsupportedKeyType()
	{
	var map = new MapField<byte, string> { { 10, "foo" } };
	Assert.Throws<ArgumentException>(() => map.ToString());
	}

	[Test]
	public void NaNValuesComparedBitwise()
	{
	var map1 = new MapField<string, double>
	{
	{ "x", SampleNaNs.Regular },
	{ "y", SampleNaNs.SignallingFlipped }
	};

	var map2 = new MapField<string, double>
	{
	{ "x", SampleNaNs.Regular },
	{ "y", SampleNaNs.PayloadFlipped }
	};

	var map3 = new MapField<string, double>
	{
	{ "x", SampleNaNs.Regular },
	{ "y", SampleNaNs.SignallingFlipped }
	};

	EqualityTester.AssertInequality(map1, map2);
	EqualityTester.AssertEquality(map1, map3);
	Assert.True(map1.Values.Contains(SampleNaNs.SignallingFlipped));
	Assert.False(map2.Values.Contains(SampleNaNs.SignallingFlipped));
	}

	// This wouldn't usually happen, as protos can't use doubles as map keys,
	// but let's be consistent.
	[Test]
	public void NaNKeysComparedBitwise()
	{
	var map = new MapField<double, string>
	{
	{ SampleNaNs.Regular, "x" },
	{ SampleNaNs.SignallingFlipped, "y" }
	};
	Assert.AreEqual("x", map[SampleNaNs.Regular]);
	Assert.AreEqual("y", map[SampleNaNs.SignallingFlipped]);
	Assert.False(map.TryGetValue(SampleNaNs.PayloadFlipped, out _));
	}

	[Test]
	public void AddEntriesFrom_CodedInputStream()
	{
	// map will have string key and string value
	var keyTag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited);
	var valueTag = WireFormat.MakeTag(2, WireFormat.WireType.LengthDelimited);

	var memoryStream = new MemoryStream();
	var output = new CodedOutputStream(memoryStream);
	output.WriteLength(20); // total of keyTag + key + valueTag + value
	output.WriteTag(keyTag);
	output.WriteString("the_key");
	output.WriteTag(valueTag);
	output.WriteString("the_value");
	output.Flush();

	var field = new MapField<string,string>();
	var mapCodec = new MapField<string,string>.Codec(FieldCodec.ForString(keyTag, ""), FieldCodec.ForString(valueTag, ""), 10);
	var input = new CodedInputStream(memoryStream.ToArray());

	// test the legacy overload of AddEntriesFrom that takes a CodedInputStream
	field.AddEntriesFrom(input, mapCodec);
	CollectionAssert.AreEquivalent(new[] { "the_key" }, field.Keys);
	CollectionAssert.AreEquivalent(new[] { "the_value" }, field.Values);
	Assert.IsTrue(input.IsAtEnd);
	}

	[Test]
	public void AddEntriesFrom_CodedInputStream_MissingKey()
	{
	// map will have string key and string value
	var keyTag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited);
	var valueTag = WireFormat.MakeTag(2, WireFormat.WireType.LengthDelimited);

	var memoryStream = new MemoryStream();
	var output = new CodedOutputStream(memoryStream);
	output.WriteLength(11); // total of valueTag + value
	output.WriteTag(valueTag);
	output.WriteString("the_value");
	output.Flush();

	var field = new MapField<string, string>();
	var mapCodec = new MapField<string, string>.Codec(FieldCodec.ForString(keyTag, ""), FieldCodec.ForString(valueTag, ""), 10);
	var input = new CodedInputStream(memoryStream.ToArray());

	field.AddEntriesFrom(input, mapCodec);
	CollectionAssert.AreEquivalent(new[] { "" }, field.Keys);
	CollectionAssert.AreEquivalent(new[] { "the_value" }, field.Values);
	Assert.IsTrue(input.IsAtEnd);
	}

	[Test]
	public void IDictionaryKeys_Equals_IReadOnlyDictionaryKeys()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	CollectionAssert.AreEquivalent(((IDictionary<string, string>)map).Keys, ((IReadOnlyDictionary<string, string>)map).Keys);
	}

	[Test]
	public void IDictionaryValues_Equals_IReadOnlyDictionaryValues()
	{
	var map = new MapField<string, string> { { "foo", "bar" }, { "x", "y" } };
	CollectionAssert.AreEquivalent(((IDictionary<string, string>)map).Values, ((IReadOnlyDictionary<string, string>)map).Values);
	}

	[Test]
	public void SortIntKeys_RandomOrder()
	{
	var map = new MapField<int, string>() { { 1, "val" }, { -1, "val"}, { 0, "val" } };
	var sortedList = map.GetSortedListCopy(map.ToList()).ToList();
	var sortedKeys = sortedList.Select(kvp => kvp.Key);
	CollectionAssert.AreEqual(new[] { -1, 0, 1 }, sortedKeys);
	}

	[Test]
	public void SortIntKeys_Empty()
	{
	var map = new MapField<int, string> { };
	var sortedList = map.GetSortedListCopy(map.ToList()).ToList();
	var sortedKeys = sortedList.Select(kvp => kvp.Key);
	Assert.IsEmpty(sortedKeys);
	}

	[Test]
	public void SortStringKeys_RandomOrder()
	{
	var map = new MapField<string, string> { { "a", "val" }, { "c", "val" }, { "b", "val" } };
	var sortedList = map.GetSortedListCopy(map.ToList()).ToList();
	var sortedKeys = sortedList.Select(kvp => kvp.Key);
	CollectionAssert.AreEqual(new[] { "a", "b", "c" }, sortedKeys);
	}

	[Test]
	public void SortStringKeys_EnsureOrdinalSort()
	{
	var map = new MapField<string, string>
	{
	{ "i", "val" } , { "I", "val" }, { "ı", "val" }, { "İ", "val" }
	};
	var sortedList = map.GetSortedListCopy(map.ToList());
	var sortedKeys = sortedList.Select(kvp => kvp.Key);
	// Assert Ordinal sort I, i, ı, İ (Non-ordinal sort returns i, I, İ, ı)
	// I == 0x49 , i == 0x69 , İ == 0x130 , ı == 0x131
	CollectionAssert.AreEqual(new[] { "I", "i", "İ", "ı" }, sortedKeys);
	}

	[Test]
	public void SortBoolKeys()
	{
	var map = new MapField<bool, string>
	{
	{ true, "val" } , { false, "val" }
	};
	var sortedList = map.GetSortedListCopy(map.ToList());
	var sortedKeys = sortedList.Select(kvp => kvp.Key);
	CollectionAssert.AreEqual(new[] { false, true }, sortedKeys);
	}

	private static KeyValuePair<TKey, TValue> NewKeyValuePair<TKey, TValue>(TKey key, TValue value)
	{
	return new KeyValuePair<TKey, TValue>(key, value);
	}
	}
	}