diff --git a/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs b/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs
index 39aae9324c2b..b4f76dad2221 100644
--- a/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs
+++ b/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs
@@ -71,6 +71,8 @@ protected virtual object CreateT(int seed)
 
         protected virtual Type IList_NonGeneric_Item_InvalidIndex_ThrowType => typeof(ArgumentOutOfRangeException);
 
+        protected virtual bool IList_NonGeneric_RemoveNonExistent_Throws => false;
+
         #endregion
 
         #region ICollection Helper Methods
@@ -866,12 +868,20 @@ public void IList_NonGeneric_Remove_NonNullNotContainedInCollection(int count)
             if (!IsReadOnly && !ExpectedFixedSize)
             {
                 int seed = count * 251;
-                IList collection = NonGenericIListFactory(count);
+                IList list = NonGenericIListFactory(count);
                 object value = CreateT(seed++);
-                while (collection.Contains(value) || Enumerable.Contains(InvalidValues, value))
+                while (list.Contains(value) || Enumerable.Contains(InvalidValues, value))
                     value = CreateT(seed++);
-                collection.Remove(value);
-                Assert.Equal(count, collection.Count);
+                list.Remove(value);
+
+                if (IList_NonGeneric_RemoveNonExistent_Throws)
+                {
+                    Assert.Throws<ArgumentException>(() => list.Remove(value));
+                }
+                else
+                {
+                    Assert.Equal(count, list.Count);
+                }
             }
         }
 
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs
new file mode 100644
index 000000000000..fe092d361a5d
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeAttributeArgumentCollectionTests : CodeCollectionTestBase<CodeAttributeArgumentCollection, CodeAttributeArgument>
+    {
+        public override CodeAttributeArgumentCollection Ctor() => new CodeAttributeArgumentCollection();
+        public override CodeAttributeArgumentCollection CtorArray(CodeAttributeArgument[] array) => new CodeAttributeArgumentCollection(array);
+        public override CodeAttributeArgumentCollection CtorCollection(CodeAttributeArgumentCollection collection) => new CodeAttributeArgumentCollection(collection);
+
+        public override int Count(CodeAttributeArgumentCollection collection) => collection.Count;
+
+        public override CodeAttributeArgument GetItem(CodeAttributeArgumentCollection collection, int index) => collection[index];
+        public override void SetItem(CodeAttributeArgumentCollection collection, int index, CodeAttributeArgument value) => collection[index] = value;
+
+        public override void AddRange(CodeAttributeArgumentCollection collection, CodeAttributeArgument[] array) => collection.AddRange(array);
+        public override void AddRange(CodeAttributeArgumentCollection collection, CodeAttributeArgumentCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeAttributeArgumentCollection collection, CodeAttributeArgument obj) => collection.Add(obj);
+
+        public override void Insert(CodeAttributeArgumentCollection collection, int index, CodeAttributeArgument value) => collection.Insert(index, value);
+
+        public override void Remove(CodeAttributeArgumentCollection collection, CodeAttributeArgument value) => collection.Remove(value);
+
+        public override int IndexOf(CodeAttributeArgumentCollection collection, CodeAttributeArgument value) => collection.IndexOf(value);
+        public override bool Contains(CodeAttributeArgumentCollection collection, CodeAttributeArgument value) => collection.Contains(value);
+
+        public override void CopyTo(CodeAttributeArgumentCollection collection, CodeAttributeArgument[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs
new file mode 100644
index 000000000000..4e5e0f973fb8
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeAttributeDeclarationCollectionTests : CodeCollectionTestBase<CodeAttributeDeclarationCollection, CodeAttributeDeclaration>
+    {
+        public override CodeAttributeDeclarationCollection Ctor() => new CodeAttributeDeclarationCollection();
+        public override CodeAttributeDeclarationCollection CtorArray(CodeAttributeDeclaration[] array) => new CodeAttributeDeclarationCollection(array);
+        public override CodeAttributeDeclarationCollection CtorCollection(CodeAttributeDeclarationCollection collection) => new CodeAttributeDeclarationCollection(collection);
+
+        public override int Count(CodeAttributeDeclarationCollection collection) => collection.Count;
+
+        public override CodeAttributeDeclaration GetItem(CodeAttributeDeclarationCollection collection, int index) => collection[index];
+        public override void SetItem(CodeAttributeDeclarationCollection collection, int index, CodeAttributeDeclaration value) => collection[index] = value;
+
+        public override void AddRange(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration[] array) => collection.AddRange(array);
+        public override void AddRange(CodeAttributeDeclarationCollection collection, CodeAttributeDeclarationCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration obj) => collection.Add(obj);
+
+        public override void Insert(CodeAttributeDeclarationCollection collection, int index, CodeAttributeDeclaration value) => collection.Insert(index, value);
+
+        public override void Remove(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration value) => collection.Remove(value);
+
+        public override int IndexOf(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration value) => collection.IndexOf(value);
+        public override bool Contains(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration value) => collection.Contains(value);
+
+        public override void CopyTo(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs
new file mode 100644
index 000000000000..9130f6c24378
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeCatchClauseCollectionTests : CodeCollectionTestBase<CodeCatchClauseCollection, CodeCatchClause>
+    {
+        public override CodeCatchClauseCollection Ctor() => new CodeCatchClauseCollection();
+        public override CodeCatchClauseCollection CtorArray(CodeCatchClause[] array) => new CodeCatchClauseCollection(array);
+        public override CodeCatchClauseCollection CtorCollection(CodeCatchClauseCollection collection) => new CodeCatchClauseCollection(collection);
+
+        public override int Count(CodeCatchClauseCollection collection) => collection.Count;
+
+        public override CodeCatchClause GetItem(CodeCatchClauseCollection collection, int index) => collection[index];
+        public override void SetItem(CodeCatchClauseCollection collection, int index, CodeCatchClause value) => collection[index] = value;
+
+        public override void AddRange(CodeCatchClauseCollection collection, CodeCatchClause[] array) => collection.AddRange(array);
+        public override void AddRange(CodeCatchClauseCollection collection, CodeCatchClauseCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeCatchClauseCollection collection, CodeCatchClause obj) => collection.Add(obj);
+
+        public override void Insert(CodeCatchClauseCollection collection, int index, CodeCatchClause value) => collection.Insert(index, value);
+
+        public override void Remove(CodeCatchClauseCollection collection, CodeCatchClause value) => collection.Remove(value);
+
+        public override int IndexOf(CodeCatchClauseCollection collection, CodeCatchClause value) => collection.IndexOf(value);
+        public override bool Contains(CodeCatchClauseCollection collection, CodeCatchClause value) => collection.Contains(value);
+
+        public override void CopyTo(CodeCatchClauseCollection collection, CodeCatchClause[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeCollectionTestBase.cs b/src/System.CodeDom/tests/CodeCollections/CodeCollectionTestBase.cs
new file mode 100644
index 000000000000..64df9883287b
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeCollectionTestBase.cs
@@ -0,0 +1,221 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using Xunit;
+
+namespace System.CodeDom.Tests
+{
+    public abstract class CodeCollectionTestBase<TCollection, TItem> where TCollection: class where TItem : class, new()
+    {
+        public abstract TCollection Ctor();
+        public abstract TCollection CtorArray(TItem[] array);
+        public abstract TCollection CtorCollection(TCollection collection);
+
+        public abstract int Count(TCollection collection);
+
+        public abstract TItem GetItem(TCollection collection, int index);
+        public abstract void SetItem(TCollection collection, int index, TItem value);
+
+        public abstract void AddRange(TCollection collection, TItem[] array);
+        public abstract void AddRange(TCollection collection, TCollection value);
+
+        public abstract object Add(TCollection collection, TItem seed);
+
+        public abstract void Insert(TCollection collection, int index, TItem value);
+        public abstract void Remove(TCollection collection, TItem value);
+
+        public abstract int IndexOf(TCollection collection, TItem value);
+        public abstract bool Contains(TCollection collection, TItem value);
+
+        public abstract void CopyTo(TCollection collection, TItem[] array, int index);
+
+        [Fact]
+        public void Ctor_Empty()
+        {
+            var collection = Ctor();
+            Assert.Equal(0, Count(collection));
+        }
+
+        public static IEnumerable<object[]> AddRange_TestData()
+        {
+            yield return new object[] { new TItem[0] };
+            yield return new object[] { new TItem[] { new TItem() } };
+            yield return new object[] { new TItem[] { new TItem(), new TItem() } };
+        }
+
+        [Theory]
+        [MemberData(nameof(AddRange_TestData))]
+        public void Ctor_Array_Works(TItem[] value)
+        {
+            var collection = CtorArray(value);
+            VerifyCollection(collection, value);
+        }
+
+        [Theory]
+        [MemberData(nameof(AddRange_TestData))]
+        public void Ctor_CodeStatementCollection_Works(TItem[] value)
+        {
+            var collection = CtorCollection(CtorArray(value));
+            VerifyCollection(collection, value);
+        }
+
+        [Theory]
+        [MemberData(nameof(AddRange_TestData))]
+        public void AddRange_CodeStatementArray_Works(TItem[] value)
+        {
+            var collection = Ctor();
+            AddRange(collection, value);
+            VerifyCollection(collection, value);
+        }
+
+        [Theory]
+        [MemberData(nameof(AddRange_TestData))]
+        public void AddRange_CodeStatementCollection_Works(TItem[] value)
+        {
+            var collection = Ctor();
+            AddRange(collection, CtorCollection(CtorArray(value)));
+            VerifyCollection(collection, value);
+        }
+
+        [Fact]
+        public void AddRange_Null_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("value", () => CtorArray(null));
+            Assert.Throws<ArgumentNullException>("value", () => CtorCollection(null));
+
+            var collection = Ctor();
+            Assert.Throws<ArgumentNullException>("value", () => AddRange(collection, (TItem[])null));
+            Assert.Throws<ArgumentNullException>("value", () => AddRange(collection, (TCollection)null));
+        }
+
+        [Fact]
+        public void AddRange_NullObjectInValue_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("value", () => CtorArray(new TItem[] { null }));
+
+            var collection = Ctor();
+            Assert.Throws<ArgumentNullException>("value", () => AddRange(collection, new TItem[] { null }));
+        }
+
+        [Fact]
+        public void Add_CodeStatement_Insert_Remove()
+        {
+            var collection = Ctor();
+
+            var value1 = new TItem();
+            Assert.Equal(0, Add(collection, value1));
+            Assert.Equal(1, Count(collection));
+            Assert.Equal(value1, GetItem(collection, 0));
+
+            var value2 = new TItem();
+            Insert(collection, 0, value2);
+            Assert.Equal(2, Count(collection));
+            Assert.Same(value2, GetItem(collection, 0));
+
+            Remove(collection, value1);
+            Assert.Equal(1, Count(collection));
+
+            Remove(collection, value2);
+            Assert.Equal(0, Count(collection));
+        }
+
+        [Fact]
+        public void Add_Null_ThrowsArgumentNullException()
+        {
+            var collection = Ctor();
+            Assert.Throws<ArgumentNullException>("value", () => Add(collection, null));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(1)]
+        public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var collection = Ctor();
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => Insert(collection, index, new TItem()));
+        }
+
+        [Fact]
+        public void Insert_Null_ThrowsArgumentNullException()
+        {
+            var collection = Ctor();
+            Assert.Throws<ArgumentNullException>("value", () => Insert(collection, 0, null));
+        }
+
+        [Fact]
+        public void Remove_Null_ThrowsArgumentNullException()
+        {
+            var collection = Ctor();
+            Assert.Throws<ArgumentNullException>("value", () => Remove(collection, null));
+        }
+
+        [Fact]
+        public void Remove_NoSuchObject_ThrowsArgumentException()
+        {
+            var collection = Ctor();
+            Assert.Throws<ArgumentException>(null, () => Remove(collection, new TItem()));
+        }
+
+        [Fact]
+        public void Contains_NoSuchObject_ReturnsMinusOne()
+        {
+            var collection = Ctor();
+            Assert.False(Contains(collection, null));
+            Assert.False(Contains(collection, new TItem()));
+        }
+
+        [Fact]
+        public void IndexOf_NoSuchObject_ReturnsMinusOne()
+        {
+            var collection = Ctor();
+            Assert.Equal(-1, IndexOf(collection, null));
+            Assert.Equal(-1, IndexOf(collection, new TItem()));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(0)]
+        public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var collection = Ctor();
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => GetItem(collection, index));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => SetItem(collection, index, new TItem()));
+        }
+
+        [Fact]
+        public void ItemSet_Get_ReturnsExpected()
+        {
+            var value1 = new TItem();
+            var value2 = new TItem();
+            var collection = Ctor();
+            Add(collection, value1);
+
+            SetItem(collection, 0, value2);
+            Assert.Equal(1, Count(collection));
+            Assert.Same(value2, GetItem(collection, 0));
+        }
+
+        private void VerifyCollection(TCollection collection, TItem[] contents)
+        {
+            Assert.Equal(contents.Length, Count(collection));
+            for (int i = 0; i < contents.Length; i++)
+            {
+                TItem content = GetItem(collection, i);
+                Assert.Equal(i, IndexOf(collection, content));
+                Assert.True(Contains(collection, content));
+                Assert.Same(content, GetItem(collection, i));
+            }
+
+            const int Index = 1;
+            var copy = new TItem[contents.Length + Index];
+            CopyTo(collection, copy, Index);
+            Assert.Null(copy[0]);
+            for (int i = Index; i < copy.Length; i++)
+            {
+                Assert.Same(contents[i - Index], copy[i]);
+            }
+        }
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs
new file mode 100644
index 000000000000..84cc8fb41ae1
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeCommentStatementCollectionTests : CodeCollectionTestBase<CodeCommentStatementCollection, CodeCommentStatement>
+    {
+        public override CodeCommentStatementCollection Ctor() => new CodeCommentStatementCollection();
+        public override CodeCommentStatementCollection CtorArray(CodeCommentStatement[] array) => new CodeCommentStatementCollection(array);
+        public override CodeCommentStatementCollection CtorCollection(CodeCommentStatementCollection collection) => new CodeCommentStatementCollection(collection);
+
+        public override int Count(CodeCommentStatementCollection collection) => collection.Count;
+
+        public override CodeCommentStatement GetItem(CodeCommentStatementCollection collection, int index) => collection[index];
+        public override void SetItem(CodeCommentStatementCollection collection, int index, CodeCommentStatement value) => collection[index] = value;
+
+        public override void AddRange(CodeCommentStatementCollection collection, CodeCommentStatement[] array) => collection.AddRange(array);
+        public override void AddRange(CodeCommentStatementCollection collection, CodeCommentStatementCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeCommentStatementCollection collection, CodeCommentStatement obj) => collection.Add(obj);
+
+        public override void Insert(CodeCommentStatementCollection collection, int index, CodeCommentStatement value) => collection.Insert(index, value);
+
+        public override void Remove(CodeCommentStatementCollection collection, CodeCommentStatement value) => collection.Remove(value);
+
+        public override int IndexOf(CodeCommentStatementCollection collection, CodeCommentStatement value) => collection.IndexOf(value);
+        public override bool Contains(CodeCommentStatementCollection collection, CodeCommentStatement value) => collection.Contains(value);
+
+        public override void CopyTo(CodeCommentStatementCollection collection, CodeCommentStatement[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs
new file mode 100644
index 000000000000..44b52f1d042c
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeDirectiveCollectionTests : CodeCollectionTestBase<CodeDirectiveCollection, CodeDirective>
+    {
+        public override CodeDirectiveCollection Ctor() => new CodeDirectiveCollection();
+        public override CodeDirectiveCollection CtorArray(CodeDirective[] array) => new CodeDirectiveCollection(array);
+        public override CodeDirectiveCollection CtorCollection(CodeDirectiveCollection collection) => new CodeDirectiveCollection(collection);
+
+        public override int Count(CodeDirectiveCollection collection) => collection.Count;
+
+        public override CodeDirective GetItem(CodeDirectiveCollection collection, int index) => collection[index];
+        public override void SetItem(CodeDirectiveCollection collection, int index, CodeDirective value) => collection[index] = value;
+
+        public override void AddRange(CodeDirectiveCollection collection, CodeDirective[] array) => collection.AddRange(array);
+        public override void AddRange(CodeDirectiveCollection collection, CodeDirectiveCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeDirectiveCollection collection, CodeDirective obj) => collection.Add(obj);
+
+        public override void Insert(CodeDirectiveCollection collection, int index, CodeDirective value) => collection.Insert(index, value);
+
+        public override void Remove(CodeDirectiveCollection collection, CodeDirective value) => collection.Remove(value);
+
+        public override int IndexOf(CodeDirectiveCollection collection, CodeDirective value) => collection.IndexOf(value);
+        public override bool Contains(CodeDirectiveCollection collection, CodeDirective value) => collection.Contains(value);
+
+        public override void CopyTo(CodeDirectiveCollection collection, CodeDirective[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs
new file mode 100644
index 000000000000..b386d309d8b3
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeExpressionCollectionTests : CodeCollectionTestBase<CodeExpressionCollection, CodeExpression>
+    {
+        public override CodeExpressionCollection Ctor() => new CodeExpressionCollection();
+        public override CodeExpressionCollection CtorArray(CodeExpression[] array) => new CodeExpressionCollection(array);
+        public override CodeExpressionCollection CtorCollection(CodeExpressionCollection collection) => new CodeExpressionCollection(collection);
+
+        public override int Count(CodeExpressionCollection collection) => collection.Count;
+
+        public override CodeExpression GetItem(CodeExpressionCollection collection, int index) => collection[index];
+        public override void SetItem(CodeExpressionCollection collection, int index, CodeExpression value) => collection[index] = value;
+
+        public override void AddRange(CodeExpressionCollection collection, CodeExpression[] array) => collection.AddRange(array);
+        public override void AddRange(CodeExpressionCollection collection, CodeExpressionCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeExpressionCollection collection, CodeExpression obj) => collection.Add(obj);
+
+        public override void Insert(CodeExpressionCollection collection, int index, CodeExpression value) => collection.Insert(index, value);
+
+        public override void Remove(CodeExpressionCollection collection, CodeExpression value) => collection.Remove(value);
+
+        public override int IndexOf(CodeExpressionCollection collection, CodeExpression value) => collection.IndexOf(value);
+        public override bool Contains(CodeExpressionCollection collection, CodeExpression value) => collection.Contains(value);
+
+        public override void CopyTo(CodeExpressionCollection collection, CodeExpression[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs
new file mode 100644
index 000000000000..25fe39eba257
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeNamespaceCollectionTests : CodeCollectionTestBase<CodeNamespaceCollection, CodeNamespace>
+    {
+        public override CodeNamespaceCollection Ctor() => new CodeNamespaceCollection();
+        public override CodeNamespaceCollection CtorArray(CodeNamespace[] array) => new CodeNamespaceCollection(array);
+        public override CodeNamespaceCollection CtorCollection(CodeNamespaceCollection collection) => new CodeNamespaceCollection(collection);
+
+        public override int Count(CodeNamespaceCollection collection) => collection.Count;
+
+        public override CodeNamespace GetItem(CodeNamespaceCollection collection, int index) => collection[index];
+        public override void SetItem(CodeNamespaceCollection collection, int index, CodeNamespace value) => collection[index] = value;
+
+        public override void AddRange(CodeNamespaceCollection collection, CodeNamespace[] array) => collection.AddRange(array);
+        public override void AddRange(CodeNamespaceCollection collection, CodeNamespaceCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeNamespaceCollection collection, CodeNamespace obj) => collection.Add(obj);
+
+        public override void Insert(CodeNamespaceCollection collection, int index, CodeNamespace value) => collection.Insert(index, value);
+
+        public override void Remove(CodeNamespaceCollection collection, CodeNamespace value) => collection.Remove(value);
+
+        public override int IndexOf(CodeNamespaceCollection collection, CodeNamespace value) => collection.IndexOf(value);
+        public override bool Contains(CodeNamespaceCollection collection, CodeNamespace value) => collection.Contains(value);
+
+        public override void CopyTo(CodeNamespaceCollection collection, CodeNamespace[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeNamespaceImportCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeNamespaceImportCollectionTests.cs
new file mode 100644
index 000000000000..f307dee73cb7
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeNamespaceImportCollectionTests.cs
@@ -0,0 +1,136 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Tests;
+using Xunit;
+
+namespace System.CodeDom.Tests
+{
+    public class CodeNamespaceImportCollectionTests : IList_NonGeneric_Tests
+    {
+        protected override IList NonGenericIListFactory() => new CodeNamespaceImportCollection();
+
+        protected override object CreateT(int seed) => new CodeNamespaceImport(seed.ToString());
+
+        protected override bool NullAllowed => false;
+        protected override bool Enumerator_Current_UndefinedOperation_Throws => true;
+        protected override bool ICollection_NonGeneric_HasNullSyncRoot => true;
+
+        protected override Type ICollection_NonGeneric_CopyTo_NonZeroLowerBound_ThrowType => typeof(ArgumentOutOfRangeException);
+        protected override Type ICollection_NonGeneric_CopyTo_ArrayOfEnumType_ThrowType => typeof(ArgumentException);
+
+        [Fact]
+        public void Add()
+        {
+            var collection = new CodeNamespaceImportCollection();
+            var value = new CodeNamespaceImport();
+
+            collection.Add(value);
+            Assert.Equal(1, collection.Count);
+            Assert.Same(value, collection[0]);
+        }
+
+        [Fact]
+        public void Add_SameNamespace_DoesntAdd()
+        {
+            var collection = new CodeNamespaceImportCollection();
+            var value1 = new CodeNamespaceImport("Namespace");
+            collection.Add(value1);
+
+            collection.Add(value1);
+            Assert.Equal(1, collection.Count);
+
+            var value2 = new CodeNamespaceImport("Namespace");
+            collection.Add(value2);
+            Assert.Equal(1, collection.Count);
+        }
+
+        [Fact]
+        public void Add_Null_ThrowsNullReferenceException()
+        {
+            var collection = new CodeNamespaceImportCollection();
+            Assert.Throws<NullReferenceException>(() => collection.Add(null));
+        }
+
+        public static IEnumerable<object[]> AddRange_TestData()
+        {
+            yield return new object[] { new CodeNamespaceImport[0] };
+            yield return new object[] { new CodeNamespaceImport[] { new CodeNamespaceImport() } };
+        }
+
+        [Theory]
+        [MemberData(nameof(AddRange_TestData))]
+        public void AddRange_CodeNamespaceArray_Works(CodeNamespaceImport[] value)
+        {
+            var collection = new CodeNamespaceImportCollection();
+            collection.AddRange(value);
+            Assert.Equal(value.Length, collection.Count);
+            for (int i = 0; i < value.Length; i++)
+            {
+                Assert.Same(value[i], collection[i]);
+            }
+        }
+
+        [Fact]
+        public void AddRange_Null_ThrowsArgumentNullException()
+        {
+            var collection = new CodeNamespaceImportCollection();
+            Assert.Throws<ArgumentNullException>("value", () => collection.AddRange(null));
+            Assert.Throws<ArgumentNullException>("value", () => collection.AddRange(null));
+        }
+
+        [Fact]
+        public void AddRange_NullObjectInValue_ThrowsNullReferenceException()
+        {
+            var collection = new CodeNamespaceImportCollection();
+            Assert.Throws<NullReferenceException>(() => collection.AddRange(new CodeNamespaceImport[] { null }));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(0)]
+        public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var collection = new CodeNamespaceCollection();
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = new CodeNamespace());
+        }
+
+        [Fact]
+        public void ItemSet_Get_ReturnsExpected()
+        {
+            var value1 = new CodeNamespace();
+            var value2 = new CodeNamespace();
+            var collection = new CodeNamespaceCollection();
+            collection.Add(value1);
+
+            collection[0] = value2;
+            Assert.Equal(1, collection.Count);
+            Assert.Same(value2, collection[0]);
+        }
+
+        private static void VerifyCollection(CodeNamespaceCollection collection, CodeNamespace[] contents)
+        {
+            Assert.Equal(contents.Length, collection.Count);
+            for (int i = 0; i < contents.Length; i++)
+            {
+                CodeNamespace content = contents[i];
+                Assert.Equal(i, collection.IndexOf(content));
+                Assert.True(collection.Contains(content));
+                Assert.Same(content, collection[i]);
+            }
+
+            const int Index = 1;
+            var copy = new CodeNamespace[collection.Count + Index];
+            collection.CopyTo(copy, Index);
+            Assert.Null(copy[0]);
+            for (int i = Index; i < copy.Length; i++)
+            {
+                Assert.Same(contents[i - Index], copy[i]);
+            }
+        }
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs
new file mode 100644
index 000000000000..b27ce22e09e4
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeParameterDeclarationExpressionCollectionTests : CodeCollectionTestBase<CodeParameterDeclarationExpressionCollection, CodeParameterDeclarationExpression>
+    {
+        public override CodeParameterDeclarationExpressionCollection Ctor() => new CodeParameterDeclarationExpressionCollection();
+        public override CodeParameterDeclarationExpressionCollection CtorArray(CodeParameterDeclarationExpression[] array) => new CodeParameterDeclarationExpressionCollection(array);
+        public override CodeParameterDeclarationExpressionCollection CtorCollection(CodeParameterDeclarationExpressionCollection collection) => new CodeParameterDeclarationExpressionCollection(collection);
+
+        public override int Count(CodeParameterDeclarationExpressionCollection collection) => collection.Count;
+
+        public override CodeParameterDeclarationExpression GetItem(CodeParameterDeclarationExpressionCollection collection, int index) => collection[index];
+        public override void SetItem(CodeParameterDeclarationExpressionCollection collection, int index, CodeParameterDeclarationExpression value) => collection[index] = value;
+
+        public override void AddRange(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression[] array) => collection.AddRange(array);
+        public override void AddRange(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpressionCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression obj) => collection.Add(obj);
+
+        public override void Insert(CodeParameterDeclarationExpressionCollection collection, int index, CodeParameterDeclarationExpression value) => collection.Insert(index, value);
+
+        public override void Remove(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression value) => collection.Remove(value);
+
+        public override int IndexOf(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression value) => collection.IndexOf(value);
+        public override bool Contains(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression value) => collection.Contains(value);
+
+        public override void CopyTo(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs
new file mode 100644
index 000000000000..ab02c770a580
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs
@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using Xunit;
+
+namespace System.CodeDom.Tests
+{
+    public class CodeStatementCollectionTests : CodeCollectionTestBase<CodeStatementCollection, CodeStatement>
+    {
+        public override CodeStatementCollection Ctor() => new CodeStatementCollection();
+        public override CodeStatementCollection CtorArray(CodeStatement[] array) => new CodeStatementCollection(array);
+        public override CodeStatementCollection CtorCollection(CodeStatementCollection collection) => new CodeStatementCollection(collection);
+
+        public override int Count(CodeStatementCollection collection) => collection.Count;
+
+        public override CodeStatement GetItem(CodeStatementCollection collection, int index) => collection[index];
+        public override void SetItem(CodeStatementCollection collection, int index, CodeStatement value) => collection[index] = value;
+        
+        public override void AddRange(CodeStatementCollection collection, CodeStatement[] array) => collection.AddRange(array);
+        public override void AddRange(CodeStatementCollection collection, CodeStatementCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeStatementCollection collection, CodeStatement obj) => collection.Add(obj);
+
+        public override void Insert(CodeStatementCollection collection, int index, CodeStatement value) => collection.Insert(index, value);
+
+        public override void Remove(CodeStatementCollection collection, CodeStatement value) => collection.Remove(value);
+
+        public override int IndexOf(CodeStatementCollection collection, CodeStatement value) => collection.IndexOf(value);
+        public override bool Contains(CodeStatementCollection collection, CodeStatement value) => collection.Contains(value);
+
+        public override void CopyTo(CodeStatementCollection collection, CodeStatement[] array, int index) => collection.CopyTo(array, index);
+
+        public static IEnumerable<object[]> Add_CodeExpression_TestData()
+        {
+            yield return new object[] { null };
+            yield return new object[] { new CodePrimitiveExpression("Value") };
+        }
+
+        [Theory]
+        [MemberData(nameof(Add_CodeExpression_TestData))]
+        public void Add_CodeExpression(CodeExpression expression)
+        {
+            var collection = new CodeStatementCollection();
+            Assert.Equal(0, collection.Add(expression));
+            Assert.Equal(expression, ((CodeExpressionStatement)collection[0]).Expression);
+        }
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs
new file mode 100644
index 000000000000..bbdcefac6628
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeTypeDeclarationCollectionTests : CodeCollectionTestBase<CodeTypeDeclarationCollection, CodeTypeDeclaration>
+    {
+        public override CodeTypeDeclarationCollection Ctor() => new CodeTypeDeclarationCollection();
+        public override CodeTypeDeclarationCollection CtorArray(CodeTypeDeclaration[] array) => new CodeTypeDeclarationCollection(array);
+        public override CodeTypeDeclarationCollection CtorCollection(CodeTypeDeclarationCollection collection) => new CodeTypeDeclarationCollection(collection);
+
+        public override int Count(CodeTypeDeclarationCollection collection) => collection.Count;
+
+        public override CodeTypeDeclaration GetItem(CodeTypeDeclarationCollection collection, int index) => collection[index];
+        public override void SetItem(CodeTypeDeclarationCollection collection, int index, CodeTypeDeclaration value) => collection[index] = value;
+
+        public override void AddRange(CodeTypeDeclarationCollection collection, CodeTypeDeclaration[] array) => collection.AddRange(array);
+        public override void AddRange(CodeTypeDeclarationCollection collection, CodeTypeDeclarationCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeTypeDeclarationCollection collection, CodeTypeDeclaration obj) => collection.Add(obj);
+
+        public override void Insert(CodeTypeDeclarationCollection collection, int index, CodeTypeDeclaration value) => collection.Insert(index, value);
+
+        public override void Remove(CodeTypeDeclarationCollection collection, CodeTypeDeclaration value) => collection.Remove(value);
+
+        public override int IndexOf(CodeTypeDeclarationCollection collection, CodeTypeDeclaration value) => collection.IndexOf(value);
+        public override bool Contains(CodeTypeDeclarationCollection collection, CodeTypeDeclaration value) => collection.Contains(value);
+
+        public override void CopyTo(CodeTypeDeclarationCollection collection, CodeTypeDeclaration[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs
new file mode 100644
index 000000000000..51a43f9926d3
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.CodeDom.Tests
+{
+    public class CodeTypeMemberCollectionTests : CodeCollectionTestBase<CodeTypeMemberCollection, CodeTypeMember>
+    {
+        public override CodeTypeMemberCollection Ctor() => new CodeTypeMemberCollection();
+        public override CodeTypeMemberCollection CtorArray(CodeTypeMember[] array) => new CodeTypeMemberCollection(array);
+        public override CodeTypeMemberCollection CtorCollection(CodeTypeMemberCollection collection) => new CodeTypeMemberCollection(collection);
+
+        public override int Count(CodeTypeMemberCollection collection) => collection.Count;
+
+        public override CodeTypeMember GetItem(CodeTypeMemberCollection collection, int index) => collection[index];
+        public override void SetItem(CodeTypeMemberCollection collection, int index, CodeTypeMember value) => collection[index] = value;
+
+        public override void AddRange(CodeTypeMemberCollection collection, CodeTypeMember[] array) => collection.AddRange(array);
+        public override void AddRange(CodeTypeMemberCollection collection, CodeTypeMemberCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeTypeMemberCollection collection, CodeTypeMember obj) => collection.Add(obj);
+
+        public override void Insert(CodeTypeMemberCollection collection, int index, CodeTypeMember value) => collection.Insert(index, value);
+
+        public override void Remove(CodeTypeMemberCollection collection, CodeTypeMember value) => collection.Remove(value);
+
+        public override int IndexOf(CodeTypeMemberCollection collection, CodeTypeMember value) => collection.IndexOf(value);
+        public override bool Contains(CodeTypeMemberCollection collection, CodeTypeMember value) => collection.Contains(value);
+
+        public override void CopyTo(CodeTypeMemberCollection collection, CodeTypeMember[] array, int index) => collection.CopyTo(array, index);
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs
new file mode 100644
index 000000000000..2d785f63e8ab
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Xunit;
+
+namespace System.CodeDom.Tests
+{
+    public class CodeTypeParameterCollectionTests : CodeCollectionTestBase<CodeTypeParameterCollection, CodeTypeParameter>
+    {
+        public override CodeTypeParameterCollection Ctor() => new CodeTypeParameterCollection();
+        public override CodeTypeParameterCollection CtorArray(CodeTypeParameter[] array) => new CodeTypeParameterCollection(array);
+        public override CodeTypeParameterCollection CtorCollection(CodeTypeParameterCollection collection) => new CodeTypeParameterCollection(collection);
+
+        public override int Count(CodeTypeParameterCollection collection) => collection.Count;
+
+        public override CodeTypeParameter GetItem(CodeTypeParameterCollection collection, int index) => collection[index];
+        public override void SetItem(CodeTypeParameterCollection collection, int index, CodeTypeParameter value) => collection[index] = value;
+
+        public override void AddRange(CodeTypeParameterCollection collection, CodeTypeParameter[] array) => collection.AddRange(array);
+        public override void AddRange(CodeTypeParameterCollection collection, CodeTypeParameterCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeTypeParameterCollection collection, CodeTypeParameter obj) => collection.Add(obj);
+
+        public override void Insert(CodeTypeParameterCollection collection, int index, CodeTypeParameter value) => collection.Insert(index, value);
+
+        public override void Remove(CodeTypeParameterCollection collection, CodeTypeParameter value) => collection.Remove(value);
+
+        public override int IndexOf(CodeTypeParameterCollection collection, CodeTypeParameter value) => collection.IndexOf(value);
+        public override bool Contains(CodeTypeParameterCollection collection, CodeTypeParameter value) => collection.Contains(value);
+
+        public override void CopyTo(CodeTypeParameterCollection collection, CodeTypeParameter[] array, int index) => collection.CopyTo(array, index);
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("Name")]
+        public void Add_String(string name)
+        {
+            var collection = new CodeTypeParameterCollection();
+            collection.Add(name);
+            Assert.Equal(new CodeTypeParameter(name).Name, collection[0].Name);
+        }
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs
new file mode 100644
index 000000000000..f5a05a91287f
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs
@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Xunit;
+
+namespace System.CodeDom.Tests
+{
+    public class CodeTypeReferenceCollectionTests : CodeCollectionTestBase<CodeTypeReferenceCollection, CodeTypeReference>
+    {
+        public override CodeTypeReferenceCollection Ctor() => new CodeTypeReferenceCollection();
+        public override CodeTypeReferenceCollection CtorArray(CodeTypeReference[] array) => new CodeTypeReferenceCollection(array);
+        public override CodeTypeReferenceCollection CtorCollection(CodeTypeReferenceCollection collection) => new CodeTypeReferenceCollection(collection);
+
+        public override int Count(CodeTypeReferenceCollection collection) => collection.Count;
+
+        public override CodeTypeReference GetItem(CodeTypeReferenceCollection collection, int index) => collection[index];
+        public override void SetItem(CodeTypeReferenceCollection collection, int index, CodeTypeReference value) => collection[index] = value;
+
+        public override void AddRange(CodeTypeReferenceCollection collection, CodeTypeReference[] array) => collection.AddRange(array);
+        public override void AddRange(CodeTypeReferenceCollection collection, CodeTypeReferenceCollection value) => collection.AddRange(value);
+
+        public override object Add(CodeTypeReferenceCollection collection, CodeTypeReference obj) => collection.Add(obj);
+
+        public override void Insert(CodeTypeReferenceCollection collection, int index, CodeTypeReference value) => collection.Insert(index, value);
+
+        public override void Remove(CodeTypeReferenceCollection collection, CodeTypeReference value) => collection.Remove(value);
+
+        public override int IndexOf(CodeTypeReferenceCollection collection, CodeTypeReference value) => collection.IndexOf(value);
+        public override bool Contains(CodeTypeReferenceCollection collection, CodeTypeReference value) => collection.Contains(value);
+
+        public override void CopyTo(CodeTypeReferenceCollection collection, CodeTypeReference[] array, int index) => collection.CopyTo(array, index);
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("System.Int32")]
+        public void Add_String(string type)
+        {
+            var collection = new CodeTypeReferenceCollection();
+            collection.Add(type);
+            Assert.Equal(new CodeTypeReference(type).BaseType, collection[0].BaseType);
+        }
+
+        [Theory]
+        [InlineData(typeof(int))]
+        public void Add_Type(Type type)
+        {
+            var collection = new CodeTypeReferenceCollection();
+            collection.Add(type);
+            Assert.Equal(new CodeTypeReference(type).BaseType, collection[0].BaseType);
+        }
+
+        [Fact]
+        public void Add_NullType_ThrowsArgumentNullException()
+        {
+            var collection = new CodeTypeReferenceCollection();
+            Assert.Throws<ArgumentNullException>("type", () => collection.Add((Type)null));
+        }
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs
new file mode 100644
index 000000000000..df22879a7111
--- /dev/null
+++ b/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs
@@ -0,0 +1,102 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.CodeDom.Compiler;
+using Xunit;
+
+namespace System.CodeDom.Tests
+{
+    public class CompilerErrorCollectionTests : CodeCollectionTestBase<CompilerErrorCollection, CompilerError>
+    {
+        public override CompilerErrorCollection Ctor() => new CompilerErrorCollection();
+        public override CompilerErrorCollection CtorArray(CompilerError[] array) => new CompilerErrorCollection(array);
+        public override CompilerErrorCollection CtorCollection(CompilerErrorCollection collection) => new CompilerErrorCollection(collection);
+
+        public override int Count(CompilerErrorCollection collection) => collection.Count;
+
+        public override CompilerError GetItem(CompilerErrorCollection collection, int index) => collection[index];
+        public override void SetItem(CompilerErrorCollection collection, int index, CompilerError value) => collection[index] = value;
+
+        public override void AddRange(CompilerErrorCollection collection, CompilerError[] array) => collection.AddRange(array);
+        public override void AddRange(CompilerErrorCollection collection, CompilerErrorCollection value) => collection.AddRange(value);
+
+        public override object Add(CompilerErrorCollection collection, CompilerError obj) => collection.Add(obj);
+
+        public override void Insert(CompilerErrorCollection collection, int index, CompilerError value) => collection.Insert(index, value);
+
+        public override void Remove(CompilerErrorCollection collection, CompilerError value) => collection.Remove(value);
+
+        public override int IndexOf(CompilerErrorCollection collection, CompilerError value) => collection.IndexOf(value);
+        public override bool Contains(CompilerErrorCollection collection, CompilerError value) => collection.Contains(value);
+
+        public override void CopyTo(CompilerErrorCollection collection, CompilerError[] array, int index) => collection.CopyTo(array, index);
+
+        [Fact]
+        public void HasWarnings_Empty_ReturnsFalse()
+        {
+            var collection = new CompilerErrorCollection();
+            Assert.False(collection.HasWarnings);
+        }
+
+        [Fact]
+        public void HasWarnings_OnlyErrors_ReturnsFalse()
+        {
+            var collection = new CompilerErrorCollection();
+            collection.Add(new CompilerError() { IsWarning = false });
+            Assert.False(collection.HasWarnings);
+        }
+
+        [Fact]
+        public void HasWarnings_OnlyWarnings_ReturnsTrue()
+        {
+            var collection = new CompilerErrorCollection();
+            collection.Add(new CompilerError() { IsWarning = true });
+            Assert.True(collection.HasWarnings);
+        }
+
+        [Fact]
+        public void HasWarnings_WarningsAndErrors_ReturnsTrue()
+        {
+            var collection = new CompilerErrorCollection();
+            collection.Add(new CompilerError() { IsWarning = false });
+            collection.Add(new CompilerError() { IsWarning = true });
+            Assert.True(collection.HasWarnings);
+        }
+
+        [Fact]
+        public void HasErrors_Empty_ReturnsFalse()
+        {
+            var collection = new CompilerErrorCollection();
+            Assert.False(collection.HasErrors);
+        }
+
+        [Fact]
+        public void HasErrors_OnlyErrors_ReturnsTrue()
+        {
+            var collection = new CompilerErrorCollection();
+            collection.Add(new CompilerError() { IsWarning = false });
+            Assert.True(collection.HasErrors);
+        }
+
+        [Fact]
+        public void HasErrors_OnlyWarnings_ReturnsFalse()
+        {
+            var collection = new CompilerErrorCollection();
+            collection.Add(new CompilerError() { IsWarning = true });
+            Assert.False(collection.HasErrors);
+        }
+
+        [Fact]
+        public void HasErrors_WarningsAndErrors_ReturnsTrue()
+        {
+            var collection = new CompilerErrorCollection();
+            collection.Add(new CompilerError() { IsWarning = false });
+            collection.Add(new CompilerError() { IsWarning = true });
+            Assert.True(collection.HasErrors);
+        }
+    }
+}
diff --git a/src/System.CodeDom/tests/CodeObjects/CodeNamespaceTests.cs b/src/System.CodeDom/tests/CodeObjects/CodeNamespaceTests.cs
index 53341aa588ed..598346afc172 100644
--- a/src/System.CodeDom/tests/CodeObjects/CodeNamespaceTests.cs
+++ b/src/System.CodeDom/tests/CodeObjects/CodeNamespaceTests.cs
@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Linq;
+using System.Reflection;
+using System.Runtime.Serialization;
 using Xunit;
 
 namespace System.CodeDom.Tests
@@ -30,6 +32,17 @@ public void Ctor_String(string name)
 			Assert.Empty(codeNamespace.Comments);
 		}
 
+        [Fact]
+        public void Ctor_SerializationInfo_StreamingContext()
+        {
+            ConstructorInfo constructor = typeof(CodeNamespace).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, null);
+            var codeNamespace = (CodeNamespace)constructor.Invoke(new object[] { default(SerializationInfo), default(StreamingContext) });
+            Assert.Empty(codeNamespace.Name);
+            Assert.Empty(codeNamespace.Types);
+            Assert.Empty(codeNamespace.Imports);
+            Assert.Empty(codeNamespace.Comments);
+        }
+
 		[Theory]
 		[MemberData(nameof(String_TestData))]
 		public void Name_Set_Get_ReturnsExpected(string value)
diff --git a/src/System.CodeDom/tests/System.CodeDom.Tests.csproj b/src/System.CodeDom/tests/System.CodeDom.Tests.csproj
index ee2d0d08e2d6..ef99221b134d 100644
--- a/src/System.CodeDom/tests/System.CodeDom.Tests.csproj
+++ b/src/System.CodeDom/tests/System.CodeDom.Tests.csproj
@@ -9,6 +9,22 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'netstandard1.7_Debug|AnyCPU' " />
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'netstandard1.7_Release|AnyCPU' " />
   <ItemGroup>
+    <Compile Include="CodeCollections\CodeAttributeDeclarationCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeAttributeArgumentCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeCatchClauseCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeStatementCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeCollectionTestBase.cs" />
+    <Compile Include="CodeCollections\CodeCommentStatementCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeDirectiveCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeExpressionCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeNamespaceCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeNamespaceImportCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeParameterDeclarationExpressionCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeTypeDeclarationCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeTypeMemberCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeTypeParameterCollectionTests.cs" />
+    <Compile Include="CodeCollections\CodeTypeReferenceCollectionTests.cs" />
+    <Compile Include="CodeCollections\CompilerErrorCollectionTests.cs" />
     <Compile Include="CodeCollections\TempFileCollectionTests.cs" />
     <Compile Include="CodeExpressions\CodeObjectCreateExpressionTests.cs" />
     <Compile Include="CodeExpressions\CodeParameterDeclarationExpressionTests.cs" />