Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Make mutable generic collection interfaces implement read-only collection interfaces #95830

Merged
merged 20 commits into from
Apr 24, 2024
+490 −164
Merged

Make mutable generic collection interfaces implement read-only collection interfaces #95830

Changes from 1 commit
Commits
Show all changes
20 commits
Select commit Hold shift + click to select a range
9f3d848
Make mutable generic collection interfaces implement read-only collec…
TylerBrinkley Dec 8, 2023
df31e3b
More updates
TylerBrinkley Dec 9, 2023
e2c9b7c
Fix build
TylerBrinkley Dec 9, 2023
4e81afc
Update refs
TylerBrinkley Dec 10, 2023
2a873e5
Add DIM's to ref also
TylerBrinkley Dec 10, 2023
a7d4cbf
fixes
TylerBrinkley Dec 10, 2023
5089b36
Try to fix arrays
TylerBrinkley Dec 11, 2023
27c9fe6
Moved dim's to the end of the interfaces. Made the tests support .NET…
TylerBrinkley Dec 12, 2023
b3f7aae
Small fix
TylerBrinkley Dec 12, 2023
27c5fdf
Small fix
TylerBrinkley Dec 12, 2023
140f43b
Fix build
TylerBrinkley Dec 12, 2023
888eb0b
Fix
TylerBrinkley Dec 12, 2023
f701940
Cleanup
TylerBrinkley Dec 12, 2023
6be8e51
Merge branch 'main' into issue-31001
eiriktsarpalis Jan 8, 2024
0580aae
Incorporate #96672
TylerBrinkley Jan 9, 2024
de36206
Merge branch 'main' into issue-31001
TylerBrinkley Jan 22, 2024
25a6a93
Merge remote-tracking branch 'dotnet/main' into issue-31001
tannergooding Mar 2, 2024
79fff71
Check the correct inheritanceDepth in vm/array.cpp
tannergooding Mar 2, 2024
11d49dd
Merge branch 'main' into issue-31001
tannergooding Apr 17, 2024
68c768d
Merge branch 'main' into issue-31001
eiriktsarpalis Apr 23, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
More updates
  • Loading branch information
@TylerBrinkley
TylerBrinkley committed Dec 9, 2023
commit df31e3b9ba2ab9728cd209bf067ecf6a2131a793
4 changes: 2 additions & 2 deletions src/libraries/Common/tests/System/Collections/CollectionAsserts.cs
View file
Original file line number Diff line number Diff line change
@@ -35,7 +35,7 @@ public static void Equal(ICollection expected, ICollection actual)
Assert.False(a.MoveNext(), "actual has more elements");
}

public static void Equal<T>(ICollection<T> expected, ICollection<T> actual)
public static void Equal<T>(IReadOnlyCollection<T> expected, IReadOnlyCollection<T> actual)
{
Assert.Equal(expected == null, actual == null);
if (expected == null)
@@ -80,7 +80,7 @@ public static void EqualUnordered(ICollection expected, ICollection actual)
Assert.Equal(e[null].Count(), a[null].Count());
}

public static void EqualUnordered<T>(ICollection<T> expected, ICollection<T> actual)
public static void EqualUnordered<T>(IReadOnlyCollection<T> expected, IReadOnlyCollection<T> actual)
{
Assert.Equal(expected == null, actual == null);
if (expected == null)
40 changes: 40 additions & 0 deletions src/libraries/Common/tests/System/Collections/ICollection.Generic.Tests.cs
View file
Original file line number Diff line number Diff line change
@@ -146,8 +146,10 @@ public virtual void ICollection_Generic_Add_DefaultValue(int count)
if (DefaultValueAllowed && !IsReadOnly && !AddRemoveClear_ThrowsNotSupported)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
collection.Add(default(T));
Assert.Equal(count + 1, collection.Count);
Assert.Equal(count + 1, readOnlyCollection.Count);
}
}

