From 2fd11831f66385b71e8108db8f481c2eac9f9ae1 Mon Sep 17 00:00:00 2001 From: Hugh Bellamy Date: Thu, 13 Oct 2016 22:47:27 +0100 Subject: [PATCH 1/2] Add tests for Code*Collections --- .../Collections/IList.NonGeneric.Tests.cs | 33 ++- .../CodeAttributeArgumentCollectionTests.cs | 198 +++++++++++++ ...CodeAttributeDeclarationCollectionTests.cs | 198 +++++++++++++ .../CodeCatchClauseCollectionTests.cs | 198 +++++++++++++ .../CodeCommentStatementCollectionTests.cs | 198 +++++++++++++ .../CodeDirectiveCollectionTests.cs | 198 +++++++++++++ .../CodeExpressionCollectionTests.cs | 198 +++++++++++++ .../CodeNamespaceCollectionTests.cs | 198 +++++++++++++ .../CodeNamespaceImportCollectionTests.cs | 136 +++++++++ ...terDeclarationExpressionCollectionTests.cs | 198 +++++++++++++ .../CodeStatementCollectionTests.cs | 213 ++++++++++++++ .../CodeTypeDeclarationCollectionTests.cs | 198 +++++++++++++ .../CodeTypeMemberCollectionTests.cs | 198 +++++++++++++ .../CodeTypeParameterCollectionTests.cs | 209 ++++++++++++++ .../CodeTypeReferenceCollectionTests.cs | 219 +++++++++++++++ .../CompilerErrorCollectionTests.cs | 263 ++++++++++++++++++ .../tests/System.CodeDom.Tests.csproj | 15 + 17 files changed, 3060 insertions(+), 8 deletions(-) create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeNamespaceImportCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs create mode 100644 src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs diff --git a/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs b/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs index 39aae9324c2b..d7f3eebce49b 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 @@ -863,19 +865,34 @@ public void IList_NonGeneric_Remove_NullNotContainedInCollection(int count) [MemberData(nameof(ValidCollectionSizes))] public void IList_NonGeneric_Remove_NonNullNotContainedInCollection(int count) { - if (!IsReadOnly && !ExpectedFixedSize) + if (!IsReadOnly && !ExpectedFixedSize && !IList_NonGeneric_RemoveNonExistent_Throws) { 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); + Assert.Equal(count, list.Count); } - } - - [Theory] + } + + [Theory] + [MemberData(nameof(ValidCollectionSizes))] + public void IList_NonGeneric_Remove_NonNullNotContainedInCollection_Throws(int count) + { + if (IList_NonGeneric_RemoveNonExistent_Throws) + { + int seed = count * 251; + IList list = NonGenericIListFactory(count); + object value = CreateT(seed++); + while (list.Contains(value) || Enumerable.Contains(InvalidValues, value)) + value = CreateT(seed++); + Assert.Throws(() => list.Remove(value)); + } + } + + [Theory] [MemberData(nameof(ValidCollectionSizes))] public void IList_NonGeneric_Remove_NullContainedInCollection(int 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..40ecec3eee75 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeAttributeArgumentCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeAttributeArgument[0] }; + yield return new object[] { new CodeAttributeArgument[] { new CodeAttributeArgument() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeAttributeArgumentArray_Works(CodeAttributeArgument[] value) + { + var collection = new CodeAttributeArgumentCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeAttributeArgumentCollection_Works(CodeAttributeArgument[] value) + { + var collection = new CodeAttributeArgumentCollection(new CodeAttributeArgumentCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeAttributeArgumentArray_Works(CodeAttributeArgument[] value) + { + var collection = new CodeAttributeArgumentCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeAttributeArgumentCollection_Works(CodeAttributeArgument[] value) + { + var collection = new CodeAttributeArgumentCollection(); + collection.AddRange(new CodeAttributeArgumentCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeAttributeArgumentCollection((CodeAttributeArgument[])null)); + Assert.Throws("value", () => new CodeAttributeArgumentCollection((CodeAttributeArgumentCollection)null)); + + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws("value", () => collection.AddRange((CodeAttributeArgument[])null)); + Assert.Throws("value", () => collection.AddRange((CodeAttributeArgumentCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeAttributeArgumentCollection(new CodeAttributeArgument[] { null })); + + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeAttributeArgument[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeAttributeArgumentCollection(); + + var value1 = new CodeAttributeArgument(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeAttributeArgument(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeAttributeArgument())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws(null, () => collection.Remove(new CodeAttributeArgument())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeAttributeArgumentCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeAttributeArgument())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeAttributeArgument())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeAttributeArgumentCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeAttributeArgument()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeAttributeArgument(); + var value2 = new CodeAttributeArgument(); + var collection = new CodeAttributeArgumentCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeAttributeArgumentCollection collection, CodeAttributeArgument[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeAttributeArgument 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 CodeAttributeArgument[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/CodeAttributeDeclarationCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs new file mode 100644 index 000000000000..09445f40c168 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeAttributeDeclarationCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeAttributeDeclaration[0] }; + yield return new object[] { new CodeAttributeDeclaration[] { new CodeAttributeDeclaration() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeAttributeDeclarationArray_Works(CodeAttributeDeclaration[] value) + { + var collection = new CodeAttributeDeclarationCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeAttributeDeclarationCollection_Works(CodeAttributeDeclaration[] value) + { + var collection = new CodeAttributeDeclarationCollection(new CodeAttributeDeclarationCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeAttributeDeclarationArray_Works(CodeAttributeDeclaration[] value) + { + var collection = new CodeAttributeDeclarationCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeAttributeDeclarationCollection_Works(CodeAttributeDeclaration[] value) + { + var collection = new CodeAttributeDeclarationCollection(); + collection.AddRange(new CodeAttributeDeclarationCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeAttributeDeclarationCollection((CodeAttributeDeclaration[])null)); + Assert.Throws("value", () => new CodeAttributeDeclarationCollection((CodeAttributeDeclarationCollection)null)); + + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws("value", () => collection.AddRange((CodeAttributeDeclaration[])null)); + Assert.Throws("value", () => collection.AddRange((CodeAttributeDeclarationCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeAttributeDeclarationCollection(new CodeAttributeDeclaration[] { null })); + + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeAttributeDeclaration[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeAttributeDeclarationCollection(); + + var value1 = new CodeAttributeDeclaration(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeAttributeDeclaration(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeAttributeDeclaration())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws(null, () => collection.Remove(new CodeAttributeDeclaration())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeAttributeDeclaration())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeAttributeDeclaration())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeAttributeDeclarationCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeAttributeDeclaration()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeAttributeDeclaration(); + var value2 = new CodeAttributeDeclaration(); + var collection = new CodeAttributeDeclarationCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeAttributeDeclaration 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 CodeAttributeDeclaration[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/CodeCatchClauseCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs new file mode 100644 index 000000000000..30eeeb0c06d4 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeCatchClauseCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeCatchClauseCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeCatchClause[0] }; + yield return new object[] { new CodeCatchClause[] { new CodeCatchClause() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeCatchClauseArray_Works(CodeCatchClause[] value) + { + var collection = new CodeCatchClauseCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeCatchClauseCollection_Works(CodeCatchClause[] value) + { + var collection = new CodeCatchClauseCollection(new CodeCatchClauseCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeCatchClauseArray_Works(CodeCatchClause[] value) + { + var collection = new CodeCatchClauseCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeCatchClauseCollection_Works(CodeCatchClause[] value) + { + var collection = new CodeCatchClauseCollection(); + collection.AddRange(new CodeCatchClauseCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeCatchClauseCollection((CodeCatchClause[])null)); + Assert.Throws("value", () => new CodeCatchClauseCollection((CodeCatchClauseCollection)null)); + + var collection = new CodeCatchClauseCollection(); + Assert.Throws("value", () => collection.AddRange((CodeCatchClause[])null)); + Assert.Throws("value", () => collection.AddRange((CodeCatchClauseCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeCatchClauseCollection(new CodeCatchClause[] { null })); + + var collection = new CodeCatchClauseCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeCatchClause[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeCatchClauseCollection(); + + var value1 = new CodeCatchClause(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeCatchClause(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeCatchClauseCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeCatchClauseCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeCatchClause())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeCatchClauseCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeCatchClauseCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeCatchClauseCollection(); + Assert.Throws(null, () => collection.Remove(new CodeCatchClause())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeCatchClauseCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeCatchClause())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeCatchClauseCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeCatchClause())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeCatchClauseCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeCatchClause()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeCatchClause(); + var value2 = new CodeCatchClause(); + var collection = new CodeCatchClauseCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeCatchClauseCollection collection, CodeCatchClause[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeCatchClause 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 CodeCatchClause[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/CodeCommentStatementCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs new file mode 100644 index 000000000000..f9c0f3985f1a --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeCommentStatementCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeCommentStatementCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeCommentStatement[0] }; + yield return new object[] { new CodeCommentStatement[] { new CodeCommentStatement() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeCommentStatementArray_Works(CodeCommentStatement[] value) + { + var collection = new CodeCommentStatementCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeCommentStatementCollection_Works(CodeCommentStatement[] value) + { + var collection = new CodeCommentStatementCollection(new CodeCommentStatementCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeCommentStatementArray_Works(CodeCommentStatement[] value) + { + var collection = new CodeCommentStatementCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeCommentStatementCollection_Works(CodeCommentStatement[] value) + { + var collection = new CodeCommentStatementCollection(); + collection.AddRange(new CodeCommentStatementCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeCommentStatementCollection((CodeCommentStatement[])null)); + Assert.Throws("value", () => new CodeCommentStatementCollection((CodeCommentStatementCollection)null)); + + var collection = new CodeCommentStatementCollection(); + Assert.Throws("value", () => collection.AddRange((CodeCommentStatement[])null)); + Assert.Throws("value", () => collection.AddRange((CodeCommentStatementCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeCommentStatementCollection(new CodeCommentStatement[] { null })); + + var collection = new CodeCommentStatementCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeCommentStatement[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeCommentStatementCollection(); + + var value1 = new CodeCommentStatement(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeCommentStatement(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeCommentStatementCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeCommentStatementCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeCommentStatement())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeCommentStatementCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeCommentStatementCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeCommentStatementCollection(); + Assert.Throws(null, () => collection.Remove(new CodeCommentStatement())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeCommentStatementCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeCommentStatement())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeCommentStatementCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeCommentStatement())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeCommentStatementCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeCommentStatement()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeCommentStatement(); + var value2 = new CodeCommentStatement(); + var collection = new CodeCommentStatementCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeCommentStatementCollection collection, CodeCommentStatement[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeCommentStatement 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 CodeCommentStatement[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/CodeDirectiveCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs new file mode 100644 index 000000000000..884889951595 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeDirectiveCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeDirectiveCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeDirective[0] }; + yield return new object[] { new CodeDirective[] { new CodeDirective() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeDirectiveArray_Works(CodeDirective[] value) + { + var collection = new CodeDirectiveCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeDirectiveCollection_Works(CodeDirective[] value) + { + var collection = new CodeDirectiveCollection(new CodeDirectiveCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeDirectiveArray_Works(CodeDirective[] value) + { + var collection = new CodeDirectiveCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeDirectiveCollection_Works(CodeDirective[] value) + { + var collection = new CodeDirectiveCollection(); + collection.AddRange(new CodeDirectiveCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeDirectiveCollection((CodeDirective[])null)); + Assert.Throws("value", () => new CodeDirectiveCollection((CodeDirectiveCollection)null)); + + var collection = new CodeDirectiveCollection(); + Assert.Throws("value", () => collection.AddRange((CodeDirective[])null)); + Assert.Throws("value", () => collection.AddRange((CodeDirectiveCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeDirectiveCollection(new CodeDirective[] { null })); + + var collection = new CodeDirectiveCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeDirective[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeDirectiveCollection(); + + var value1 = new CodeDirective(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeDirective(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeDirectiveCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeDirectiveCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeDirective())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeDirectiveCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeDirectiveCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeDirectiveCollection(); + Assert.Throws(null, () => collection.Remove(new CodeDirective())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeDirectiveCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeDirective())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeDirectiveCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeDirective())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeDirectiveCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeDirective()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeDirective(); + var value2 = new CodeDirective(); + var collection = new CodeDirectiveCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeDirectiveCollection collection, CodeDirective[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeDirective 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 CodeDirective[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/CodeExpressionCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs new file mode 100644 index 000000000000..502b3d0a72ee --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeExpressionCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeExpressionCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeExpression[0] }; + yield return new object[] { new CodeExpression[] { new CodeExpression() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeExpressionArray_Works(CodeExpression[] value) + { + var collection = new CodeExpressionCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeExpressionCollection_Works(CodeExpression[] value) + { + var collection = new CodeExpressionCollection(new CodeExpressionCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeExpressionArray_Works(CodeExpression[] value) + { + var collection = new CodeExpressionCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeExpressionCollection_Works(CodeExpression[] value) + { + var collection = new CodeExpressionCollection(); + collection.AddRange(new CodeExpressionCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeExpressionCollection((CodeExpression[])null)); + Assert.Throws("value", () => new CodeExpressionCollection((CodeExpressionCollection)null)); + + var collection = new CodeExpressionCollection(); + Assert.Throws("value", () => collection.AddRange((CodeExpression[])null)); + Assert.Throws("value", () => collection.AddRange((CodeExpressionCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeExpressionCollection(new CodeExpression[] { null })); + + var collection = new CodeExpressionCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeExpression[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeExpressionCollection(); + + var value1 = new CodeExpression(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeExpression(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeExpressionCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeExpressionCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeExpression())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeExpressionCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeExpressionCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeExpressionCollection(); + Assert.Throws(null, () => collection.Remove(new CodeExpression())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeExpressionCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeExpression())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeExpressionCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeExpression())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeExpressionCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeExpression()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeExpression(); + var value2 = new CodeExpression(); + var collection = new CodeExpressionCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeExpressionCollection collection, CodeExpression[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeExpression 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 CodeExpression[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/CodeNamespaceCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs new file mode 100644 index 000000000000..7e98103fe5ad --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeNamespaceCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeNamespaceCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeNamespace[0] }; + yield return new object[] { new CodeNamespace[] { new CodeNamespace() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeNamespaceArray_Works(CodeNamespace[] value) + { + var collection = new CodeNamespaceCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeNamespaceCollection_Works(CodeNamespace[] value) + { + var collection = new CodeNamespaceCollection(new CodeNamespaceCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeNamespaceArray_Works(CodeNamespace[] value) + { + var collection = new CodeNamespaceCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeNamespaceCollection_Works(CodeNamespace[] value) + { + var collection = new CodeNamespaceCollection(); + collection.AddRange(new CodeNamespaceCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeNamespaceCollection((CodeNamespace[])null)); + Assert.Throws("value", () => new CodeNamespaceCollection((CodeNamespaceCollection)null)); + + var collection = new CodeNamespaceCollection(); + Assert.Throws("value", () => collection.AddRange((CodeNamespace[])null)); + Assert.Throws("value", () => collection.AddRange((CodeNamespaceCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeNamespaceCollection(new CodeNamespace[] { null })); + + var collection = new CodeNamespaceCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeNamespace[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeNamespaceCollection(); + + var value1 = new CodeNamespace(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeNamespace(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeNamespaceCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeNamespaceCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeNamespace())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeNamespaceCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeNamespaceCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeNamespaceCollection(); + Assert.Throws(null, () => collection.Remove(new CodeNamespace())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeNamespaceCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeNamespace())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeNamespaceCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeNamespace())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeNamespaceCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("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/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(() => collection.Add(null)); + } + + public static IEnumerable 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("value", () => collection.AddRange(null)); + Assert.Throws("value", () => collection.AddRange(null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsNullReferenceException() + { + var collection = new CodeNamespaceImportCollection(); + Assert.Throws(() => collection.AddRange(new CodeNamespaceImport[] { null })); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeNamespaceCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("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..3147bb28adcb --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeParameterDeclarationExpressionCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeParameterDeclarationExpression[0] }; + yield return new object[] { new CodeParameterDeclarationExpression[] { new CodeParameterDeclarationExpression() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeParameterDeclarationExpressionArray_Works(CodeParameterDeclarationExpression[] value) + { + var collection = new CodeParameterDeclarationExpressionCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeParameterDeclarationExpressionCollection_Works(CodeParameterDeclarationExpression[] value) + { + var collection = new CodeParameterDeclarationExpressionCollection(new CodeParameterDeclarationExpressionCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeParameterDeclarationExpressionArray_Works(CodeParameterDeclarationExpression[] value) + { + var collection = new CodeParameterDeclarationExpressionCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeParameterDeclarationExpressionCollection_Works(CodeParameterDeclarationExpression[] value) + { + var collection = new CodeParameterDeclarationExpressionCollection(); + collection.AddRange(new CodeParameterDeclarationExpressionCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeParameterDeclarationExpressionCollection((CodeParameterDeclarationExpression[])null)); + Assert.Throws("value", () => new CodeParameterDeclarationExpressionCollection((CodeParameterDeclarationExpressionCollection)null)); + + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws("value", () => collection.AddRange((CodeParameterDeclarationExpression[])null)); + Assert.Throws("value", () => collection.AddRange((CodeParameterDeclarationExpressionCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeParameterDeclarationExpressionCollection(new CodeParameterDeclarationExpression[] { null })); + + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeParameterDeclarationExpression[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + + var value1 = new CodeParameterDeclarationExpression(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeParameterDeclarationExpression(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeParameterDeclarationExpression())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws(null, () => collection.Remove(new CodeParameterDeclarationExpression())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeParameterDeclarationExpression())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeParameterDeclarationExpression())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeParameterDeclarationExpressionCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeParameterDeclarationExpression()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeParameterDeclarationExpression(); + var value2 = new CodeParameterDeclarationExpression(); + var collection = new CodeParameterDeclarationExpressionCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeParameterDeclarationExpression 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 CodeParameterDeclarationExpression[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/CodeStatementCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs new file mode 100644 index 000000000000..e95a6cf05d5f --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs @@ -0,0 +1,213 @@ +// 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 + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeStatementCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeStatement[0] }; + yield return new object[] { new CodeStatement[] { new CodeStatement() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeStatementArray_Works(CodeStatement[] value) + { + var collection = new CodeStatementCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeStatementCollection_Works(CodeStatement[] value) + { + var collection = new CodeStatementCollection(new CodeStatementCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeStatementArray_Works(CodeStatement[] value) + { + var collection = new CodeStatementCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeStatementCollection_Works(CodeStatement[] value) + { + var collection = new CodeStatementCollection(); + collection.AddRange(new CodeStatementCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeStatementCollection((CodeStatement[])null)); + Assert.Throws("value", () => new CodeStatementCollection((CodeStatementCollection)null)); + + var collection = new CodeStatementCollection(); + Assert.Throws("value", () => collection.AddRange((CodeStatement[])null)); + Assert.Throws("value", () => collection.AddRange((CodeStatementCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeStatementCollection(new CodeStatement[] { null })); + + var collection = new CodeStatementCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeStatement[] { null })); + } + + [Fact] + public void Add_CodeStatement_Insert_Remove() + { + var collection = new CodeStatementCollection(); + + var value1 = new CodeStatement(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeStatement(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable 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); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeStatementCollection(); + Assert.Throws("value", () => collection.Add((CodeStatement)null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeStatementCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeStatement())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeStatementCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeStatementCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeStatementCollection(); + Assert.Throws(null, () => collection.Remove(new CodeStatement())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeStatementCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeStatement())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeStatementCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeStatement())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeStatementCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeStatement()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeStatement(); + var value2 = new CodeStatement(); + var collection = new CodeStatementCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeStatementCollection collection, CodeStatement[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeStatement 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 CodeStatement[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/CodeTypeDeclarationCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs new file mode 100644 index 000000000000..130c717302c1 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeTypeDeclarationCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeTypeDeclaration[0] }; + yield return new object[] { new CodeTypeDeclaration[] { new CodeTypeDeclaration() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeTypeDeclarationArray_Works(CodeTypeDeclaration[] value) + { + var collection = new CodeTypeDeclarationCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeTypeDeclarationCollection_Works(CodeTypeDeclaration[] value) + { + var collection = new CodeTypeDeclarationCollection(new CodeTypeDeclarationCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeDeclarationArray_Works(CodeTypeDeclaration[] value) + { + var collection = new CodeTypeDeclarationCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeDeclarationCollection_Works(CodeTypeDeclaration[] value) + { + var collection = new CodeTypeDeclarationCollection(); + collection.AddRange(new CodeTypeDeclarationCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeDeclarationCollection((CodeTypeDeclaration[])null)); + Assert.Throws("value", () => new CodeTypeDeclarationCollection((CodeTypeDeclarationCollection)null)); + + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws("value", () => collection.AddRange((CodeTypeDeclaration[])null)); + Assert.Throws("value", () => collection.AddRange((CodeTypeDeclarationCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeDeclarationCollection(new CodeTypeDeclaration[] { null })); + + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeTypeDeclaration[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeTypeDeclarationCollection(); + + var value1 = new CodeTypeDeclaration(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeTypeDeclaration(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeTypeDeclaration())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws(null, () => collection.Remove(new CodeTypeDeclaration())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeDeclarationCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeTypeDeclaration())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeTypeDeclaration())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeDeclarationCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeTypeDeclaration()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeTypeDeclaration(); + var value2 = new CodeTypeDeclaration(); + var collection = new CodeTypeDeclarationCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeTypeDeclarationCollection collection, CodeTypeDeclaration[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeTypeDeclaration 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 CodeTypeDeclaration[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/CodeTypeMemberCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs new file mode 100644 index 000000000000..9c44a5716b17 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs @@ -0,0 +1,198 @@ +// 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 CodeTypeMemberCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeTypeMemberCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeTypeMember[0] }; + yield return new object[] { new CodeTypeMember[] { new CodeTypeMember() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeTypeMemberArray_Works(CodeTypeMember[] value) + { + var collection = new CodeTypeMemberCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeTypeMemberCollection_Works(CodeTypeMember[] value) + { + var collection = new CodeTypeMemberCollection(new CodeTypeMemberCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeMemberArray_Works(CodeTypeMember[] value) + { + var collection = new CodeTypeMemberCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeMemberCollection_Works(CodeTypeMember[] value) + { + var collection = new CodeTypeMemberCollection(); + collection.AddRange(new CodeTypeMemberCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeMemberCollection((CodeTypeMember[])null)); + Assert.Throws("value", () => new CodeTypeMemberCollection((CodeTypeMemberCollection)null)); + + var collection = new CodeTypeMemberCollection(); + Assert.Throws("value", () => collection.AddRange((CodeTypeMember[])null)); + Assert.Throws("value", () => collection.AddRange((CodeTypeMemberCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeMemberCollection(new CodeTypeMember[] { null })); + + var collection = new CodeTypeMemberCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeTypeMember[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CodeTypeMemberCollection(); + + var value1 = new CodeTypeMember(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeTypeMember(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeMemberCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeMemberCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeTypeMember())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeMemberCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeMemberCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeTypeMemberCollection(); + Assert.Throws(null, () => collection.Remove(new CodeTypeMember())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeMemberCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeTypeMember())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeMemberCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeTypeMember())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeMemberCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeTypeMember()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeTypeMember(); + var value2 = new CodeTypeMember(); + var collection = new CodeTypeMemberCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeTypeMemberCollection collection, CodeTypeMember[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeTypeMember 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 CodeTypeMember[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/CodeTypeParameterCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs new file mode 100644 index 000000000000..c84897c76256 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs @@ -0,0 +1,209 @@ +// 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 CodeTypeParameterCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeTypeParameterCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeTypeParameter[0] }; + yield return new object[] { new CodeTypeParameter[] { new CodeTypeParameter() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeTypeParameterArray_Works(CodeTypeParameter[] value) + { + var collection = new CodeTypeParameterCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeTypeParameterCollection_Works(CodeTypeParameter[] value) + { + var collection = new CodeTypeParameterCollection(new CodeTypeParameterCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeParameterArray_Works(CodeTypeParameter[] value) + { + var collection = new CodeTypeParameterCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeParameterCollection_Works(CodeTypeParameter[] value) + { + var collection = new CodeTypeParameterCollection(); + collection.AddRange(new CodeTypeParameterCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeParameterCollection((CodeTypeParameter[])null)); + Assert.Throws("value", () => new CodeTypeParameterCollection((CodeTypeParameterCollection)null)); + + var collection = new CodeTypeParameterCollection(); + Assert.Throws("value", () => collection.AddRange((CodeTypeParameter[])null)); + Assert.Throws("value", () => collection.AddRange((CodeTypeParameterCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeParameterCollection(new CodeTypeParameter[] { null })); + + var collection = new CodeTypeParameterCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeTypeParameter[] { null })); + } + + [Fact] + public void Add_CodeTypeParameter_Insert_Remove() + { + var collection = new CodeTypeParameterCollection(); + + var value1 = new CodeTypeParameter(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeTypeParameter(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [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); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeParameterCollection(); + Assert.Throws("value", () => collection.Add((CodeTypeParameter)null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeParameterCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeTypeParameter())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeParameterCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeParameterCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeTypeParameterCollection(); + Assert.Throws(null, () => collection.Remove(new CodeTypeParameter())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeParameterCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeTypeParameter())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeParameterCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeTypeParameter())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeParameterCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeTypeParameter()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeTypeParameter(); + var value2 = new CodeTypeParameter(); + var collection = new CodeTypeParameterCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeTypeParameterCollection collection, CodeTypeParameter[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeTypeParameter 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 CodeTypeParameter[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/CodeTypeReferenceCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs new file mode 100644 index 000000000000..5bd95f494493 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs @@ -0,0 +1,219 @@ +// 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 CodeTypeReferenceCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CodeTypeReferenceCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CodeTypeReference[0] }; + yield return new object[] { new CodeTypeReference[] { new CodeTypeReference() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CodeTypeReferenceArray_Works(CodeTypeReference[] value) + { + var collection = new CodeTypeReferenceCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CodeTypeReferenceCollection_Works(CodeTypeReference[] value) + { + var collection = new CodeTypeReferenceCollection(new CodeTypeReferenceCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeReferenceArray_Works(CodeTypeReference[] value) + { + var collection = new CodeTypeReferenceCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CodeTypeReferenceCollection_Works(CodeTypeReference[] value) + { + var collection = new CodeTypeReferenceCollection(); + collection.AddRange(new CodeTypeReferenceCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeReferenceCollection((CodeTypeReference[])null)); + Assert.Throws("value", () => new CodeTypeReferenceCollection((CodeTypeReferenceCollection)null)); + + var collection = new CodeTypeReferenceCollection(); + Assert.Throws("value", () => collection.AddRange((CodeTypeReference[])null)); + Assert.Throws("value", () => collection.AddRange((CodeTypeReferenceCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CodeTypeReferenceCollection(new CodeTypeReference[] { null })); + + var collection = new CodeTypeReferenceCollection(); + Assert.Throws("value", () => collection.AddRange(new CodeTypeReference[] { null })); + } + + [Fact] + public void Add_CodeTypeReference_Insert_Remove() + { + var collection = new CodeTypeReferenceCollection(); + + var value1 = new CodeTypeReference(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CodeTypeReference(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [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_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeReferenceCollection(); + Assert.Throws("value", () => collection.Add((CodeTypeReference)null)); + Assert.Throws("type", () => collection.Add((Type)null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeReferenceCollection(); + Assert.Throws("index", () => collection.Insert(index, new CodeTypeReference())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeReferenceCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CodeTypeReferenceCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CodeTypeReferenceCollection(); + Assert.Throws(null, () => collection.Remove(new CodeTypeReference())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeReferenceCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CodeTypeReference())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CodeTypeReferenceCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CodeTypeReference())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CodeTypeReferenceCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CodeTypeReference()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CodeTypeReference(); + var value2 = new CodeTypeReference(); + var collection = new CodeTypeReferenceCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + private static void VerifyCollection(CodeTypeReferenceCollection collection, CodeTypeReference[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CodeTypeReference 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 CodeTypeReference[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/CompilerErrorCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs new file mode 100644 index 000000000000..a274c91e7501 --- /dev/null +++ b/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs @@ -0,0 +1,263 @@ +// 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 System.Collections.Generic; +using Xunit; + +namespace System.CodeDom.Tests +{ + public class CompilerErrorCollectionTests + { + [Fact] + public void Ctor_IsEmpty() + { + var collection = new CompilerErrorCollection(); + Assert.Equal(0, collection.Count); + } + + public static IEnumerable AddRange_TestData() + { + yield return new object[] { new CompilerError[0] }; + yield return new object[] { new CompilerError[] { new CompilerError() } }; + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor__CompilerErrorArray_Works(CompilerError[] value) + { + var collection = new CompilerErrorCollection(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void Ctor_CompilerErrorCollection_Works(CompilerError[] value) + { + var collection = new CompilerErrorCollection(new CompilerErrorCollection(value)); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CompilerErrorArray_Works(CompilerError[] value) + { + var collection = new CompilerErrorCollection(); + collection.AddRange(value); + VerifyCollection(collection, value); + } + + [Theory] + [MemberData(nameof(AddRange_TestData))] + public void AddRange_CompilerErrorCollection_Works(CompilerError[] value) + { + var collection = new CompilerErrorCollection(); + collection.AddRange(new CompilerErrorCollection(value)); + VerifyCollection(collection, value); + } + + [Fact] + public void AddRange_Null_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CompilerErrorCollection((CompilerError[])null)); + Assert.Throws("value", () => new CompilerErrorCollection((CompilerErrorCollection)null)); + + var collection = new CompilerErrorCollection(); + Assert.Throws("value", () => collection.AddRange((CompilerError[])null)); + Assert.Throws("value", () => collection.AddRange((CompilerErrorCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => new CompilerErrorCollection(new CompilerError[] { null })); + + var collection = new CompilerErrorCollection(); + Assert.Throws("value", () => collection.AddRange(new CompilerError[] { null })); + } + + [Fact] + public void Add_Insert_Remove() + { + var collection = new CompilerErrorCollection(); + + var value1 = new CompilerError(); + Assert.Equal(0, collection.Add(value1)); + Assert.Equal(1, collection.Count); + Assert.Equal(value1, collection[0]); + + var value2 = new CompilerError(); + collection.Insert(0, value2); + Assert.Equal(2, collection.Count); + Assert.Same(value2, collection[0]); + + collection.Remove(value1); + Assert.Equal(1, collection.Count); + + collection.Remove(value2); + Assert.Equal(0, collection.Count); + } + + [Fact] + public void Add_Null_ThrowsArgumentNullException() + { + var collection = new CompilerErrorCollection(); + Assert.Throws("value", () => collection.Add(null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CompilerErrorCollection(); + Assert.Throws("index", () => collection.Insert(index, new CompilerError())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = new CompilerErrorCollection(); + Assert.Throws("value", () => collection.Insert(0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = new CompilerErrorCollection(); + Assert.Throws("value", () => collection.Remove(null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = new CompilerErrorCollection(); + Assert.Throws(null, () => collection.Remove(new CompilerError())); + } + + [Fact] + public void Contains_NoSuchObject_ReturnsMinusOne() + { + var collection = new CompilerErrorCollection(); + Assert.False(collection.Contains(null)); + Assert.False(collection.Contains(new CompilerError())); + } + + [Fact] + public void IndexOf_NoSuchObject_ReturnsMinusOne() + { + var collection = new CompilerErrorCollection(); + Assert.Equal(-1, collection.IndexOf(null)); + Assert.Equal(-1, collection.IndexOf(new CompilerError())); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = new CompilerErrorCollection(); + Assert.Throws("index", () => collection[index]); + Assert.Throws("index", () => collection[index] = new CompilerError()); + } + + [Fact] + public void ItemSet_Get_ReturnsExpected() + { + var value1 = new CompilerError(); + var value2 = new CompilerError(); + var collection = new CompilerErrorCollection(); + collection.Add(value1); + + collection[0] = value2; + Assert.Equal(1, collection.Count); + Assert.Same(value2, collection[0]); + } + + [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); + } + + private static void VerifyCollection(CompilerErrorCollection collection, CompilerError[] contents) + { + Assert.Equal(contents.Length, collection.Count); + for (int i = 0; i < contents.Length; i++) + { + CompilerError 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 CompilerError[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/System.CodeDom.Tests.csproj b/src/System.CodeDom/tests/System.CodeDom.Tests.csproj index ee2d0d08e2d6..f934782e1b05 100644 --- a/src/System.CodeDom/tests/System.CodeDom.Tests.csproj +++ b/src/System.CodeDom/tests/System.CodeDom.Tests.csproj @@ -9,6 +9,21 @@ + + + + + + + + + + + + + + + From 71fcd0f0c73b1fd4cc4f7312dab04601b4577d72 Mon Sep 17 00:00:00 2001 From: Hugh Bellamy Date: Sat, 15 Oct 2016 17:12:44 +0100 Subject: [PATCH 2/2] Address PR feedback --- .../Collections/IList.NonGeneric.Tests.cs | 35 +- .../CodeAttributeArgumentCollectionTests.cs | 200 +--------- ...CodeAttributeDeclarationCollectionTests.cs | 200 +--------- .../CodeCatchClauseCollectionTests.cs | 200 +--------- .../CodeCollections/CodeCollectionTestBase.cs | 221 +++++++++++ .../CodeCommentStatementCollectionTests.cs | 200 +--------- .../CodeDirectiveCollectionTests.cs | 200 +--------- .../CodeExpressionCollectionTests.cs | 200 +--------- .../CodeNamespaceCollectionTests.cs | 200 +--------- ...terDeclarationExpressionCollectionTests.cs | 200 +--------- .../CodeStatementCollectionTests.cs | 243 ++---------- .../CodeTypeDeclarationCollectionTests.cs | 200 +--------- .../CodeTypeMemberCollectionTests.cs | 200 +--------- .../CodeTypeParameterCollectionTests.cs | 218 ++--------- .../CodeTypeReferenceCollectionTests.cs | 262 +++---------- .../CompilerErrorCollectionTests.cs | 345 +++++------------- .../tests/CodeObjects/CodeNamespaceTests.cs | 13 + .../tests/System.CodeDom.Tests.csproj | 3 +- 18 files changed, 631 insertions(+), 2709 deletions(-) create mode 100644 src/System.CodeDom/tests/CodeCollections/CodeCollectionTestBase.cs diff --git a/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs b/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs index d7f3eebce49b..b4f76dad2221 100644 --- a/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs +++ b/src/Common/tests/System/Collections/IList.NonGeneric.Tests.cs @@ -71,7 +71,7 @@ protected virtual object CreateT(int seed) protected virtual Type IList_NonGeneric_Item_InvalidIndex_ThrowType => typeof(ArgumentOutOfRangeException); - protected virtual bool IList_NonGeneric_RemoveNonExistent_Throws => false; + protected virtual bool IList_NonGeneric_RemoveNonExistent_Throws => false; #endregion @@ -865,7 +865,7 @@ public void IList_NonGeneric_Remove_NullNotContainedInCollection(int count) [MemberData(nameof(ValidCollectionSizes))] public void IList_NonGeneric_Remove_NonNullNotContainedInCollection(int count) { - if (!IsReadOnly && !ExpectedFixedSize && !IList_NonGeneric_RemoveNonExistent_Throws) + if (!IsReadOnly && !ExpectedFixedSize) { int seed = count * 251; IList list = NonGenericIListFactory(count); @@ -873,26 +873,19 @@ public void IList_NonGeneric_Remove_NonNullNotContainedInCollection(int count) while (list.Contains(value) || Enumerable.Contains(InvalidValues, value)) value = CreateT(seed++); list.Remove(value); - Assert.Equal(count, list.Count); + + if (IList_NonGeneric_RemoveNonExistent_Throws) + { + Assert.Throws(() => list.Remove(value)); + } + else + { + Assert.Equal(count, list.Count); + } } - } - - [Theory] - [MemberData(nameof(ValidCollectionSizes))] - public void IList_NonGeneric_Remove_NonNullNotContainedInCollection_Throws(int count) - { - if (IList_NonGeneric_RemoveNonExistent_Throws) - { - int seed = count * 251; - IList list = NonGenericIListFactory(count); - object value = CreateT(seed++); - while (list.Contains(value) || Enumerable.Contains(InvalidValues, value)) - value = CreateT(seed++); - Assert.Throws(() => list.Remove(value)); - } - } - - [Theory] + } + + [Theory] [MemberData(nameof(ValidCollectionSizes))] public void IList_NonGeneric_Remove_NullContainedInCollection(int count) { diff --git a/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs index 40ecec3eee75..fe092d361a5d 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeAttributeArgumentCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeAttributeArgumentCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeAttributeArgument[0] }; - yield return new object[] { new CodeAttributeArgument[] { new CodeAttributeArgument() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeAttributeArgumentArray_Works(CodeAttributeArgument[] value) - { - var collection = new CodeAttributeArgumentCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeAttributeArgumentCollection_Works(CodeAttributeArgument[] value) - { - var collection = new CodeAttributeArgumentCollection(new CodeAttributeArgumentCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeAttributeArgumentArray_Works(CodeAttributeArgument[] value) - { - var collection = new CodeAttributeArgumentCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeAttributeArgumentCollection_Works(CodeAttributeArgument[] value) - { - var collection = new CodeAttributeArgumentCollection(); - collection.AddRange(new CodeAttributeArgumentCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeAttributeArgumentCollection((CodeAttributeArgument[])null)); - Assert.Throws("value", () => new CodeAttributeArgumentCollection((CodeAttributeArgumentCollection)null)); - - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws("value", () => collection.AddRange((CodeAttributeArgument[])null)); - Assert.Throws("value", () => collection.AddRange((CodeAttributeArgumentCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeAttributeArgumentCollection(new CodeAttributeArgument[] { null })); - - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeAttributeArgument[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeAttributeArgumentCollection(); - - var value1 = new CodeAttributeArgument(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeAttributeArgument(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeAttributeArgument())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeAttributeArgumentCollectionTests : CodeCollectionTestBase + { + public override CodeAttributeArgumentCollection Ctor() => new CodeAttributeArgumentCollection(); + public override CodeAttributeArgumentCollection CtorArray(CodeAttributeArgument[] array) => new CodeAttributeArgumentCollection(array); + public override CodeAttributeArgumentCollection CtorCollection(CodeAttributeArgumentCollection collection) => new CodeAttributeArgumentCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws(null, () => collection.Remove(new CodeAttributeArgument())); - } + public override int Count(CodeAttributeArgumentCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeAttributeArgumentCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeAttributeArgument())); - } + public override CodeAttributeArgument GetItem(CodeAttributeArgumentCollection collection, int index) => collection[index]; + public override void SetItem(CodeAttributeArgumentCollection collection, int index, CodeAttributeArgument value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeAttributeArgument())); - } + public override void AddRange(CodeAttributeArgumentCollection collection, CodeAttributeArgument[] array) => collection.AddRange(array); + public override void AddRange(CodeAttributeArgumentCollection collection, CodeAttributeArgumentCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeAttributeArgumentCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeAttributeArgument()); - } + public override object Add(CodeAttributeArgumentCollection collection, CodeAttributeArgument obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeAttributeArgument(); - var value2 = new CodeAttributeArgument(); - var collection = new CodeAttributeArgumentCollection(); - collection.Add(value1); + public override void Insert(CodeAttributeArgumentCollection collection, int index, CodeAttributeArgument value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeAttributeArgumentCollection collection, CodeAttributeArgument value) => collection.Remove(value); - private static void VerifyCollection(CodeAttributeArgumentCollection collection, CodeAttributeArgument[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeAttributeArgument content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeAttributeArgumentCollection collection, CodeAttributeArgument value) => collection.IndexOf(value); + public override bool Contains(CodeAttributeArgumentCollection collection, CodeAttributeArgument value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeAttributeArgument[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]); - } - } - } + 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 index 09445f40c168..4e5e0f973fb8 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeAttributeDeclarationCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeAttributeDeclarationCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeAttributeDeclaration[0] }; - yield return new object[] { new CodeAttributeDeclaration[] { new CodeAttributeDeclaration() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeAttributeDeclarationArray_Works(CodeAttributeDeclaration[] value) - { - var collection = new CodeAttributeDeclarationCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeAttributeDeclarationCollection_Works(CodeAttributeDeclaration[] value) - { - var collection = new CodeAttributeDeclarationCollection(new CodeAttributeDeclarationCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeAttributeDeclarationArray_Works(CodeAttributeDeclaration[] value) - { - var collection = new CodeAttributeDeclarationCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeAttributeDeclarationCollection_Works(CodeAttributeDeclaration[] value) - { - var collection = new CodeAttributeDeclarationCollection(); - collection.AddRange(new CodeAttributeDeclarationCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeAttributeDeclarationCollection((CodeAttributeDeclaration[])null)); - Assert.Throws("value", () => new CodeAttributeDeclarationCollection((CodeAttributeDeclarationCollection)null)); - - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws("value", () => collection.AddRange((CodeAttributeDeclaration[])null)); - Assert.Throws("value", () => collection.AddRange((CodeAttributeDeclarationCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeAttributeDeclarationCollection(new CodeAttributeDeclaration[] { null })); - - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeAttributeDeclaration[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeAttributeDeclarationCollection(); - - var value1 = new CodeAttributeDeclaration(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeAttributeDeclaration(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeAttributeDeclaration())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeAttributeDeclarationCollectionTests : CodeCollectionTestBase + { + public override CodeAttributeDeclarationCollection Ctor() => new CodeAttributeDeclarationCollection(); + public override CodeAttributeDeclarationCollection CtorArray(CodeAttributeDeclaration[] array) => new CodeAttributeDeclarationCollection(array); + public override CodeAttributeDeclarationCollection CtorCollection(CodeAttributeDeclarationCollection collection) => new CodeAttributeDeclarationCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws(null, () => collection.Remove(new CodeAttributeDeclaration())); - } + public override int Count(CodeAttributeDeclarationCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeAttributeDeclaration())); - } + public override CodeAttributeDeclaration GetItem(CodeAttributeDeclarationCollection collection, int index) => collection[index]; + public override void SetItem(CodeAttributeDeclarationCollection collection, int index, CodeAttributeDeclaration value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeAttributeDeclaration())); - } + public override void AddRange(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration[] array) => collection.AddRange(array); + public override void AddRange(CodeAttributeDeclarationCollection collection, CodeAttributeDeclarationCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeAttributeDeclarationCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeAttributeDeclaration()); - } + public override object Add(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeAttributeDeclaration(); - var value2 = new CodeAttributeDeclaration(); - var collection = new CodeAttributeDeclarationCollection(); - collection.Add(value1); + public override void Insert(CodeAttributeDeclarationCollection collection, int index, CodeAttributeDeclaration value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration value) => collection.Remove(value); - private static void VerifyCollection(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeAttributeDeclaration content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration value) => collection.IndexOf(value); + public override bool Contains(CodeAttributeDeclarationCollection collection, CodeAttributeDeclaration value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeAttributeDeclaration[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]); - } - } - } + 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 index 30eeeb0c06d4..9130f6c24378 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeCatchClauseCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeCatchClauseCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeCatchClauseCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeCatchClause[0] }; - yield return new object[] { new CodeCatchClause[] { new CodeCatchClause() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeCatchClauseArray_Works(CodeCatchClause[] value) - { - var collection = new CodeCatchClauseCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeCatchClauseCollection_Works(CodeCatchClause[] value) - { - var collection = new CodeCatchClauseCollection(new CodeCatchClauseCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeCatchClauseArray_Works(CodeCatchClause[] value) - { - var collection = new CodeCatchClauseCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeCatchClauseCollection_Works(CodeCatchClause[] value) - { - var collection = new CodeCatchClauseCollection(); - collection.AddRange(new CodeCatchClauseCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeCatchClauseCollection((CodeCatchClause[])null)); - Assert.Throws("value", () => new CodeCatchClauseCollection((CodeCatchClauseCollection)null)); - - var collection = new CodeCatchClauseCollection(); - Assert.Throws("value", () => collection.AddRange((CodeCatchClause[])null)); - Assert.Throws("value", () => collection.AddRange((CodeCatchClauseCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeCatchClauseCollection(new CodeCatchClause[] { null })); - - var collection = new CodeCatchClauseCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeCatchClause[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeCatchClauseCollection(); - - var value1 = new CodeCatchClause(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeCatchClause(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeCatchClauseCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeCatchClauseCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeCatchClause())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeCatchClauseCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeCatchClauseCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeCatchClauseCollectionTests : CodeCollectionTestBase + { + public override CodeCatchClauseCollection Ctor() => new CodeCatchClauseCollection(); + public override CodeCatchClauseCollection CtorArray(CodeCatchClause[] array) => new CodeCatchClauseCollection(array); + public override CodeCatchClauseCollection CtorCollection(CodeCatchClauseCollection collection) => new CodeCatchClauseCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeCatchClauseCollection(); - Assert.Throws(null, () => collection.Remove(new CodeCatchClause())); - } + public override int Count(CodeCatchClauseCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeCatchClauseCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeCatchClause())); - } + public override CodeCatchClause GetItem(CodeCatchClauseCollection collection, int index) => collection[index]; + public override void SetItem(CodeCatchClauseCollection collection, int index, CodeCatchClause value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeCatchClauseCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeCatchClause())); - } + public override void AddRange(CodeCatchClauseCollection collection, CodeCatchClause[] array) => collection.AddRange(array); + public override void AddRange(CodeCatchClauseCollection collection, CodeCatchClauseCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeCatchClauseCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeCatchClause()); - } + public override object Add(CodeCatchClauseCollection collection, CodeCatchClause obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeCatchClause(); - var value2 = new CodeCatchClause(); - var collection = new CodeCatchClauseCollection(); - collection.Add(value1); + public override void Insert(CodeCatchClauseCollection collection, int index, CodeCatchClause value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeCatchClauseCollection collection, CodeCatchClause value) => collection.Remove(value); - private static void VerifyCollection(CodeCatchClauseCollection collection, CodeCatchClause[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeCatchClause content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeCatchClauseCollection collection, CodeCatchClause value) => collection.IndexOf(value); + public override bool Contains(CodeCatchClauseCollection collection, CodeCatchClause value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeCatchClause[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]); - } - } - } + 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 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 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("value", () => CtorArray(null)); + Assert.Throws("value", () => CtorCollection(null)); + + var collection = Ctor(); + Assert.Throws("value", () => AddRange(collection, (TItem[])null)); + Assert.Throws("value", () => AddRange(collection, (TCollection)null)); + } + + [Fact] + public void AddRange_NullObjectInValue_ThrowsArgumentNullException() + { + Assert.Throws("value", () => CtorArray(new TItem[] { null })); + + var collection = Ctor(); + Assert.Throws("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("value", () => Add(collection, null)); + } + + [Theory] + [InlineData(-1)] + [InlineData(1)] + public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) + { + var collection = Ctor(); + Assert.Throws("index", () => Insert(collection, index, new TItem())); + } + + [Fact] + public void Insert_Null_ThrowsArgumentNullException() + { + var collection = Ctor(); + Assert.Throws("value", () => Insert(collection, 0, null)); + } + + [Fact] + public void Remove_Null_ThrowsArgumentNullException() + { + var collection = Ctor(); + Assert.Throws("value", () => Remove(collection, null)); + } + + [Fact] + public void Remove_NoSuchObject_ThrowsArgumentException() + { + var collection = Ctor(); + Assert.Throws(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("index", () => GetItem(collection, index)); + Assert.Throws("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 index f9c0f3985f1a..84cc8fb41ae1 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeCommentStatementCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeCommentStatementCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeCommentStatementCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeCommentStatement[0] }; - yield return new object[] { new CodeCommentStatement[] { new CodeCommentStatement() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeCommentStatementArray_Works(CodeCommentStatement[] value) - { - var collection = new CodeCommentStatementCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeCommentStatementCollection_Works(CodeCommentStatement[] value) - { - var collection = new CodeCommentStatementCollection(new CodeCommentStatementCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeCommentStatementArray_Works(CodeCommentStatement[] value) - { - var collection = new CodeCommentStatementCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeCommentStatementCollection_Works(CodeCommentStatement[] value) - { - var collection = new CodeCommentStatementCollection(); - collection.AddRange(new CodeCommentStatementCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeCommentStatementCollection((CodeCommentStatement[])null)); - Assert.Throws("value", () => new CodeCommentStatementCollection((CodeCommentStatementCollection)null)); - - var collection = new CodeCommentStatementCollection(); - Assert.Throws("value", () => collection.AddRange((CodeCommentStatement[])null)); - Assert.Throws("value", () => collection.AddRange((CodeCommentStatementCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeCommentStatementCollection(new CodeCommentStatement[] { null })); - - var collection = new CodeCommentStatementCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeCommentStatement[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeCommentStatementCollection(); - - var value1 = new CodeCommentStatement(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeCommentStatement(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeCommentStatementCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeCommentStatementCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeCommentStatement())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeCommentStatementCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeCommentStatementCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeCommentStatementCollectionTests : CodeCollectionTestBase + { + public override CodeCommentStatementCollection Ctor() => new CodeCommentStatementCollection(); + public override CodeCommentStatementCollection CtorArray(CodeCommentStatement[] array) => new CodeCommentStatementCollection(array); + public override CodeCommentStatementCollection CtorCollection(CodeCommentStatementCollection collection) => new CodeCommentStatementCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeCommentStatementCollection(); - Assert.Throws(null, () => collection.Remove(new CodeCommentStatement())); - } + public override int Count(CodeCommentStatementCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeCommentStatementCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeCommentStatement())); - } + public override CodeCommentStatement GetItem(CodeCommentStatementCollection collection, int index) => collection[index]; + public override void SetItem(CodeCommentStatementCollection collection, int index, CodeCommentStatement value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeCommentStatementCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeCommentStatement())); - } + public override void AddRange(CodeCommentStatementCollection collection, CodeCommentStatement[] array) => collection.AddRange(array); + public override void AddRange(CodeCommentStatementCollection collection, CodeCommentStatementCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeCommentStatementCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeCommentStatement()); - } + public override object Add(CodeCommentStatementCollection collection, CodeCommentStatement obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeCommentStatement(); - var value2 = new CodeCommentStatement(); - var collection = new CodeCommentStatementCollection(); - collection.Add(value1); + public override void Insert(CodeCommentStatementCollection collection, int index, CodeCommentStatement value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeCommentStatementCollection collection, CodeCommentStatement value) => collection.Remove(value); - private static void VerifyCollection(CodeCommentStatementCollection collection, CodeCommentStatement[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeCommentStatement content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeCommentStatementCollection collection, CodeCommentStatement value) => collection.IndexOf(value); + public override bool Contains(CodeCommentStatementCollection collection, CodeCommentStatement value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeCommentStatement[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]); - } - } - } + 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 index 884889951595..44b52f1d042c 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeDirectiveCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeDirectiveCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeDirectiveCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeDirective[0] }; - yield return new object[] { new CodeDirective[] { new CodeDirective() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeDirectiveArray_Works(CodeDirective[] value) - { - var collection = new CodeDirectiveCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeDirectiveCollection_Works(CodeDirective[] value) - { - var collection = new CodeDirectiveCollection(new CodeDirectiveCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeDirectiveArray_Works(CodeDirective[] value) - { - var collection = new CodeDirectiveCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeDirectiveCollection_Works(CodeDirective[] value) - { - var collection = new CodeDirectiveCollection(); - collection.AddRange(new CodeDirectiveCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeDirectiveCollection((CodeDirective[])null)); - Assert.Throws("value", () => new CodeDirectiveCollection((CodeDirectiveCollection)null)); - - var collection = new CodeDirectiveCollection(); - Assert.Throws("value", () => collection.AddRange((CodeDirective[])null)); - Assert.Throws("value", () => collection.AddRange((CodeDirectiveCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeDirectiveCollection(new CodeDirective[] { null })); - - var collection = new CodeDirectiveCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeDirective[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeDirectiveCollection(); - - var value1 = new CodeDirective(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeDirective(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeDirectiveCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeDirectiveCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeDirective())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeDirectiveCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeDirectiveCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeDirectiveCollectionTests : CodeCollectionTestBase + { + public override CodeDirectiveCollection Ctor() => new CodeDirectiveCollection(); + public override CodeDirectiveCollection CtorArray(CodeDirective[] array) => new CodeDirectiveCollection(array); + public override CodeDirectiveCollection CtorCollection(CodeDirectiveCollection collection) => new CodeDirectiveCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeDirectiveCollection(); - Assert.Throws(null, () => collection.Remove(new CodeDirective())); - } + public override int Count(CodeDirectiveCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeDirectiveCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeDirective())); - } + public override CodeDirective GetItem(CodeDirectiveCollection collection, int index) => collection[index]; + public override void SetItem(CodeDirectiveCollection collection, int index, CodeDirective value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeDirectiveCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeDirective())); - } + public override void AddRange(CodeDirectiveCollection collection, CodeDirective[] array) => collection.AddRange(array); + public override void AddRange(CodeDirectiveCollection collection, CodeDirectiveCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeDirectiveCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeDirective()); - } + public override object Add(CodeDirectiveCollection collection, CodeDirective obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeDirective(); - var value2 = new CodeDirective(); - var collection = new CodeDirectiveCollection(); - collection.Add(value1); + public override void Insert(CodeDirectiveCollection collection, int index, CodeDirective value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeDirectiveCollection collection, CodeDirective value) => collection.Remove(value); - private static void VerifyCollection(CodeDirectiveCollection collection, CodeDirective[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeDirective content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeDirectiveCollection collection, CodeDirective value) => collection.IndexOf(value); + public override bool Contains(CodeDirectiveCollection collection, CodeDirective value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeDirective[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]); - } - } - } + 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 index 502b3d0a72ee..b386d309d8b3 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeExpressionCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeExpressionCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeExpressionCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeExpression[0] }; - yield return new object[] { new CodeExpression[] { new CodeExpression() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeExpressionArray_Works(CodeExpression[] value) - { - var collection = new CodeExpressionCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeExpressionCollection_Works(CodeExpression[] value) - { - var collection = new CodeExpressionCollection(new CodeExpressionCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeExpressionArray_Works(CodeExpression[] value) - { - var collection = new CodeExpressionCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeExpressionCollection_Works(CodeExpression[] value) - { - var collection = new CodeExpressionCollection(); - collection.AddRange(new CodeExpressionCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeExpressionCollection((CodeExpression[])null)); - Assert.Throws("value", () => new CodeExpressionCollection((CodeExpressionCollection)null)); - - var collection = new CodeExpressionCollection(); - Assert.Throws("value", () => collection.AddRange((CodeExpression[])null)); - Assert.Throws("value", () => collection.AddRange((CodeExpressionCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeExpressionCollection(new CodeExpression[] { null })); - - var collection = new CodeExpressionCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeExpression[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeExpressionCollection(); - - var value1 = new CodeExpression(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeExpression(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeExpressionCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeExpressionCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeExpression())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeExpressionCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeExpressionCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeExpressionCollectionTests : CodeCollectionTestBase + { + public override CodeExpressionCollection Ctor() => new CodeExpressionCollection(); + public override CodeExpressionCollection CtorArray(CodeExpression[] array) => new CodeExpressionCollection(array); + public override CodeExpressionCollection CtorCollection(CodeExpressionCollection collection) => new CodeExpressionCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeExpressionCollection(); - Assert.Throws(null, () => collection.Remove(new CodeExpression())); - } + public override int Count(CodeExpressionCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeExpressionCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeExpression())); - } + public override CodeExpression GetItem(CodeExpressionCollection collection, int index) => collection[index]; + public override void SetItem(CodeExpressionCollection collection, int index, CodeExpression value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeExpressionCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeExpression())); - } + public override void AddRange(CodeExpressionCollection collection, CodeExpression[] array) => collection.AddRange(array); + public override void AddRange(CodeExpressionCollection collection, CodeExpressionCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeExpressionCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeExpression()); - } + public override object Add(CodeExpressionCollection collection, CodeExpression obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeExpression(); - var value2 = new CodeExpression(); - var collection = new CodeExpressionCollection(); - collection.Add(value1); + public override void Insert(CodeExpressionCollection collection, int index, CodeExpression value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeExpressionCollection collection, CodeExpression value) => collection.Remove(value); - private static void VerifyCollection(CodeExpressionCollection collection, CodeExpression[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeExpression content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeExpressionCollection collection, CodeExpression value) => collection.IndexOf(value); + public override bool Contains(CodeExpressionCollection collection, CodeExpression value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeExpression[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]); - } - } - } + 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 index 7e98103fe5ad..25fe39eba257 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeNamespaceCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeNamespaceCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeNamespaceCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeNamespace[0] }; - yield return new object[] { new CodeNamespace[] { new CodeNamespace() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeNamespaceArray_Works(CodeNamespace[] value) - { - var collection = new CodeNamespaceCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeNamespaceCollection_Works(CodeNamespace[] value) - { - var collection = new CodeNamespaceCollection(new CodeNamespaceCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeNamespaceArray_Works(CodeNamespace[] value) - { - var collection = new CodeNamespaceCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeNamespaceCollection_Works(CodeNamespace[] value) - { - var collection = new CodeNamespaceCollection(); - collection.AddRange(new CodeNamespaceCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeNamespaceCollection((CodeNamespace[])null)); - Assert.Throws("value", () => new CodeNamespaceCollection((CodeNamespaceCollection)null)); - - var collection = new CodeNamespaceCollection(); - Assert.Throws("value", () => collection.AddRange((CodeNamespace[])null)); - Assert.Throws("value", () => collection.AddRange((CodeNamespaceCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeNamespaceCollection(new CodeNamespace[] { null })); - - var collection = new CodeNamespaceCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeNamespace[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeNamespaceCollection(); - - var value1 = new CodeNamespace(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeNamespace(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeNamespaceCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeNamespaceCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeNamespace())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeNamespaceCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeNamespaceCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeNamespaceCollectionTests : CodeCollectionTestBase + { + public override CodeNamespaceCollection Ctor() => new CodeNamespaceCollection(); + public override CodeNamespaceCollection CtorArray(CodeNamespace[] array) => new CodeNamespaceCollection(array); + public override CodeNamespaceCollection CtorCollection(CodeNamespaceCollection collection) => new CodeNamespaceCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeNamespaceCollection(); - Assert.Throws(null, () => collection.Remove(new CodeNamespace())); - } + public override int Count(CodeNamespaceCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeNamespaceCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeNamespace())); - } + public override CodeNamespace GetItem(CodeNamespaceCollection collection, int index) => collection[index]; + public override void SetItem(CodeNamespaceCollection collection, int index, CodeNamespace value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeNamespaceCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeNamespace())); - } + public override void AddRange(CodeNamespaceCollection collection, CodeNamespace[] array) => collection.AddRange(array); + public override void AddRange(CodeNamespaceCollection collection, CodeNamespaceCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeNamespaceCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeNamespace()); - } + public override object Add(CodeNamespaceCollection collection, CodeNamespace obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeNamespace(); - var value2 = new CodeNamespace(); - var collection = new CodeNamespaceCollection(); - collection.Add(value1); + public override void Insert(CodeNamespaceCollection collection, int index, CodeNamespace value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeNamespaceCollection collection, CodeNamespace value) => collection.Remove(value); - 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]); - } + public override int IndexOf(CodeNamespaceCollection collection, CodeNamespace value) => collection.IndexOf(value); + public override bool Contains(CodeNamespaceCollection collection, CodeNamespace value) => collection.Contains(value); - 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]); - } - } - } + public override void CopyTo(CodeNamespaceCollection collection, CodeNamespace[] array, int index) => collection.CopyTo(array, index); + } } diff --git a/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs index 3147bb28adcb..b27ce22e09e4 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeParameterDeclarationExpressionCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeParameterDeclarationExpressionCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeParameterDeclarationExpression[0] }; - yield return new object[] { new CodeParameterDeclarationExpression[] { new CodeParameterDeclarationExpression() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeParameterDeclarationExpressionArray_Works(CodeParameterDeclarationExpression[] value) - { - var collection = new CodeParameterDeclarationExpressionCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeParameterDeclarationExpressionCollection_Works(CodeParameterDeclarationExpression[] value) - { - var collection = new CodeParameterDeclarationExpressionCollection(new CodeParameterDeclarationExpressionCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeParameterDeclarationExpressionArray_Works(CodeParameterDeclarationExpression[] value) - { - var collection = new CodeParameterDeclarationExpressionCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeParameterDeclarationExpressionCollection_Works(CodeParameterDeclarationExpression[] value) - { - var collection = new CodeParameterDeclarationExpressionCollection(); - collection.AddRange(new CodeParameterDeclarationExpressionCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeParameterDeclarationExpressionCollection((CodeParameterDeclarationExpression[])null)); - Assert.Throws("value", () => new CodeParameterDeclarationExpressionCollection((CodeParameterDeclarationExpressionCollection)null)); - - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws("value", () => collection.AddRange((CodeParameterDeclarationExpression[])null)); - Assert.Throws("value", () => collection.AddRange((CodeParameterDeclarationExpressionCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeParameterDeclarationExpressionCollection(new CodeParameterDeclarationExpression[] { null })); - - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeParameterDeclarationExpression[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - - var value1 = new CodeParameterDeclarationExpression(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeParameterDeclarationExpression(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeParameterDeclarationExpression())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeParameterDeclarationExpressionCollectionTests : CodeCollectionTestBase + { + public override CodeParameterDeclarationExpressionCollection Ctor() => new CodeParameterDeclarationExpressionCollection(); + public override CodeParameterDeclarationExpressionCollection CtorArray(CodeParameterDeclarationExpression[] array) => new CodeParameterDeclarationExpressionCollection(array); + public override CodeParameterDeclarationExpressionCollection CtorCollection(CodeParameterDeclarationExpressionCollection collection) => new CodeParameterDeclarationExpressionCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws(null, () => collection.Remove(new CodeParameterDeclarationExpression())); - } + public override int Count(CodeParameterDeclarationExpressionCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeParameterDeclarationExpression())); - } + public override CodeParameterDeclarationExpression GetItem(CodeParameterDeclarationExpressionCollection collection, int index) => collection[index]; + public override void SetItem(CodeParameterDeclarationExpressionCollection collection, int index, CodeParameterDeclarationExpression value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeParameterDeclarationExpression())); - } + public override void AddRange(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression[] array) => collection.AddRange(array); + public override void AddRange(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpressionCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeParameterDeclarationExpressionCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeParameterDeclarationExpression()); - } + public override object Add(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeParameterDeclarationExpression(); - var value2 = new CodeParameterDeclarationExpression(); - var collection = new CodeParameterDeclarationExpressionCollection(); - collection.Add(value1); + public override void Insert(CodeParameterDeclarationExpressionCollection collection, int index, CodeParameterDeclarationExpression value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression value) => collection.Remove(value); - private static void VerifyCollection(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeParameterDeclarationExpression content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression value) => collection.IndexOf(value); + public override bool Contains(CodeParameterDeclarationExpressionCollection collection, CodeParameterDeclarationExpression value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeParameterDeclarationExpression[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]); - } - } - } + 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 index e95a6cf05d5f..ab02c770a580 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeStatementCollectionTests.cs @@ -7,207 +7,44 @@ namespace System.CodeDom.Tests { - public class CodeStatementCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeStatementCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeStatement[0] }; - yield return new object[] { new CodeStatement[] { new CodeStatement() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeStatementArray_Works(CodeStatement[] value) - { - var collection = new CodeStatementCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeStatementCollection_Works(CodeStatement[] value) - { - var collection = new CodeStatementCollection(new CodeStatementCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeStatementArray_Works(CodeStatement[] value) - { - var collection = new CodeStatementCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeStatementCollection_Works(CodeStatement[] value) - { - var collection = new CodeStatementCollection(); - collection.AddRange(new CodeStatementCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeStatementCollection((CodeStatement[])null)); - Assert.Throws("value", () => new CodeStatementCollection((CodeStatementCollection)null)); - - var collection = new CodeStatementCollection(); - Assert.Throws("value", () => collection.AddRange((CodeStatement[])null)); - Assert.Throws("value", () => collection.AddRange((CodeStatementCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeStatementCollection(new CodeStatement[] { null })); - - var collection = new CodeStatementCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeStatement[] { null })); - } - - [Fact] - public void Add_CodeStatement_Insert_Remove() - { - var collection = new CodeStatementCollection(); - - var value1 = new CodeStatement(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeStatement(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable 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); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeStatementCollection(); - Assert.Throws("value", () => collection.Add((CodeStatement)null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeStatementCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeStatement())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeStatementCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeStatementCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } - - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeStatementCollection(); - Assert.Throws(null, () => collection.Remove(new CodeStatement())); - } - - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeStatementCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeStatement())); - } - - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeStatementCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeStatement())); - } - - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeStatementCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeStatement()); - } - - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeStatement(); - var value2 = new CodeStatement(); - var collection = new CodeStatementCollection(); - collection.Add(value1); - - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } - - private static void VerifyCollection(CodeStatementCollection collection, CodeStatement[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeStatement 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 CodeStatement[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]); - } - } - } + public class CodeStatementCollectionTests : CodeCollectionTestBase + { + 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 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 index 130c717302c1..bbdcefac6628 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeDeclarationCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeTypeDeclarationCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeTypeDeclaration[0] }; - yield return new object[] { new CodeTypeDeclaration[] { new CodeTypeDeclaration() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeTypeDeclarationArray_Works(CodeTypeDeclaration[] value) - { - var collection = new CodeTypeDeclarationCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeTypeDeclarationCollection_Works(CodeTypeDeclaration[] value) - { - var collection = new CodeTypeDeclarationCollection(new CodeTypeDeclarationCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeDeclarationArray_Works(CodeTypeDeclaration[] value) - { - var collection = new CodeTypeDeclarationCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeDeclarationCollection_Works(CodeTypeDeclaration[] value) - { - var collection = new CodeTypeDeclarationCollection(); - collection.AddRange(new CodeTypeDeclarationCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeDeclarationCollection((CodeTypeDeclaration[])null)); - Assert.Throws("value", () => new CodeTypeDeclarationCollection((CodeTypeDeclarationCollection)null)); - - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws("value", () => collection.AddRange((CodeTypeDeclaration[])null)); - Assert.Throws("value", () => collection.AddRange((CodeTypeDeclarationCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeDeclarationCollection(new CodeTypeDeclaration[] { null })); - - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeTypeDeclaration[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeTypeDeclarationCollection(); - - var value1 = new CodeTypeDeclaration(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeTypeDeclaration(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeTypeDeclaration())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeTypeDeclarationCollectionTests : CodeCollectionTestBase + { + public override CodeTypeDeclarationCollection Ctor() => new CodeTypeDeclarationCollection(); + public override CodeTypeDeclarationCollection CtorArray(CodeTypeDeclaration[] array) => new CodeTypeDeclarationCollection(array); + public override CodeTypeDeclarationCollection CtorCollection(CodeTypeDeclarationCollection collection) => new CodeTypeDeclarationCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws(null, () => collection.Remove(new CodeTypeDeclaration())); - } + public override int Count(CodeTypeDeclarationCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeDeclarationCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeTypeDeclaration())); - } + public override CodeTypeDeclaration GetItem(CodeTypeDeclarationCollection collection, int index) => collection[index]; + public override void SetItem(CodeTypeDeclarationCollection collection, int index, CodeTypeDeclaration value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeTypeDeclaration())); - } + public override void AddRange(CodeTypeDeclarationCollection collection, CodeTypeDeclaration[] array) => collection.AddRange(array); + public override void AddRange(CodeTypeDeclarationCollection collection, CodeTypeDeclarationCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeDeclarationCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeTypeDeclaration()); - } + public override object Add(CodeTypeDeclarationCollection collection, CodeTypeDeclaration obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeTypeDeclaration(); - var value2 = new CodeTypeDeclaration(); - var collection = new CodeTypeDeclarationCollection(); - collection.Add(value1); + public override void Insert(CodeTypeDeclarationCollection collection, int index, CodeTypeDeclaration value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeTypeDeclarationCollection collection, CodeTypeDeclaration value) => collection.Remove(value); - private static void VerifyCollection(CodeTypeDeclarationCollection collection, CodeTypeDeclaration[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeTypeDeclaration content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeTypeDeclarationCollection collection, CodeTypeDeclaration value) => collection.IndexOf(value); + public override bool Contains(CodeTypeDeclarationCollection collection, CodeTypeDeclaration value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeTypeDeclaration[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]); - } - } - } + 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 index 9c44a5716b17..51a43f9926d3 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeMemberCollectionTests.cs @@ -2,197 +2,31 @@ // 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 CodeTypeMemberCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeTypeMemberCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeTypeMember[0] }; - yield return new object[] { new CodeTypeMember[] { new CodeTypeMember() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeTypeMemberArray_Works(CodeTypeMember[] value) - { - var collection = new CodeTypeMemberCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeTypeMemberCollection_Works(CodeTypeMember[] value) - { - var collection = new CodeTypeMemberCollection(new CodeTypeMemberCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeMemberArray_Works(CodeTypeMember[] value) - { - var collection = new CodeTypeMemberCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeMemberCollection_Works(CodeTypeMember[] value) - { - var collection = new CodeTypeMemberCollection(); - collection.AddRange(new CodeTypeMemberCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeMemberCollection((CodeTypeMember[])null)); - Assert.Throws("value", () => new CodeTypeMemberCollection((CodeTypeMemberCollection)null)); - - var collection = new CodeTypeMemberCollection(); - Assert.Throws("value", () => collection.AddRange((CodeTypeMember[])null)); - Assert.Throws("value", () => collection.AddRange((CodeTypeMemberCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeMemberCollection(new CodeTypeMember[] { null })); - - var collection = new CodeTypeMemberCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeTypeMember[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CodeTypeMemberCollection(); - - var value1 = new CodeTypeMember(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeTypeMember(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeMemberCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeMemberCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeTypeMember())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeMemberCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeMemberCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } + public class CodeTypeMemberCollectionTests : CodeCollectionTestBase + { + public override CodeTypeMemberCollection Ctor() => new CodeTypeMemberCollection(); + public override CodeTypeMemberCollection CtorArray(CodeTypeMember[] array) => new CodeTypeMemberCollection(array); + public override CodeTypeMemberCollection CtorCollection(CodeTypeMemberCollection collection) => new CodeTypeMemberCollection(collection); - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeTypeMemberCollection(); - Assert.Throws(null, () => collection.Remove(new CodeTypeMember())); - } + public override int Count(CodeTypeMemberCollection collection) => collection.Count; - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeMemberCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeTypeMember())); - } + public override CodeTypeMember GetItem(CodeTypeMemberCollection collection, int index) => collection[index]; + public override void SetItem(CodeTypeMemberCollection collection, int index, CodeTypeMember value) => collection[index] = value; - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeMemberCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeTypeMember())); - } + public override void AddRange(CodeTypeMemberCollection collection, CodeTypeMember[] array) => collection.AddRange(array); + public override void AddRange(CodeTypeMemberCollection collection, CodeTypeMemberCollection value) => collection.AddRange(value); - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeMemberCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeTypeMember()); - } + public override object Add(CodeTypeMemberCollection collection, CodeTypeMember obj) => collection.Add(obj); - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeTypeMember(); - var value2 = new CodeTypeMember(); - var collection = new CodeTypeMemberCollection(); - collection.Add(value1); + public override void Insert(CodeTypeMemberCollection collection, int index, CodeTypeMember value) => collection.Insert(index, value); - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } + public override void Remove(CodeTypeMemberCollection collection, CodeTypeMember value) => collection.Remove(value); - private static void VerifyCollection(CodeTypeMemberCollection collection, CodeTypeMember[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeTypeMember content = contents[i]; - Assert.Equal(i, collection.IndexOf(content)); - Assert.True(collection.Contains(content)); - Assert.Same(content, collection[i]); - } + public override int IndexOf(CodeTypeMemberCollection collection, CodeTypeMember value) => collection.IndexOf(value); + public override bool Contains(CodeTypeMemberCollection collection, CodeTypeMember value) => collection.Contains(value); - const int Index = 1; - var copy = new CodeTypeMember[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]); - } - } - } + 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 index c84897c76256..2d785f63e8ab 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeParameterCollectionTests.cs @@ -2,208 +2,44 @@ // 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 CodeTypeParameterCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeTypeParameterCollection(); - Assert.Equal(0, collection.Count); - } + public class CodeTypeParameterCollectionTests : CodeCollectionTestBase + { + 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 static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeTypeParameter[0] }; - yield return new object[] { new CodeTypeParameter[] { new CodeTypeParameter() } }; - } + public override int Count(CodeTypeParameterCollection collection) => collection.Count; - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeTypeParameterArray_Works(CodeTypeParameter[] value) - { - var collection = new CodeTypeParameterCollection(value); - VerifyCollection(collection, value); - } + public override CodeTypeParameter GetItem(CodeTypeParameterCollection collection, int index) => collection[index]; + public override void SetItem(CodeTypeParameterCollection collection, int index, CodeTypeParameter value) => collection[index] = value; - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeTypeParameterCollection_Works(CodeTypeParameter[] value) - { - var collection = new CodeTypeParameterCollection(new CodeTypeParameterCollection(value)); - VerifyCollection(collection, value); - } + public override void AddRange(CodeTypeParameterCollection collection, CodeTypeParameter[] array) => collection.AddRange(array); + public override void AddRange(CodeTypeParameterCollection collection, CodeTypeParameterCollection value) => collection.AddRange(value); - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeParameterArray_Works(CodeTypeParameter[] value) - { - var collection = new CodeTypeParameterCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } + public override object Add(CodeTypeParameterCollection collection, CodeTypeParameter obj) => collection.Add(obj); - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeParameterCollection_Works(CodeTypeParameter[] value) - { - var collection = new CodeTypeParameterCollection(); - collection.AddRange(new CodeTypeParameterCollection(value)); - VerifyCollection(collection, value); - } + public override void Insert(CodeTypeParameterCollection collection, int index, CodeTypeParameter value) => collection.Insert(index, value); - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeParameterCollection((CodeTypeParameter[])null)); - Assert.Throws("value", () => new CodeTypeParameterCollection((CodeTypeParameterCollection)null)); + public override void Remove(CodeTypeParameterCollection collection, CodeTypeParameter value) => collection.Remove(value); - var collection = new CodeTypeParameterCollection(); - Assert.Throws("value", () => collection.AddRange((CodeTypeParameter[])null)); - Assert.Throws("value", () => collection.AddRange((CodeTypeParameterCollection)null)); - } + public override int IndexOf(CodeTypeParameterCollection collection, CodeTypeParameter value) => collection.IndexOf(value); + public override bool Contains(CodeTypeParameterCollection collection, CodeTypeParameter value) => collection.Contains(value); - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeParameterCollection(new CodeTypeParameter[] { null })); + public override void CopyTo(CodeTypeParameterCollection collection, CodeTypeParameter[] array, int index) => collection.CopyTo(array, index); - var collection = new CodeTypeParameterCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeTypeParameter[] { null })); - } - - [Fact] - public void Add_CodeTypeParameter_Insert_Remove() - { - var collection = new CodeTypeParameterCollection(); - - var value1 = new CodeTypeParameter(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeTypeParameter(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [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); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeParameterCollection(); - Assert.Throws("value", () => collection.Add((CodeTypeParameter)null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeParameterCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeTypeParameter())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeParameterCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeParameterCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } - - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeTypeParameterCollection(); - Assert.Throws(null, () => collection.Remove(new CodeTypeParameter())); - } - - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeParameterCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeTypeParameter())); - } - - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeParameterCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeTypeParameter())); - } - - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeParameterCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeTypeParameter()); - } - - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeTypeParameter(); - var value2 = new CodeTypeParameter(); - var collection = new CodeTypeParameterCollection(); - collection.Add(value1); - - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } - - private static void VerifyCollection(CodeTypeParameterCollection collection, CodeTypeParameter[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeTypeParameter 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 CodeTypeParameter[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]); - } - } - } + [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 index 5bd95f494493..f5a05a91287f 100644 --- a/src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CodeTypeReferenceCollectionTests.cs @@ -2,218 +2,60 @@ // 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 CodeTypeReferenceCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CodeTypeReferenceCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CodeTypeReference[0] }; - yield return new object[] { new CodeTypeReference[] { new CodeTypeReference() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CodeTypeReferenceArray_Works(CodeTypeReference[] value) - { - var collection = new CodeTypeReferenceCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CodeTypeReferenceCollection_Works(CodeTypeReference[] value) - { - var collection = new CodeTypeReferenceCollection(new CodeTypeReferenceCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeReferenceArray_Works(CodeTypeReference[] value) - { - var collection = new CodeTypeReferenceCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CodeTypeReferenceCollection_Works(CodeTypeReference[] value) - { - var collection = new CodeTypeReferenceCollection(); - collection.AddRange(new CodeTypeReferenceCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeReferenceCollection((CodeTypeReference[])null)); - Assert.Throws("value", () => new CodeTypeReferenceCollection((CodeTypeReferenceCollection)null)); - - var collection = new CodeTypeReferenceCollection(); - Assert.Throws("value", () => collection.AddRange((CodeTypeReference[])null)); - Assert.Throws("value", () => collection.AddRange((CodeTypeReferenceCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CodeTypeReferenceCollection(new CodeTypeReference[] { null })); - - var collection = new CodeTypeReferenceCollection(); - Assert.Throws("value", () => collection.AddRange(new CodeTypeReference[] { null })); - } - - [Fact] - public void Add_CodeTypeReference_Insert_Remove() - { - var collection = new CodeTypeReferenceCollection(); - - var value1 = new CodeTypeReference(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CodeTypeReference(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [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_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeReferenceCollection(); - Assert.Throws("value", () => collection.Add((CodeTypeReference)null)); - Assert.Throws("type", () => collection.Add((Type)null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeReferenceCollection(); - Assert.Throws("index", () => collection.Insert(index, new CodeTypeReference())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeReferenceCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CodeTypeReferenceCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } - - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CodeTypeReferenceCollection(); - Assert.Throws(null, () => collection.Remove(new CodeTypeReference())); - } - - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeReferenceCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CodeTypeReference())); - } - - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CodeTypeReferenceCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CodeTypeReference())); - } - - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CodeTypeReferenceCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CodeTypeReference()); - } - - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CodeTypeReference(); - var value2 = new CodeTypeReference(); - var collection = new CodeTypeReferenceCollection(); - collection.Add(value1); - - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } - - private static void VerifyCollection(CodeTypeReferenceCollection collection, CodeTypeReference[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CodeTypeReference 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 CodeTypeReference[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]); - } - } - } + public class CodeTypeReferenceCollectionTests : CodeCollectionTestBase + { + 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("type", () => collection.Add((Type)null)); + } + } } diff --git a/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs b/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs index a274c91e7501..df22879a7111 100644 --- a/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs +++ b/src/System.CodeDom/tests/CodeCollections/CompilerErrorCollectionTests.cs @@ -1,263 +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 System.Collections.Generic; using Xunit; namespace System.CodeDom.Tests { - public class CompilerErrorCollectionTests - { - [Fact] - public void Ctor_IsEmpty() - { - var collection = new CompilerErrorCollection(); - Assert.Equal(0, collection.Count); - } - - public static IEnumerable AddRange_TestData() - { - yield return new object[] { new CompilerError[0] }; - yield return new object[] { new CompilerError[] { new CompilerError() } }; - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor__CompilerErrorArray_Works(CompilerError[] value) - { - var collection = new CompilerErrorCollection(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void Ctor_CompilerErrorCollection_Works(CompilerError[] value) - { - var collection = new CompilerErrorCollection(new CompilerErrorCollection(value)); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CompilerErrorArray_Works(CompilerError[] value) - { - var collection = new CompilerErrorCollection(); - collection.AddRange(value); - VerifyCollection(collection, value); - } - - [Theory] - [MemberData(nameof(AddRange_TestData))] - public void AddRange_CompilerErrorCollection_Works(CompilerError[] value) - { - var collection = new CompilerErrorCollection(); - collection.AddRange(new CompilerErrorCollection(value)); - VerifyCollection(collection, value); - } - - [Fact] - public void AddRange_Null_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CompilerErrorCollection((CompilerError[])null)); - Assert.Throws("value", () => new CompilerErrorCollection((CompilerErrorCollection)null)); - - var collection = new CompilerErrorCollection(); - Assert.Throws("value", () => collection.AddRange((CompilerError[])null)); - Assert.Throws("value", () => collection.AddRange((CompilerErrorCollection)null)); - } - - [Fact] - public void AddRange_NullObjectInValue_ThrowsArgumentNullException() - { - Assert.Throws("value", () => new CompilerErrorCollection(new CompilerError[] { null })); - - var collection = new CompilerErrorCollection(); - Assert.Throws("value", () => collection.AddRange(new CompilerError[] { null })); - } - - [Fact] - public void Add_Insert_Remove() - { - var collection = new CompilerErrorCollection(); - - var value1 = new CompilerError(); - Assert.Equal(0, collection.Add(value1)); - Assert.Equal(1, collection.Count); - Assert.Equal(value1, collection[0]); - - var value2 = new CompilerError(); - collection.Insert(0, value2); - Assert.Equal(2, collection.Count); - Assert.Same(value2, collection[0]); - - collection.Remove(value1); - Assert.Equal(1, collection.Count); - - collection.Remove(value2); - Assert.Equal(0, collection.Count); - } - - [Fact] - public void Add_Null_ThrowsArgumentNullException() - { - var collection = new CompilerErrorCollection(); - Assert.Throws("value", () => collection.Add(null)); - } - - [Theory] - [InlineData(-1)] - [InlineData(1)] - public void Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CompilerErrorCollection(); - Assert.Throws("index", () => collection.Insert(index, new CompilerError())); - } - - [Fact] - public void Insert_Null_ThrowsArgumentNullException() - { - var collection = new CompilerErrorCollection(); - Assert.Throws("value", () => collection.Insert(0, null)); - } - - [Fact] - public void Remove_Null_ThrowsArgumentNullException() - { - var collection = new CompilerErrorCollection(); - Assert.Throws("value", () => collection.Remove(null)); - } - - [Fact] - public void Remove_NoSuchObject_ThrowsArgumentException() - { - var collection = new CompilerErrorCollection(); - Assert.Throws(null, () => collection.Remove(new CompilerError())); - } - - [Fact] - public void Contains_NoSuchObject_ReturnsMinusOne() - { - var collection = new CompilerErrorCollection(); - Assert.False(collection.Contains(null)); - Assert.False(collection.Contains(new CompilerError())); - } - - [Fact] - public void IndexOf_NoSuchObject_ReturnsMinusOne() - { - var collection = new CompilerErrorCollection(); - Assert.Equal(-1, collection.IndexOf(null)); - Assert.Equal(-1, collection.IndexOf(new CompilerError())); - } - - [Theory] - [InlineData(-1)] - [InlineData(0)] - public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) - { - var collection = new CompilerErrorCollection(); - Assert.Throws("index", () => collection[index]); - Assert.Throws("index", () => collection[index] = new CompilerError()); - } - - [Fact] - public void ItemSet_Get_ReturnsExpected() - { - var value1 = new CompilerError(); - var value2 = new CompilerError(); - var collection = new CompilerErrorCollection(); - collection.Add(value1); - - collection[0] = value2; - Assert.Equal(1, collection.Count); - Assert.Same(value2, collection[0]); - } - - [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); - } - - private static void VerifyCollection(CompilerErrorCollection collection, CompilerError[] contents) - { - Assert.Equal(contents.Length, collection.Count); - for (int i = 0; i < contents.Length; i++) - { - CompilerError 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 CompilerError[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]); - } - } - } + public class CompilerErrorCollectionTests : CodeCollectionTestBase + { + 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 f934782e1b05..ef99221b134d 100644 --- a/src/System.CodeDom/tests/System.CodeDom.Tests.csproj +++ b/src/System.CodeDom/tests/System.CodeDom.Tests.csproj @@ -12,13 +12,14 @@ + + -