+ DictionaryEntry [] array = new DictionaryEntry [1];
+ c.CopyTo (array, array.Length);
+
+ ICollection<KeyValuePair<int,int>> c2 = d;
+ KeyValuePair<int,int> [] array2 = new KeyValuePair<int,int> [1];
+ c2.CopyTo (array2, array2.Length);
+ }
+
+ [Test]
+ public void IDictionary_Contains ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Add (1, 2);
+ Assert.IsTrue (d.Contains (1));
+ Assert.IsFalse (d.Contains (2));
+ Assert.IsFalse (d.Contains ("x"));
+ }
+
+ [Test, ExpectedException (typeof (ArgumentNullException))]
+ public void IDictionary_Contains2 ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Contains (null);
+ }
+
+ [Test, ExpectedException (typeof (ArgumentNullException))]
+ public void IDictionary_Add1 ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Add (null, 1);
+ }
+
+ [Test, ExpectedException (typeof (ArgumentException))]
+ public void IDictionary_Add2 ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Add ("bar", 1);
+ }
+
+ [Test, ExpectedException (typeof (ArgumentException))]
+ public void IDictionary_Add3 ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Add (1, "bar");
+ }
+
+ [Test]
+ public void IDictionary_Add_Null ()
+ {
+ IDictionary d = new Dictionary<int, string> ();
+ d.Add (1, null);
+ d [2] = null;
+
+ Assert.IsNull (d [1]);
+ Assert.IsNull (d [2]);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void IDictionary_Add_Null_2 ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Add (1, null);
+ }
+
+ [Test]
+ public void IDictionary_Remove1 ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Add (1, 2);
+ d.Remove (1);
+ d.Remove (5);
+ d.Remove ("foo");
+ }
+
+ [Test, ExpectedException (typeof (ArgumentNullException))]
+ public void IDictionary_Remove2 ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Remove (null);
+ }
+
+ [Test]
+ public void IDictionary_IndexerGetNonExistingTest ()
+ {
+ IDictionary d = new Dictionary<int, int> ();
+ d.Add(1, 2);
+ Assert.IsNull(d[2]);
+ Assert.IsNull(d["foo"]);
+ }
+
+ [Test] // bug #332534
+ public void Dictionary_MoveNext ()
+ {
+ Dictionary<int,int> a = new Dictionary<int,int>();
+ a.Add(3,1);
+ a.Add(4,1);
+
+ IEnumerator en = a.GetEnumerator();
+ for (int i = 1; i < 10; i++)
+ en.MoveNext();
+ }
+
+ [Test]
+ public void CopyToArray ()
+ {
+ Dictionary<string, string> test = new Dictionary<string, string> ();
+ test.Add ("monkey", "singe");
+ test.Add ("singe", "mono");
+ test.Add ("mono", "monkey");
+ Assert.AreEqual (3, test.Keys.Count, "Dictionary.Count");
+
+ ArrayList list = new ArrayList (test.Keys);
+ Assert.AreEqual (3, list.Count, "ArrayList.Count");
+ Assert.IsTrue (list.Contains ("monkey"), "monkey");
+ Assert.IsTrue (list.Contains ("singe"), "singe");
+ Assert.IsTrue (list.Contains ("mono"), "mono");
+ }
+
+ [Test]
+ public void KeyObjectMustNotGetChangedIfKeyAlreadyExists ()
+ {
+ Dictionary<String, int> d = new Dictionary<string, int> ();
+ string s1 = "Test";
+ string s2 = "Tes" + "T".ToLowerInvariant();
+ d[s1] = 1;
+ d[s2] = 2;
+ string comp = String.Empty;
+ foreach (String s in d.Keys)
+ comp = s;
+ Assert.IsTrue (Object.ReferenceEquals (s1, comp));
+ }
+
+ [Test]
+ public void ResetKeysEnumerator ()
+ {
+ Dictionary<string, string> test = new Dictionary<string, string> ();
+ test.Add ("monkey", "singe");
+ test.Add ("singe", "mono");
+ test.Add ("mono", "monkey");
+
+ IEnumerator enumerator = test.Keys.GetEnumerator ();
+
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+
+ enumerator.Reset ();
+
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsFalse (enumerator.MoveNext ());
+ }
+
+ [Test]
+ public void ResetValuesEnumerator ()
+ {
+ Dictionary<string, string> test = new Dictionary<string, string> ();
+ test.Add ("monkey", "singe");
+ test.Add ("singe", "mono");
+ test.Add ("mono", "monkey");
+
+ IEnumerator enumerator = test.Values.GetEnumerator ();
+
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+
+ enumerator.Reset ();
+
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsFalse (enumerator.MoveNext ());
+ }
+
+ [Test]
+ public void ResetShimEnumerator ()
+ {
+ IDictionary test = new Dictionary<string, string> ();
+ test.Add ("monkey", "singe");
+ test.Add ("singe", "mono");
+ test.Add ("mono", "monkey");
+
+ IEnumerator enumerator = test.GetEnumerator ();
+
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+
+ enumerator.Reset ();
+
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsTrue (enumerator.MoveNext ());
+ Assert.IsFalse (enumerator.MoveNext ());
+ }
+
+ [Test]
+ public void ICollectionOfKeyValuePairContains ()
+ {
+ var dictionary = new Dictionary<string, int> ();
+ dictionary.Add ("foo", 42);
+ dictionary.Add ("bar", 12);
+
+ var collection = dictionary as ICollection<KeyValuePair<string, int>>;
+
+ Assert.AreEqual (2, collection.Count);
+
+ Assert.IsFalse (collection.Contains (new KeyValuePair<string, int> ("baz", 13)));
+ Assert.IsFalse (collection.Contains (new KeyValuePair<string, int> ("foo", 13)));
+ Assert.IsTrue (collection.Contains (new KeyValuePair<string, int> ("foo", 42)));
+ }
+
+ [Test]
+ public void ICollectionOfKeyValuePairRemove ()
+ {
+ var dictionary = new Dictionary<string, int> ();
+ dictionary.Add ("foo", 42);
+ dictionary.Add ("bar", 12);
+
+ var collection = dictionary as ICollection<KeyValuePair<string, int>>;
+
+ Assert.AreEqual (2, collection.Count);
+
+ Assert.IsFalse (collection.Remove (new KeyValuePair<string, int> ("baz", 13)));
+ Assert.IsFalse (collection.Remove (new KeyValuePair<string, int> ("foo", 13)));
+ Assert.IsTrue (collection.Remove (new KeyValuePair<string, int> ("foo", 42)));
+
+ Assert.AreEqual (12, dictionary ["bar"]);
+ Assert.IsFalse (dictionary.ContainsKey ("foo"));
+ }
+
+ [Test]
+ public void ICollectionCopyToKeyValuePairArray ()
+ {
+ var dictionary = new Dictionary<string, int> ();
+ dictionary.Add ("foo", 42);
+
+ var collection = dictionary as ICollection;
+
+ Assert.AreEqual (1, collection.Count);
+
+ var pairs = new KeyValuePair<string, int> [1];
+
+ collection.CopyTo (pairs, 0);
+
+ Assert.AreEqual ("foo", pairs [0].Key);
+ Assert.AreEqual (42, pairs [0].Value);
+ }
+
+ [Test]
+ public void ICollectionCopyToDictionaryEntryArray ()
+ {
+ var dictionary = new Dictionary<string, int> ();
+ dictionary.Add ("foo", 42);
+
+ var collection = dictionary as ICollection;
+
+ Assert.AreEqual (1, collection.Count);
+
+ var entries = new DictionaryEntry [1];
+
+ collection.CopyTo (entries, 0);
+
+ Assert.AreEqual ("foo", (string) entries [0].Key);
+ Assert.AreEqual (42, (int) entries [0].Value);
+ }
+
+ [Test]
+ public void ICollectionCopyToObjectArray ()
+ {
+ var dictionary = new Dictionary<string, int> ();
+ dictionary.Add ("foo", 42);
+
+ var collection = dictionary as ICollection;
+
+ Assert.AreEqual (1, collection.Count);
+
+ var array = new object [1];
+
+ collection.CopyTo (array, 0);
+
+ var pair = (KeyValuePair<string, int>) array [0];
+
+ Assert.AreEqual ("foo", pair.Key);
+ Assert.AreEqual (42, pair.Value);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ICollectionCopyToInvalidArray ()
+ {
+ var dictionary = new Dictionary<string, int> ();
+ dictionary.Add ("foo", 42);
+
+ var collection = dictionary as ICollection;
+
+ Assert.AreEqual (1, collection.Count);
+
+ var array = new int [1];
+
+ collection.CopyTo (array, 0);
+ }
+
+ [Test]
+ public void ValuesCopyToObjectArray ()
+ {
+ var dictionary = new Dictionary<string, string> { { "foo", "bar" } };
+
+ var values = dictionary.Values as ICollection;
+
+ var array = new object [values.Count];
+
+ values.CopyTo (array, 0);
+
+ Assert.AreEqual ("bar", array [0]);
+ }
+
+ delegate void D ();
+ bool Throws (D d)
+ {
+ try {
+ d ();
+ return false;
+ } catch {
+ return true;
+ }
+ }
+
+ [Test]
+ // based on #491858, #517415
+ public void Enumerator_Current ()
+ {
+ var e1 = new Dictionary<int,int>.Enumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e1.Current; }));
+
+ var d = new Dictionary<int,int> ();
+ var e2 = d.GetEnumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+ e2.MoveNext ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+ e2.Dispose ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+
+ var e3 = ((IEnumerable<KeyValuePair<int,int>>) d).GetEnumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+ e3.MoveNext ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+ e3.Dispose ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+
+ var e4 = ((IEnumerable) d).GetEnumerator ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ e4.MoveNext ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ ((IDisposable) e4).Dispose ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ }
+
+ [Test]
+ // based on #491858, #517415
+ public void KeyEnumerator_Current ()
+ {
+ var e1 = new Dictionary<int,int>.KeyCollection.Enumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e1.Current; }));
+
+ var d = new Dictionary<int,int> ().Keys;
+ var e2 = d.GetEnumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+ e2.MoveNext ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+ e2.Dispose ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+
+ var e3 = ((IEnumerable<int>) d).GetEnumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+ e3.MoveNext ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+ e3.Dispose ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+
+ var e4 = ((IEnumerable) d).GetEnumerator ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ e4.MoveNext ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ ((IDisposable) e4).Dispose ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ }
+
+ [Test]
+ // based on #491858, #517415
+ public void ValueEnumerator_Current ()
+ {
+ var e1 = new Dictionary<int,int>.ValueCollection.Enumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e1.Current; }));
+
+ var d = new Dictionary<int,int> ().Values;
+ var e2 = d.GetEnumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+ e2.MoveNext ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+ e2.Dispose ();
+ Assert.IsFalse (Throws (delegate { var x = e2.Current; }));
+
+ var e3 = ((IEnumerable<int>) d).GetEnumerator ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+ e3.MoveNext ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+ e3.Dispose ();
+ Assert.IsFalse (Throws (delegate { var x = e3.Current; }));
+
+ var e4 = ((IEnumerable) d).GetEnumerator ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ e4.MoveNext ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ ((IDisposable) e4).Dispose ();
+ Assert.IsTrue (Throws (delegate { var x = e4.Current; }));
+ }
+
+ [Test]
+ public void ICollectionCopyTo ()
+ {
+ var d = new Dictionary<int, string> ();
+
+ ICollection c = d;
+ c.CopyTo (new object [0], 0);
+ c.CopyTo (new string [0], 0);
+ c.CopyTo (new MyClass [0], 0);
+
+ c = d.Keys;
+ c.CopyTo (new object [0], 0);
+ c.CopyTo (new ValueType [0], 0);
+
+ c = d.Values;
+ c.CopyTo (new object [0], 0);
+ c.CopyTo (new MyClass [0], 0);
+
+ d [3] = null;
+
+ c = d.Keys;
+ c.CopyTo (new object [1], 0);
+ c.CopyTo (new ValueType [1], 0);
+
+ c = d.Values;
+ c.CopyTo (new object [1], 0);
+ c.CopyTo (new MyClass [1], 0);
+ }
+
+ [Test, ExpectedException (typeof (ArgumentException))]
+ public void ICollectionCopyTo_ex1 ()
+ {
+ var d = new Dictionary<int, string> ();
+ ICollection c = d.Keys;
+ c.CopyTo (new string [1], 0);
+ }
+
+ [Test, ExpectedException (typeof (ArgumentException))]
+ public void ICollectionCopyTo_ex2 ()
+ {
+ var d = new Dictionary<int, string> ();
+ ICollection c = d.Values;
+ c.CopyTo (new int [1], 0);
+ }
+
+ [Test, ExpectedException (typeof (ArgumentException))]
+ public void ICollectionCopyTo_ex3 ()
+ {
+ var d = new Dictionary<int, string> ();
+ d [3] = "5";
+
+ ICollection c = d.Keys;
+ c.CopyTo (new MyClass [1], 0);
+ }
+
+ [Test, ExpectedException (typeof (ArgumentException))]
+ public void ICollectionCopyTo_ex4 ()
+ {
+ var d = new Dictionary<int, string> ();
+ d [3] = "5";
+
+ ICollection c = d.Values;
+ c.CopyTo (new MyClass [1], 0);
+ }
+
+ [Test] // bug 474009
+ public void DeserializeEmptyDictionary ()
+ {
+ // contains a Dictionary<string, int> with Count = 0
+ // serialized with MS.NET 3.5
+ string data =
+@"AAEAAAD/////AQAAAAAAAAAEAQAAAOEBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuRGljdGlv
+bmFyeWAyW1tTeXN0ZW0uU3RyaW5nLCBtc2NvcmxpYiwgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJl
+PW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODldLFtTeXN0ZW0uSW50MzIs
+IG1zY29ybGliLCBWZXJzaW9uPTIuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9r
+ZW49Yjc3YTVjNTYxOTM0ZTA4OV1dAwAAAAdWZXJzaW9uCENvbXBhcmVyCEhhc2hTaXplAAMACJIB
+U3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuR2VuZXJpY0VxdWFsaXR5Q29tcGFyZXJgMVtbU3lz
+dGVtLlN0cmluZywgbXNjb3JsaWIsIFZlcnNpb249Mi4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQ
+dWJsaWNLZXlUb2tlbj1iNzdhNWM1NjE5MzRlMDg5XV0IAAAAAAkCAAAAAAAAAAQCAAAAkgFTeXN0
+ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5HZW5lcmljRXF1YWxpdHlDb21wYXJlcmAxW1tTeXN0ZW0u
+U3RyaW5nLCBtc2NvcmxpYiwgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1Ymxp
+Y0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODldXQAAAAAL";
+
+ var stream = new MemoryStream (Convert.FromBase64String (data));
+ var fmt = new BinaryFormatter ();
+ var dict = (Dictionary <string, int>) fmt.Deserialize (stream);
+ Assert.AreEqual (0, dict.Count);
+ }
+
+ [Test]
+ public void DeserializeNonEmptyDictionary ()
+ {
+ // contains a Dictionary<string, int> with Count = 2
+ // and dict [i.ToString()] == i for each i.
+ // serialized with MS.NET 3.5
+ string data =
+@"AAEAAAD/////AQAAAAAAAAAEAQAAAOEBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuRGljdGlv
+bmFyeWAyW1tTeXN0ZW0uU3RyaW5nLCBtc2NvcmxpYiwgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJl
+PW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODldLFtTeXN0ZW0uSW50MzIs
+IG1zY29ybGliLCBWZXJzaW9uPTIuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9r
+ZW49Yjc3YTVjNTYxOTM0ZTA4OV1dBAAAAAdWZXJzaW9uCENvbXBhcmVyCEhhc2hTaXplDUtleVZh
+bHVlUGFpcnMAAwADCJIBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuR2VuZXJpY0VxdWFsaXR5
+Q29tcGFyZXJgMVtbU3lzdGVtLlN0cmluZywgbXNjb3JsaWIsIFZlcnNpb249Mi4wLjAuMCwgQ3Vs
+dHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1iNzdhNWM1NjE5MzRlMDg5XV0I5QFTeXN0ZW0u
+Q29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbU3lzdGVtLlN0cmluZywgbXNjb3Js
+aWIsIFZlcnNpb249Mi4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1iNzdh
+NWM1NjE5MzRlMDg5XSxbU3lzdGVtLkludDMyLCBtc2NvcmxpYiwgVmVyc2lvbj0yLjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODldXVtdAgAAAAkC
+AAAAAwAAAAkDAAAABAIAAACSAVN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLkdlbmVyaWNFcXVh
+bGl0eUNvbXBhcmVyYDFbW1N5c3RlbS5TdHJpbmcsIG1zY29ybGliLCBWZXJzaW9uPTIuMC4wLjAs
+IEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49Yjc3YTVjNTYxOTM0ZTA4OV1dAAAAAAcD
+AAAAAAEAAAACAAAAA+MBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuS2V5VmFsdWVQYWlyYDJb
+W1N5c3RlbS5TdHJpbmcsIG1zY29ybGliLCBWZXJzaW9uPTIuMC4wLjAsIEN1bHR1cmU9bmV1dHJh
+bCwgUHVibGljS2V5VG9rZW49Yjc3YTVjNTYxOTM0ZTA4OV0sW1N5c3RlbS5JbnQzMiwgbXNjb3Js
+aWIsIFZlcnNpb249Mi4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1iNzdh
+NWM1NjE5MzRlMDg5XV0E/P///+MBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuS2V5VmFsdWVQ
+YWlyYDJbW1N5c3RlbS5TdHJpbmcsIG1zY29ybGliLCBWZXJzaW9uPTIuMC4wLjAsIEN1bHR1cmU9
+bmV1dHJhbCwgUHVibGljS2V5VG9rZW49Yjc3YTVjNTYxOTM0ZTA4OV0sW1N5c3RlbS5JbnQzMiwg
+bXNjb3JsaWIsIFZlcnNpb249Mi4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tl
+bj1iNzdhNWM1NjE5MzRlMDg5XV0CAAAAA2tleQV2YWx1ZQEACAYFAAAAATAAAAAAAfr////8////
+BgcAAAABMQEAAAAL";
+ var stream = new MemoryStream (Convert.FromBase64String (data));
+ var fmt = new BinaryFormatter ();
+ var dict = (Dictionary <string, int>) fmt.Deserialize (stream);
+ Assert.AreEqual (2, dict.Count);
+ for (int i = 0; i < dict.Count; i++)
+ Assert.AreEqual (i, dict[i.ToString ()]);