using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
+using System.Threading;
+
using NUnit.Framework;
namespace MonoTests.System.Collections.Generic {
Assert.AreEqual (20, _dictionary2 [m2].Value, "#4");
}
+
+ [Test]
+ [Category ("NotWorking")]
+ public void Remove_ZeroOut ()
+ {
+ object key = new object ();
+ object value = new object ();
+
+ WeakReference wrKey = new WeakReference (key);
+ WeakReference wrValue = new WeakReference (value);
+
+ Dictionary <object, object> dictionary = new Dictionary <object, object> ();
+ dictionary.Add (key, value);
+ dictionary.Remove (key);
+
+ key = null;
+ value = null;
+ GC.Collect ();
+ Thread.Sleep (200);
+
+ Assert.IsNull (wrKey.Target, "#1");
+ Assert.IsNull (wrValue.Target, "#2");
+ }
[Test, ExpectedException(typeof(ArgumentNullException))]
public void IndexerSetNullTest()
Assert.IsFalse (_dictionary.ContainsKey ("key2"));
}
+ [Test] // bug 432441
+ public void Clear_Iterators ()
+ {
+ Dictionary<object, object> d = new Dictionary <object, object> ();
+
+ d [new object ()] = new object ();
+ d.Clear ();
+ int hash = 0;
+ foreach (object o in d) {
+ hash += o.GetHashCode ();
+ }
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void Clear_ZeroOut ()
+ {
+ object key = new object ();
+ object value = new object ();
+
+ WeakReference wrKey = new WeakReference (key);
+ WeakReference wrValue = new WeakReference (value);
+
+ Dictionary <object, object> dictionary = new Dictionary <object, object> ();
+ dictionary.Add (key, value);
+ dictionary.Clear ();
+
+ key = null;
+ value = null;
+ GC.Collect ();
+ Thread.Sleep (200);
+
+ Assert.IsNull (wrKey.Target, "#1");
+ Assert.IsNull (wrValue.Target, "#2");
+ }
+
[Test]
public void ContainsKeyTest ()
{
contains = _dictionary.ContainsKey ("key5");
Assert.IsFalse (contains, "ContainsKey for non existant does not return correct value!");
}
+
+ [Test, ExpectedException (typeof (ArgumentNullException))]
+ public void ContainsKeyTest2 ()
+ {
+ _dictionary.ContainsKey (null);
+ }
[Test]
public void ContainsValueTest ()
return myt.Name.Equals (this.Name) &&
myt.RollNo.Equals (this.RollNo);
}
-
}
[Test]
KeyValuePair <string, object> entry = (KeyValuePair <string, object>)itr.Current;
}
Assert.AreEqual ("value4", _dictionary ["key4"].ToString (), "");
-
}
[Test]
DictionaryEntry entry = (DictionaryEntry) itr.Current;
}
Assert.AreEqual ("value4", _dictionary ["key4"].ToString (), "");
-
}
[Test]
[Test]
public void KeyValueEnumeratorTest ()
{
- IDictionary<int, int> d = new Dictionary<int, int>();
+ IDictionary<int, int> d = new Dictionary<int, int>();
// Values are chosen such that two keys map to the same bucket.
// Default dictionary table size == 10
- d [9] = 1;
- d [10] = 2;
- d [19] = 3;
+ d [9] = 1;
+ d [10] = 2;
+ d [19] = 3;
Assert.AreEqual (d.Count, d.Keys.Count, "d and d.Keys don't appear to match");
Assert.AreEqual (d.Values.Count, d.Keys.Count, "d.Keys and d.Values don't appear to match");
- int count = 0;
- foreach (int i in d.Values)
- ++count;
+ int count = 0;
+ foreach (int i in d.Values)
+ ++count;
Assert.AreEqual (count, d.Values.Count, "d.Values doesn't have the correct number of elements");
- count = 0;
+ count = 0;
foreach (int i in d.Keys)
++count;
Assert.AreEqual (count, d.Keys.Count, "d.Keys doesn't have the correct number of elements");
int nkeys = count;
count = 0;
- foreach (int i in d.Keys) {
+ foreach (int i in d.Keys) {
int foo = d [i];
if (count++ >= nkeys)
Assert.Fail ("Reading a value appears to trash enumerator state");
}
}
- [Test] // bug 75073
+ [Test] // bug 75073
public void SliceCollectionsEnumeratorTest ()
{
Dictionary<string, int> values = new Dictionary<string, int> ();
}
[Test]
- [Category ("TargetJvmNotWorking")] // BUGBUG Very very slow on TARGET_JVM.
public void SerializationTest()
{
for (int i = 0; i < 50; i++)
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 ()
{
Assert.IsNull(d["foo"]);
}
- // Bug: #332534
- [Test]
+ [Test] // bug #332534
public void Dictionary_MoveNext ()
{
Dictionary<int,int> a = new Dictionary<int,int>();
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 ()]);
+ }
}
}