@@ -160,10 +162,12 @@ public void ICollection_Generic_Add_InvalidValueToMiddleOfCollection(int count)
Assert.All(InvalidValues, invalidValue =>
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
collection.Add(invalidValue);
for (int i = 0; i < count; i++)
collection.Add(CreateT(i));
Assert.Equal(count * 2, collection.Count);
Assert.Equal(count * 2, readOnlyCollection.Count);
});
}
}
@@ -177,10 +181,12 @@ public void ICollection_Generic_Add_InvalidValueToBeginningOfCollection(int coun
Assert.All(InvalidValues, invalidValue =>
{
ICollection<T> collection = GenericICollectionFactory(0);
IReadOnlyCollection<T> readOnlyCollection = collection;
collection.Add(invalidValue);
for (int i = 0; i < count; i++)
collection.Add(CreateT(i));
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
});
}
}
@@ -194,8 +200,10 @@ public void ICollection_Generic_Add_InvalidValueToEndOfCollection(int count)
Assert.All(InvalidValues, invalidValue =>
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
collection.Add(invalidValue);
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
});
}
}
@@ -207,10 +215,12 @@ public void ICollection_Generic_Add_DuplicateValue(int count)
if (!IsReadOnly && !AddRemoveClear_ThrowsNotSupported && DuplicateValuesAllowed)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
T duplicateValue = CreateT(700);
collection.Add(duplicateValue);
collection.Add(duplicateValue);
Assert.Equal(count + 2, collection.Count);
Assert.Equal(count + 2, readOnlyCollection.Count);
}
}

@@ -221,9 +231,11 @@ public void ICollection_Generic_Add_AfterCallingClear(int count)
if (!IsReadOnly && !AddRemoveClear_ThrowsNotSupported)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
collection.Clear();
AddToCollection(collection, 5);
Assert.Equal(5, collection.Count);
Assert.Equal(5, readOnlyCollection.Count);
}
}

@@ -235,6 +247,7 @@ public void ICollection_Generic_Add_AfterRemovingAnyValue(int count)
{
int seed = 840;
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
List<T> items = collection.ToList();
T toAdd = CreateT(seed++);
while (collection.Contains(toAdd))
@@ -249,6 +262,7 @@ public void ICollection_Generic_Add_AfterRemovingAnyValue(int count)
collection.Add(toAdd);
items.Add(toAdd);
CollectionAsserts.EqualUnordered(items, collection);
CollectionAsserts.EqualUnordered(items, readOnlyCollection);
}
}

@@ -259,11 +273,13 @@ public void ICollection_Generic_Add_AfterRemovingAllItems(int count)
if (!IsReadOnly && !AddRemoveClear_ThrowsNotSupported)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
List<T> itemsToRemove = collection.ToList();
for (int i = 0; i < count; i++)
collection.Remove(collection.ElementAt(0));
collection.Add(CreateT(254));
Assert.Equal(1, collection.Count);
Assert.Equal(1, readOnlyCollection.Count);
}
}

@@ -274,8 +290,10 @@ public void ICollection_Generic_Add_ToReadOnlyCollection(int count)
if (IsReadOnly || AddRemoveClear_ThrowsNotSupported)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
Assert.Throws<NotSupportedException>(() => collection.Add(CreateT(0)));
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
}
}

@@ -305,15 +323,18 @@ public void ICollection_Generic_Add_AfterRemoving(int count)
public void ICollection_Generic_Clear(int count)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
if (IsReadOnly || AddRemoveClear_ThrowsNotSupported)
{
Assert.Throws<NotSupportedException>(() => collection.Clear());
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
}
else
{
collection.Clear();
Assert.Equal(0, collection.Count);
Assert.Equal(0, readOnlyCollection.Count);
}
}

@@ -322,19 +343,22 @@ public void ICollection_Generic_Clear(int count)
public void ICollection_Generic_Clear_Repeatedly(int count)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
if (IsReadOnly || AddRemoveClear_ThrowsNotSupported)
{
Assert.Throws<NotSupportedException>(() => collection.Clear());
Assert.Throws<NotSupportedException>(() => collection.Clear());
Assert.Throws<NotSupportedException>(() => collection.Clear());
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
}
else
{
collection.Clear();
collection.Clear();
collection.Clear();
Assert.Equal(0, collection.Count);
Assert.Equal(0, readOnlyCollection.Count);
}
}

