public void GetObjectData()
        {
            UnitTestNameObjectCollectionBase coll = new UnitTestNameObjectCollectionBase(CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant);

            coll.Add("a", "1");

            SerializationInfo si = new SerializationInfo(typeof(UnitTestNameObjectCollectionBase), new FormatterConverter());

            coll.GetObjectData(si, new StreamingContext());
            foreach (SerializationEntry se in si)
            {
                switch (se.Name)
                {
                case "HashProvider":
                    Assert.AreSame(CaseInsensitiveHashCodeProvider.DefaultInvariant, se.Value, se.Name);
                    break;

                case "Comparer":
                    Assert.AreSame(CaseInsensitiveComparer.DefaultInvariant, se.Value, se.Name);
                    break;

                case "ReadOnly":
                    Assert.IsFalse((bool)se.Value, se.Name);
                    break;

                case "Count":
                    Assert.AreEqual(1, se.Value, se.Name);
                    break;

                case "Values":
                    Assert.AreEqual(1, (se.Value as object[]).Length, se.Name);
                    break;

                case "Keys":
                    Assert.AreEqual(1, (se.Value as string[]).Length, se.Name);
                    break;

                case "Version":
                    Assert.AreEqual(2, se.Value, se.Name);
                    break;

                default:
                    string msg = String.Format("Unexpected {0} information of type {1} with value '{2}'.",
                                               se.Name, se.ObjectType, se.Value);
                    Assert.Fail(msg);
                    break;
                }
            }
        }
        public void GetObjectData_Info_Null()
        {
            UnitTestNameObjectCollectionBase coll = new UnitTestNameObjectCollectionBase();

            try {
                coll.GetObjectData(null, new StreamingContext());
                Assert.Fail("#1");
            } catch (ArgumentNullException ex) {
                Assert.AreEqual(typeof(ArgumentNullException), ex.GetType(), "#2");
                Assert.IsNull(ex.InnerException, "#3");
                Assert.IsNotNull(ex.Message, "#4");
                Assert.IsNotNull(ex.ParamName, "#5");
                Assert.AreEqual("info", ex.ParamName, "#6");
            }
        }
        public void GetObjectData_IEqualityComparer()
        {
            EqualityComparer comparer             = new EqualityComparer();
            UnitTestNameObjectCollectionBase coll = new UnitTestNameObjectCollectionBase(5, comparer);

            coll.Add("a", "1");
            coll.Add("b", "2");
            coll._IsReadOnly = true;

            SerializationInfo si = new SerializationInfo(typeof(UnitTestNameObjectCollectionBase), new FormatterConverter());

            coll.GetObjectData(si, new StreamingContext());
            foreach (SerializationEntry se in si)
            {
                switch (se.Name)
                {
                case "KeyComparer":
                    Assert.AreSame(comparer, se.Value, se.Name);
                    break;

                case "ReadOnly":
                    Assert.IsTrue((bool)se.Value, se.Name);
                    break;

                case "Count":
                    Assert.AreEqual(2, se.Value, se.Name);
                    break;

                case "Values":
                    Assert.AreEqual(2, (se.Value as object[]).Length, se.Name);
                    break;

                case "Keys":
                    Assert.AreEqual(2, (se.Value as string[]).Length, se.Name);
                    break;

                case "Version":
                    Assert.AreEqual(4, se.Value, se.Name);
                    break;

                default:
                    string msg = String.Format("Unexpected {0} information of type {1} with value '{2}'.",
                                               se.Name, se.ObjectType, se.Value);
                    Assert.Fail(msg);
                    break;
                }
            }
        }
		public void GetObjectData ()
		{
			UnitTestNameObjectCollectionBase coll = new UnitTestNameObjectCollectionBase (CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant);
			coll.Add ("a", "1");

			SerializationInfo si = new SerializationInfo (typeof (UnitTestNameObjectCollectionBase), new FormatterConverter ());
			coll.GetObjectData (si, new StreamingContext ());
			foreach (SerializationEntry se in si) {
				switch (se.Name) {
				case "HashProvider":
					Assert.AreSame (CaseInsensitiveHashCodeProvider.DefaultInvariant, se.Value, se.Name);
					break;
				case "Comparer":
					Assert.AreSame (CaseInsensitiveComparer.DefaultInvariant, se.Value, se.Name);
					break;
				case "ReadOnly":
					Assert.IsFalse ((bool)se.Value, se.Name);
					break;
				case "Count":
					Assert.AreEqual (1, se.Value, se.Name);
					break;
				case "Values":
					Assert.AreEqual (1, (se.Value as object[]).Length, se.Name);
					break;
				case "Keys":
					Assert.AreEqual (1, (se.Value as string[]).Length, se.Name);
					break;
				case "Version":
					Assert.AreEqual (2, se.Value, se.Name);
					break;
				default:
					string msg = String.Format ("Unexpected {0} information of type {1} with value '{2}'.",
						se.Name, se.ObjectType, se.Value);
					Assert.Fail (msg);
					break;
				}
			}
		}
		public void GetObjectData_Info_Null ()
		{
			UnitTestNameObjectCollectionBase coll = new UnitTestNameObjectCollectionBase ();
			try {
				coll.GetObjectData (null, new StreamingContext ());
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.IsNotNull (ex.ParamName, "#5");
				Assert.AreEqual ("info", ex.ParamName, "#6");
			}
		}
		public void GetObjectData_IEqualityComparer ()
		{
			EqualityComparer comparer = new EqualityComparer ();
			UnitTestNameObjectCollectionBase coll = new UnitTestNameObjectCollectionBase (5, comparer);
			coll.Add ("a", "1");
			coll.Add ("b", "2");
			coll._IsReadOnly = true;

			SerializationInfo si = new SerializationInfo (typeof (UnitTestNameObjectCollectionBase), new FormatterConverter ());
			coll.GetObjectData (si, new StreamingContext ());
			foreach (SerializationEntry se in si) {
				switch (se.Name) {
				case "KeyComparer":
					Assert.AreSame (comparer, se.Value, se.Name);
					break;
				case "ReadOnly":
					Assert.IsTrue ((bool) se.Value, se.Name);
					break;
				case "Count":
					Assert.AreEqual (2, se.Value, se.Name);
					break;
				case "Values":
					Assert.AreEqual (2, (se.Value as object[]).Length, se.Name);
					break;
				case "Keys":
					Assert.AreEqual (2, (se.Value as string[]).Length, se.Name);
					break;
				case "Version":
					Assert.AreEqual (4, se.Value, se.Name);
					break;
				default:
					string msg = String.Format ("Unexpected {0} information of type {1} with value '{2}'.",
						se.Name, se.ObjectType, se.Value);
					Assert.Fail (msg);
					break;
				}
			}
		}