* CodeParameterDeclarationExpressionCollection.cs: Use CollectionBase

implementation of IList.Remove to handle removal of item from
collection.
* CodeCatchClauseCollection.cs: Same.
* CodeStatementCollection.cs: Same.
* CodeAttributeDeclarationCollection.cs: Same.
* CodeTypeMemberCollection.cs: Same.
* CodeDirectiveCollection.cs: Same.
* CodeTypeDeclarationCollection.cs: Same.
* CodeNamespaceCollection.cs: Same.
* CodeExpressionCollection.cs: Same.
* CodeTypeReferenceCollection.cs: Same.
* CodeTypeParameterCollection.cs: Same.
* CodeCommentStatementCollection.cs: Same.
* CodeAttributeArgumentCollection.cs: Same.
* CodeTypeParameterCollectionTest.cs: Improve coverage of AddRange
test. Added Remove tests.
* CodeParameterDeclarationExpressionCollectionTest.cs: Same.
* CodeCatchClauseCollectionTest.cs: Same.
* CodeStatementCollectionTest.cs: Same.
* CodeTypeMemberCollectionTest.cs: Same.
* CodeExpressionCollectionTest.cs: Same.
* CodeTypeReferenceCollectionTest.cs: Same.
* CodeCommentStatementCollectionTest.cs: Same.
* CodeAttributeArgumentCollectionTest.cs: Same.
* CodeAttributeDeclarationCollectionTest.cs: Same.
* CodeDirectiveCollectionTest.cs: Same.
* CodeTypeDeclarationCollectionTest.cs: Same.
* CodeNamespaceCollectionTest.cs: Same.

svn path=/trunk/mcs/; revision=53293

mcs/class/System/System.CodeDom/ChangeLog

@@ -1,3 +1,21 @@
+2005-11-20  Gert Driesen  <[email protected]>
+
+	* CodeParameterDeclarationExpressionCollection.cs: Use CollectionBase
+	implementation of IList.Remove to handle removal of item from
+	collection.
+	* CodeCatchClauseCollection.cs: Same.
+	* CodeStatementCollection.cs: Same.
+	* CodeAttributeDeclarationCollection.cs: Same.
+	* CodeTypeMemberCollection.cs: Same.
+	* CodeDirectiveCollection.cs: Same.
+	* CodeTypeDeclarationCollection.cs: Same.
+	* CodeNamespaceCollection.cs: Same.
+	* CodeExpressionCollection.cs: Same.
+	* CodeTypeReferenceCollection.cs: Same.
+	* CodeTypeParameterCollection.cs: Same.
+	* CodeCommentStatementCollection.cs: Same.
+	* CodeAttributeArgumentCollection.cs: Same.
+
 2005-11-20  Gert Driesen  <[email protected]>
 
 	* CodeEventReferenceExpression.cs: Set eol-style to native.

mcs/class/System/System.CodeDom/CodeAttributeArgumentCollection.cs

@@ -122,10 +122,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeAttributeArgument value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeAttributeDeclarationCollection.cs

@@ -122,10 +122,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeAttributeDeclaration value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeCatchClauseCollection.cs

@@ -120,10 +120,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeCatchClause value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeCommentStatementCollection.cs

@@ -122,10 +122,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeCommentStatement value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeDirectiveCollection.cs