@@ -433,10 +457,12 @@ public void ICollection_Generic_Contains_ValidValueThatExistsTwiceInTheCollectio
if (DuplicateValuesAllowed && !IsReadOnly && !AddRemoveClear_ThrowsNotSupported)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
T item = CreateT(12);
collection.Add(item);
collection.Add(item);
Assert.Equal(count + 2, collection.Count);
Assert.Equal(count + 2, readOnlyCollection.Count);
}
}

@@ -562,6 +588,7 @@ public void ICollection_Generic_Remove_DefaultValueNotContainedInCollection(int
{
int seed = count * 21;
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
T value = default(T);
while (collection.Contains(value))
{
@@ -570,6 +597,7 @@ public void ICollection_Generic_Remove_DefaultValueNotContainedInCollection(int
}
Assert.False(collection.Remove(value));
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
}
}

@@ -581,11 +609,13 @@ public void ICollection_Generic_Remove_NonDefaultValueNotContainedInCollection(i
{
int seed = count * 251;
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
T value = CreateT(seed++);
while (collection.Contains(value) || Enumerable.Contains(InvalidValues, value))
value = CreateT(seed++);
Assert.False(collection.Remove(value));
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
}
}

@@ -597,6 +627,7 @@ public virtual void ICollection_Generic_Remove_DefaultValueContainedInCollection
{
int seed = count * 21;
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
T value = default(T);
if (!collection.Contains(value))
{
@@ -605,6 +636,7 @@ public virtual void ICollection_Generic_Remove_DefaultValueContainedInCollection
}
Assert.True(collection.Remove(value));
Assert.Equal(count - 1, collection.Count);
Assert.Equal(count - 1, readOnlyCollection.Count);
}
}

@@ -616,6 +648,7 @@ public void ICollection_Generic_Remove_NonDefaultValueContainedInCollection(int
{
int seed = count * 251;
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
T value = CreateT(seed++);
if (!collection.Contains(value))
{
@@ -624,6 +657,7 @@ public void ICollection_Generic_Remove_NonDefaultValueContainedInCollection(int
}
Assert.True(collection.Remove(value));
Assert.Equal(count - 1, collection.Count);
Assert.Equal(count - 1, readOnlyCollection.Count);
}
}

@@ -635,13 +669,15 @@ public void ICollection_Generic_Remove_ValueThatExistsTwiceInCollection(int coun
{
int seed = count * 90;
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
T value = CreateT(seed++);
collection.Add(value);
collection.Add(value);
count += 2;
Assert.True(collection.Remove(value));
Assert.True(collection.Contains(value));
Assert.Equal(count - 1, collection.Count);
Assert.Equal(count - 1, readOnlyCollection.Count);
}
}

@@ -652,11 +688,13 @@ public void ICollection_Generic_Remove_EveryValue(int count)
if (!IsReadOnly && !AddRemoveClear_ThrowsNotSupported)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
Assert.All(collection.ToList(), value =>
{
Assert.True(collection.Remove(value));
});
Assert.Empty(collection);
Assert.Empty(readOnlyCollection);
}
}

@@ -665,11 +703,13 @@ public void ICollection_Generic_Remove_EveryValue(int count)
public void ICollection_Generic_Remove_InvalidValue_ThrowsArgumentException(int count)
{
ICollection<T> collection = GenericICollectionFactory(count);
IReadOnlyCollection<T> readOnlyCollection = collection;
Assert.All(InvalidValues, value =>
{
Assert.Throws<ArgumentException>(() => collection.Remove(value));
});
Assert.Equal(count, collection.Count);
Assert.Equal(count, readOnlyCollection.Count);
}

[Theory]
Loading