@@ -109,12 +109,7 @@ namespace System.CodeDom
 
 		public void Remove (CodeDirective value)
 		{
-			int index = IndexOf (value);
-			if (index < 0) {
-				string msg = Locale.GetText ("The specified object is not found in the collection");
-				throw new ArgumentException (msg, "value");
-			}
-			RemoveAt (index);
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeExpressionCollection.cs

@@ -122,10 +122,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeExpression value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeNamespaceCollection.cs

@@ -121,10 +121,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeNamespace value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeParameterDeclarationExpressionCollection.cs

@@ -122,10 +122,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeParameterDeclarationExpression value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeStatementCollection.cs

@@ -127,10 +127,7 @@ namespace System.CodeDom
 
 		public void Remove (CodeStatement value)
 		{
-			int index = IndexOf (value);
-			if (index < 0)
-				throw new ArgumentException ("The specified object is not found in the collection");
-			RemoveAt (index);
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeTypeDeclarationCollection.cs

@@ -121,10 +121,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeTypeDeclaration value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeTypeMemberCollection.cs

@@ -121,10 +121,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeTypeMember value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/System.CodeDom/CodeTypeParameterCollection.cs

@@ -107,12 +107,7 @@ namespace System.CodeDom
 
 		public void Remove (CodeTypeParameter value)
 		{
-			int index = IndexOf (value);
-			if (index < 0) {
-				string msg = Locale.GetText ("The specified object is not found in the collection");
-				throw new ArgumentException (msg, "value");
-			}
-			RemoveAt (index);
+			List.Remove (value);
 		}
 
 		public CodeTypeParameter this [int index]

mcs/class/System/System.CodeDom/CodeTypeReferenceCollection.cs

@@ -131,10 +131,7 @@ namespace System.CodeDom
 
 		public void Remove( CodeTypeReference value )
 		{
-			int index = IndexOf( value );
-			if ( index < 0 )
-				throw( new ArgumentException( "The specified object is not found in the collection" ) );
-			RemoveAt( index );
+			List.Remove (value);
 		}
 	}
 }

mcs/class/System/Test/System.CodeDom/ChangeLog

@@ -1,3 +1,20 @@
+2005-11-20  Gert Driesen  <[email protected]>
+
+	* CodeTypeParameterCollectionTest.cs: Improve coverage of AddRange 
+	test. Added Remove tests.
+	* CodeParameterDeclarationExpressionCollectionTest.cs: Same.
+	* CodeCatchClauseCollectionTest.cs: Same.
+	* CodeStatementCollectionTest.cs: Same.
+	* CodeTypeMemberCollectionTest.cs: Same.
+	* CodeExpressionCollectionTest.cs: Same.
+	* CodeTypeReferenceCollectionTest.cs: Same.
+	* CodeCommentStatementCollectionTest.cs: Same.
+	* CodeAttributeArgumentCollectionTest.cs: Same.
+	* CodeAttributeDeclarationCollectionTest.cs: Same.
+	* CodeDirectiveCollectionTest.cs: Same.
+	* CodeTypeDeclarationCollectionTest.cs: Same.
+	* CodeNamespaceCollectionTest.cs: Same.
+
 2005-11-20  Gert Driesen  <[email protected]>
 
 	* CodeTypeParameterCollectionTest.cs: Added tests for ctors, and

mcs/class/System/Test/System.CodeDom/CodeAttributeArgumentCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeAttributeArgument caa1 = new CodeAttributeArgument ();
 			CodeAttributeArgument caa2 = new CodeAttributeArgument ();
+			CodeAttributeArgument caa3 = new CodeAttributeArgument ();
 
 			CodeAttributeArgumentCollection coll1 = new CodeAttributeArgumentCollection ();
 			coll1.Add (caa1);
 			coll1.Add (caa2);
 
-			CodeAttributeArgumentCollection coll2 = new CodeAttributeArgumentCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (caa1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (caa2), "#3");
-
-			CodeAttributeArgumentCollection coll3 = new CodeAttributeArgumentCollection(
-				new CodeAttributeArgument[] {caa1, caa2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (caa1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (caa2), "#6");
+			CodeAttributeArgumentCollection coll2 = new CodeAttributeArgumentCollection();
+			coll2.Add (caa3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (caa1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (caa2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (caa3), "#4");
+
+			CodeAttributeArgumentCollection coll3 = new CodeAttributeArgumentCollection();
+			coll3.Add (caa3);
+			coll3.AddRange (new CodeAttributeArgument[] {caa1, caa2});
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (caa1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (caa2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (caa3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeAttributeArgument caa1 = new CodeAttributeArgument ();
+			CodeAttributeArgument caa2 = new CodeAttributeArgument ();
+
+			CodeAttributeArgumentCollection coll = new CodeAttributeArgumentCollection ();
+			coll.Add (caa1);
+			coll.Add (caa2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (caa1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (caa2), "#3");
+			coll.Remove (caa1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (caa1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (caa2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeAttributeArgumentCollection coll = new CodeAttributeArgumentCollection ();
+			coll.Remove (new CodeAttributeArgument ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeAttributeArgumentCollection coll = new CodeAttributeArgumentCollection ();
+			coll.Remove ((CodeAttributeArgument) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeAttributeDeclarationCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeAttributeDeclaration cad1 = new CodeAttributeDeclaration ();
 			CodeAttributeDeclaration cad2 = new CodeAttributeDeclaration ();
+			CodeAttributeDeclaration cad3 = new CodeAttributeDeclaration ();
 
 			CodeAttributeDeclarationCollection coll1 = new CodeAttributeDeclarationCollection ();
 			coll1.Add (cad1);
 			coll1.Add (cad2);
 
-			CodeAttributeDeclarationCollection coll2 = new CodeAttributeDeclarationCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (cad1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (cad2), "#3");
-
-			CodeAttributeDeclarationCollection coll3 = new CodeAttributeDeclarationCollection(
-				new CodeAttributeDeclaration[] {cad1, cad2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (cad1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (cad2), "#6");
+			CodeAttributeDeclarationCollection coll2 = new CodeAttributeDeclarationCollection ();
+			coll2.Add (cad3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (cad1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (cad2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (cad3), "#4");
+
+			CodeAttributeDeclarationCollection coll3 = new CodeAttributeDeclarationCollection ();
+			coll3.Add (cad3);
+			coll3.AddRange (new CodeAttributeDeclaration[] { cad1, cad2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (cad1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (cad2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (cad3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeAttributeDeclaration cad1 = new CodeAttributeDeclaration ();
+			CodeAttributeDeclaration cad2 = new CodeAttributeDeclaration ();
+
+			CodeAttributeDeclarationCollection coll = new CodeAttributeDeclarationCollection ();
+			coll.Add (cad1);
+			coll.Add (cad2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (cad1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (cad2), "#3");
+			coll.Remove (cad1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (cad1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (cad2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeAttributeDeclarationCollection coll = new CodeAttributeDeclarationCollection ();
+			coll.Remove (new CodeAttributeDeclaration ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeAttributeDeclarationCollection coll = new CodeAttributeDeclarationCollection ();
+			coll.Remove ((CodeAttributeDeclaration) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeCatchClauseCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeCatchClause cc1 = new CodeCatchClause ();
 			CodeCatchClause cc2 = new CodeCatchClause ();
+			CodeCatchClause cc3 = new CodeCatchClause ();
 
 			CodeCatchClauseCollection coll1 = new CodeCatchClauseCollection ();
 			coll1.Add (cc1);
 			coll1.Add (cc2);
 
-			CodeCatchClauseCollection coll2 = new CodeCatchClauseCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (cc1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (cc2), "#3");
-
-			CodeCatchClauseCollection coll3 = new CodeCatchClauseCollection(
-				new CodeCatchClause[] {cc1, cc2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (cc1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (cc2), "#6");
+			CodeCatchClauseCollection coll2 = new CodeCatchClauseCollection ();
+			coll2.Add (cc3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (cc1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (cc2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (cc3), "#4");
+
+			CodeCatchClauseCollection coll3 = new CodeCatchClauseCollection ();
+			coll3.Add (cc3);
+			coll3.AddRange (new CodeCatchClause[] { cc1, cc2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (cc1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (cc2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (cc3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeCatchClause ccc1 = new CodeCatchClause ();
+			CodeCatchClause ccc2 = new CodeCatchClause ();
+
+			CodeCatchClauseCollection coll = new CodeCatchClauseCollection ();
+			coll.Add (ccc1);
+			coll.Add (ccc2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (ccc1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (ccc2), "#3");
+			coll.Remove (ccc1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (ccc1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (ccc2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeCatchClauseCollection coll = new CodeCatchClauseCollection ();
+			coll.Remove (new CodeCatchClause ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeCatchClauseCollection coll = new CodeCatchClauseCollection ();
+			coll.Remove ((CodeCatchClause) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeCommentStatementCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeCommentStatement ccs1 = new CodeCommentStatement ();
 			CodeCommentStatement ccs2 = new CodeCommentStatement ();
+			CodeCommentStatement ccs3 = new CodeCommentStatement ();
 
 			CodeCommentStatementCollection coll1 = new CodeCommentStatementCollection ();
 			coll1.Add (ccs1);
 			coll1.Add (ccs2);
 
-			CodeCommentStatementCollection coll2 = new CodeCommentStatementCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (ccs1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (ccs2), "#3");
-
-			CodeCommentStatementCollection coll3 = new CodeCommentStatementCollection(
-				new CodeCommentStatement[] {ccs1, ccs2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (ccs1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (ccs2), "#6");
+			CodeCommentStatementCollection coll2 = new CodeCommentStatementCollection ();
+			coll2.Add (ccs3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (ccs1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (ccs2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (ccs3), "#4");
+
+			CodeCommentStatementCollection coll3 = new CodeCommentStatementCollection ();
+			coll3.Add (ccs3);
+			coll3.AddRange (new CodeCommentStatement[] { ccs1, ccs2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (ccs1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (ccs2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (ccs3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeCommentStatement ccs1 = new CodeCommentStatement ();
+			CodeCommentStatement ccs2 = new CodeCommentStatement ();
+
+			CodeCommentStatementCollection coll = new CodeCommentStatementCollection ();
+			coll.Add (ccs1);
+			coll.Add (ccs2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (ccs1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (ccs2), "#3");
+			coll.Remove (ccs1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (ccs1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (ccs2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeCommentStatementCollection coll = new CodeCommentStatementCollection ();
+			coll.Remove (new CodeCommentStatement ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeCommentStatementCollection coll = new CodeCommentStatementCollection ();
+			coll.Remove ((CodeCommentStatement) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeDirectiveCollectionTest.cs

@@ -157,21 +157,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeDirective cd1 = new CodeDirective ();
 			CodeDirective cd2 = new CodeDirective ();
+			CodeDirective cd3 = new CodeDirective ();
 
 			CodeDirectiveCollection coll1 = new CodeDirectiveCollection ();
 			coll1.Add (cd1);
 			coll1.Add (cd2);
 
-			CodeDirectiveCollection coll2 = new CodeDirectiveCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (cd1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (cd2), "#3");
-
-			CodeDirectiveCollection coll3 = new CodeDirectiveCollection(
-				new CodeDirective[] {cd1, cd2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (cd1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (cd2), "#6");
+			CodeDirectiveCollection coll2 = new CodeDirectiveCollection ();
+			coll2.Add (cd3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (cd1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (cd2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (cd3), "#4");
+
+			CodeDirectiveCollection coll3 = new CodeDirectiveCollection ();
+			coll3.Add (cd3);
+			coll3.AddRange (new CodeDirective[] { cd1, cd2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (cd1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (cd2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (cd3), "#8");
 		}
 
 		[Test]
@@ -198,7 +204,40 @@ namespace MonoTests.System.CodeDom {
 			Assert.AreEqual (1, coll.Count, "#1");
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
+		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeDirective cd1 = new CodeDirective ();
+			CodeDirective cd2 = new CodeDirective ();
 
+			CodeDirectiveCollection coll = new CodeDirectiveCollection ();
+			coll.Add (cd1);
+			coll.Add (cd2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (cd1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (cd2), "#3");
+			coll.Remove (cd1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (cd1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (cd2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeDirectiveCollection coll = new CodeDirectiveCollection ();
+			coll.Remove (new CodeDirective ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeDirectiveCollection coll = new CodeDirectiveCollection ();
+			coll.Remove ((CodeDirective) null);
 		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeExpressionCollectionTest.cs

@@ -155,21 +155,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeExpression exp1 = new CodeExpression ();
 			CodeExpression exp2 = new CodeExpression ();
+			CodeExpression exp3 = new CodeExpression ();
 
 			CodeExpressionCollection coll1 = new CodeExpressionCollection ();
 			coll1.Add (exp1);
 			coll1.Add (exp2);
 
-			CodeExpressionCollection coll2 = new CodeExpressionCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (exp1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (exp2), "#3");
-
-			CodeExpressionCollection coll3 = new CodeExpressionCollection(
-				new CodeExpression[] {exp1, exp2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (exp1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (exp2), "#6");
+			CodeExpressionCollection coll2 = new CodeExpressionCollection ();
+			coll2.Add (exp3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (exp1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (exp2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (exp3), "#4");
+
+			CodeExpressionCollection coll3 = new CodeExpressionCollection ();
+			coll3.Add (exp3);
+			coll3.AddRange (new CodeExpression[] { exp1, exp2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (exp1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (exp2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (exp3), "#8");
 		}
 
 		[Test]
@@ -197,5 +203,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeExpression ce1 = new CodeExpression ();
+			CodeExpression ce2 = new CodeExpression ();
+
+			CodeExpressionCollection coll = new CodeExpressionCollection ();
+			coll.Add (ce1);
+			coll.Add (ce2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (ce1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (ce2), "#3");
+			coll.Remove (ce1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (ce1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (ce2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeExpressionCollection coll = new CodeExpressionCollection ();
+			coll.Remove (new CodeExpression ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeExpressionCollection coll = new CodeExpressionCollection ();
+			coll.Remove ((CodeExpression) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeNamespaceCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeNamespace ns1 = new CodeNamespace ();
 			CodeNamespace ns2 = new CodeNamespace ();
+			CodeNamespace ns3 = new CodeNamespace ();
 
 			CodeNamespaceCollection coll1 = new CodeNamespaceCollection ();
 			coll1.Add (ns1);
 			coll1.Add (ns2);
 
-			CodeNamespaceCollection coll2 = new CodeNamespaceCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (ns1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (ns2), "#3");
-
-			CodeNamespaceCollection coll3 = new CodeNamespaceCollection(
-				new CodeNamespace[] {ns1, ns2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (ns1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (ns2), "#6");
+			CodeNamespaceCollection coll2 = new CodeNamespaceCollection ();
+			coll2.Add (ns3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (ns1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (ns2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (ns3), "#4");
+
+			CodeNamespaceCollection coll3 = new CodeNamespaceCollection ();
+			coll3.Add (ns3);
+			coll3.AddRange (new CodeNamespace[] { ns1, ns2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (ns1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (ns2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (ns3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeNamespace cns1 = new CodeNamespace ();
+			CodeNamespace cns2 = new CodeNamespace ();
+
+			CodeNamespaceCollection coll = new CodeNamespaceCollection ();
+			coll.Add (cns1);
+			coll.Add (cns2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (cns1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (cns2), "#3");
+			coll.Remove (cns1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (cns1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (cns2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeNamespaceCollection coll = new CodeNamespaceCollection ();
+			coll.Remove (new CodeNamespace ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeNamespaceCollection coll = new CodeNamespaceCollection ();
+			coll.Remove ((CodeNamespace) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeParameterDeclarationExpressionCollectionTest.cs

@@ -155,21 +155,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression ();
 			CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression ();
+			CodeParameterDeclarationExpression param3 = new CodeParameterDeclarationExpression ();
 
 			CodeParameterDeclarationExpressionCollection coll1 = new CodeParameterDeclarationExpressionCollection ();
 			coll1.Add (param1);
 			coll1.Add (param2);
 
-			CodeParameterDeclarationExpressionCollection coll2 = new CodeParameterDeclarationExpressionCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (param1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (param2), "#3");
-
-			CodeParameterDeclarationExpressionCollection coll3 = new CodeParameterDeclarationExpressionCollection(
-				new CodeParameterDeclarationExpression[] {param1, param2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (param1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (param2), "#6");
+			CodeParameterDeclarationExpressionCollection coll2 = new CodeParameterDeclarationExpressionCollection ();
+			coll2.Add (param3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (param1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (param2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (param3), "#4");
+
+			CodeParameterDeclarationExpressionCollection coll3 = new CodeParameterDeclarationExpressionCollection ();
+			coll3.Add (param3);
+			coll3.AddRange (new CodeParameterDeclarationExpression[] { param1, param2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (param1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (param2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (param3), "#8");
 		}
 
 		[Test]
@@ -180,6 +186,14 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange ((CodeParameterDeclarationExpression[]) null);
 		}
 
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void AddRange_Null_Item ()
+		{
+			CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ();
+			coll.AddRange (new CodeParameterDeclarationExpression[] { null });
+		}
+
 		[Test]
 		[ExpectedException (typeof (ArgumentNullException))]
 		public void AddRange_Null_Collection ()
@@ -187,5 +201,49 @@ namespace MonoTests.System.CodeDom {
 			CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ();
 			coll.AddRange ((CodeParameterDeclarationExpressionCollection) null);
 		}
+
+		[Test]
+		public void AddRange_Self ()
+		{
+			CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ();
+			coll.Add (new CodeParameterDeclarationExpression ());
+			Assert.AreEqual (1, coll.Count, "#1");
+			coll.AddRange (coll);
+			Assert.AreEqual (2, coll.Count, "#2");
+		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeParameterDeclarationExpression cpde1 = new CodeParameterDeclarationExpression ();
+			CodeParameterDeclarationExpression cpde2 = new CodeParameterDeclarationExpression ();
+
+			CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ();
+			coll.Add (cpde1);
+			coll.Add (cpde2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (cpde1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (cpde2), "#3");
+			coll.Remove (cpde1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (cpde1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (cpde2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ();
+			coll.Remove (new CodeParameterDeclarationExpression ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ();
+			coll.Remove ((CodeParameterDeclarationExpression) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeStatementCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeStatement cs1 = new CodeStatement ();
 			CodeStatement cs2 = new CodeStatement ();
+			CodeStatement cs3 = new CodeStatement ();
 
 			CodeStatementCollection coll1 = new CodeStatementCollection ();
 			coll1.Add (cs1);
 			coll1.Add (cs2);
 
-			CodeStatementCollection coll2 = new CodeStatementCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (cs1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (cs2), "#3");
-
-			CodeStatementCollection coll3 = new CodeStatementCollection(
-				new CodeStatement[] {cs1, cs2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (cs1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (cs2), "#6");
+			CodeStatementCollection coll2 = new CodeStatementCollection ();
+			coll2.Add (cs3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (cs1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (cs2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (cs3), "#4");
+
+			CodeStatementCollection coll3 = new CodeStatementCollection ();
+			coll3.Add (cs3);
+			coll3.AddRange (new CodeStatement[] { cs1, cs2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (cs1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (cs2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (cs3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeStatement cs1 = new CodeStatement ();
+			CodeStatement cs2 = new CodeStatement ();
+
+			CodeStatementCollection coll = new CodeStatementCollection ();
+			coll.Add (cs1);
+			coll.Add (cs2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (cs1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (cs2), "#3");
+			coll.Remove (cs1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (cs1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (cs2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeStatementCollection coll = new CodeStatementCollection ();
+			coll.Remove (new CodeStatement ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeStatementCollection coll = new CodeStatementCollection ();
+			coll.Remove ((CodeStatement) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeTypeDeclarationCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeTypeDeclaration td1 = new CodeTypeDeclaration ();
 			CodeTypeDeclaration td2 = new CodeTypeDeclaration ();
+			CodeTypeDeclaration td3 = new CodeTypeDeclaration ();
 
 			CodeTypeDeclarationCollection coll1 = new CodeTypeDeclarationCollection ();
 			coll1.Add (td1);
 			coll1.Add (td2);
 
-			CodeTypeDeclarationCollection coll2 = new CodeTypeDeclarationCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (td1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (td2), "#3");
-
-			CodeTypeDeclarationCollection coll3 = new CodeTypeDeclarationCollection(
-				new CodeTypeDeclaration[] {td1, td2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (td1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (td2), "#6");
+			CodeTypeDeclarationCollection coll2 = new CodeTypeDeclarationCollection ();
+			coll2.Add (td3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (td1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (td2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (td3), "#4");
+
+			CodeTypeDeclarationCollection coll3 = new CodeTypeDeclarationCollection ();
+			coll3.Add (td3);
+			coll3.AddRange (new CodeTypeDeclaration[] { td1, td2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (td1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (td2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (td3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeTypeDeclaration td1 = new CodeTypeDeclaration ();
+			CodeTypeDeclaration td2 = new CodeTypeDeclaration ();
+
+			CodeTypeDeclarationCollection coll = new CodeTypeDeclarationCollection ();
+			coll.Add (td1);
+			coll.Add (td2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (td1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (td2), "#3");
+			coll.Remove (td1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (td1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (td2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeTypeDeclarationCollection coll = new CodeTypeDeclarationCollection ();
+			coll.Remove (new CodeTypeDeclaration ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeTypeDeclarationCollection coll = new CodeTypeDeclarationCollection ();
+			coll.Remove ((CodeTypeDeclaration) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeTypeMemberCollectionTest.cs

@@ -156,21 +156,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeTypeMember tm1 = new CodeTypeMember ();
 			CodeTypeMember tm2 = new CodeTypeMember ();
+			CodeTypeMember tm3 = new CodeTypeMember ();
 
 			CodeTypeMemberCollection coll1 = new CodeTypeMemberCollection ();
 			coll1.Add (tm1);
 			coll1.Add (tm2);
 
-			CodeTypeMemberCollection coll2 = new CodeTypeMemberCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (tm1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (tm2), "#3");
-
-			CodeTypeMemberCollection coll3 = new CodeTypeMemberCollection(
-				new CodeTypeMember[] {tm1, tm2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (tm1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (tm2), "#6");
+			CodeTypeMemberCollection coll2 = new CodeTypeMemberCollection ();
+			coll2.Add (tm3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (tm1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (tm2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (tm3), "#4");
+
+			CodeTypeMemberCollection coll3 = new CodeTypeMemberCollection ();
+			coll3.Add (tm3);
+			coll3.AddRange (new CodeTypeMember[] { tm1, tm2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (tm1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (tm2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (tm3), "#8");
 		}
 
 		[Test]
@@ -206,5 +212,39 @@ namespace MonoTests.System.CodeDom {
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeTypeMember ctm1 = new CodeTypeMember ();
+			CodeTypeMember ctm2 = new CodeTypeMember ();
+
+			CodeTypeMemberCollection coll = new CodeTypeMemberCollection ();
+			coll.Add (ctm1);
+			coll.Add (ctm2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (ctm1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (ctm2), "#3");
+			coll.Remove (ctm1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (ctm1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (ctm2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeTypeMemberCollection coll = new CodeTypeMemberCollection ();
+			coll.Remove (new CodeTypeMember ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeTypeMemberCollection coll = new CodeTypeMemberCollection ();
+			coll.Remove ((CodeTypeMember) null);
+		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeTypeParameterCollectionTest.cs

@@ -157,21 +157,27 @@ namespace MonoTests.System.CodeDom {
 		{
 			CodeTypeParameter tp1 = new CodeTypeParameter ();
 			CodeTypeParameter tp2 = new CodeTypeParameter ();
+			CodeTypeParameter tp3 = new CodeTypeParameter ();
 
 			CodeTypeParameterCollection coll1 = new CodeTypeParameterCollection ();
 			coll1.Add (tp1);
 			coll1.Add (tp2);
 
-			CodeTypeParameterCollection coll2 = new CodeTypeParameterCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (tp1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (tp2), "#3");
-
-			CodeTypeParameterCollection coll3 = new CodeTypeParameterCollection(
-				new CodeTypeParameter[] {tp1, tp2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (tp1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (tp2), "#6");
+			CodeTypeParameterCollection coll2 = new CodeTypeParameterCollection ();
+			coll2.Add (tp3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (tp1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (tp2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (tp3), "#4");
+
+			CodeTypeParameterCollection coll3 = new CodeTypeParameterCollection ();
+			coll3.Add (tp3);
+			coll3.AddRange (new CodeTypeParameter[] { tp1, tp2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (tp1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (tp2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (tp3), "#8");
 		}
 
 		[Test]
@@ -198,7 +204,40 @@ namespace MonoTests.System.CodeDom {
 			Assert.AreEqual (1, coll.Count, "#1");
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
+		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeTypeParameter ctp1 = new CodeTypeParameter ();
+			CodeTypeParameter ctp2 = new CodeTypeParameter ();
+
+			CodeTypeParameterCollection coll = new CodeTypeParameterCollection ();
+			coll.Add (ctp1);
+			coll.Add (ctp2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (ctp1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (ctp2), "#3");
+			coll.Remove (ctp1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (ctp1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (ctp2), "#6");
+		}
 
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeTypeParameterCollection coll = new CodeTypeParameterCollection ();
+			coll.Remove (new CodeTypeParameter ());
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeTypeParameterCollection coll = new CodeTypeParameterCollection ();
+			coll.Remove ((CodeTypeParameter) null);
 		}
 	}
 }

mcs/class/System/Test/System.CodeDom/CodeTypeReferenceCollectionTest.cs

@@ -159,21 +159,27 @@ namespace MonoTests.System.CodeDom
 		{
 			CodeTypeReference ref1 = new CodeTypeReference (string.Empty);
 			CodeTypeReference ref2 = new CodeTypeReference (string.Empty);
+			CodeTypeReference ref3 = new CodeTypeReference (string.Empty);
 
 			CodeTypeReferenceCollection coll1 = new CodeTypeReferenceCollection ();
 			coll1.Add (ref1);
 			coll1.Add (ref2);
 
-			CodeTypeReferenceCollection coll2 = new CodeTypeReferenceCollection(coll1);
-			Assert.AreEqual (2, coll2.Count, "#1");
-			Assert.AreEqual (0, coll2.IndexOf (ref1), "#2");
-			Assert.AreEqual (1, coll2.IndexOf (ref2), "#3");
-
-			CodeTypeReferenceCollection coll3 = new CodeTypeReferenceCollection(
-				new CodeTypeReference[] {ref1, ref2});
-			Assert.AreEqual (2, coll2.Count, "#4");
-			Assert.AreEqual (0, coll2.IndexOf (ref1), "#5");
-			Assert.AreEqual (1, coll2.IndexOf (ref2), "#6");
+			CodeTypeReferenceCollection coll2 = new CodeTypeReferenceCollection ();
+			coll2.Add (ref3);
+			coll2.AddRange (coll1);
+			Assert.AreEqual (3, coll2.Count, "#1");
+			Assert.AreEqual (1, coll2.IndexOf (ref1), "#2");
+			Assert.AreEqual (2, coll2.IndexOf (ref2), "#3");
+			Assert.AreEqual (0, coll2.IndexOf (ref3), "#4");
+
+			CodeTypeReferenceCollection coll3 = new CodeTypeReferenceCollection ();
+			coll3.Add (ref3);
+			coll3.AddRange (new CodeTypeReference[] { ref1, ref2 });
+			Assert.AreEqual (3, coll2.Count, "#5");
+			Assert.AreEqual (1, coll2.IndexOf (ref1), "#6");
+			Assert.AreEqual (2, coll2.IndexOf (ref2), "#7");
+			Assert.AreEqual (0, coll2.IndexOf (ref3), "#8");
 		}
 
 		[Test]
@@ -201,5 +207,39 @@ namespace MonoTests.System.CodeDom
 			coll.AddRange (coll);
 			Assert.AreEqual (2, coll.Count, "#2");
 		}
+
+		[Test]
+		public void Remove ()
+		{
+			CodeTypeReference ctr1 = new CodeTypeReference (string.Empty);
+			CodeTypeReference ctr2 = new CodeTypeReference (string.Empty);
+
+			CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ();
+			coll.Add (ctr1);
+			coll.Add (ctr2);
+			Assert.AreEqual (2, coll.Count, "#1");
+			Assert.AreEqual (0, coll.IndexOf (ctr1), "#2");
+			Assert.AreEqual (1, coll.IndexOf (ctr2), "#3");
+			coll.Remove (ctr1);
+			Assert.AreEqual (1, coll.Count, "#4");
+			Assert.AreEqual (-1, coll.IndexOf (ctr1), "#5");
+			Assert.AreEqual (0, coll.IndexOf (ctr2), "#6");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Remove_NotInCollection ()
+		{
+			CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ();
+			coll.Remove (new CodeTypeReference (string.Empty));
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void Remove_Null ()
+		{
+			CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ();
+			coll.Remove ((CodeTypeReference) null);
+		}
 	}
 }