public void IEnumerable_Generic_Serialize_Deserialize(int count)
{
if (!SupportsSerialization)
{
return;
}
IEnumerable <T> enumerable = GenericIEnumerableFactory(count);
var formatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
formatter.Serialize(stream, enumerable);
stream.Position = 0L;
var copy = (IEnumerable <T>)formatter.Deserialize(stream);
Assert.NotSame(enumerable, copy);
Assert.Equal(enumerable.Count(), copy.Count());
// We can't compare contents, because Dictionary/Set might not
// return items in the same order. Use a PooledSet to compare content
// without regard to order:
using (var set = new PooledSet <T>(enumerable))
{
Assert.True(set.SetEquals(copy), "Deserialized content differs!");
}
if (copy is IDisposable disposable)
{
disposable.Dispose();
}
}
}
protected override ISet <T> GenericISetFactory()
{
var set = new PooledSet <T>();
RegisterForDispose(set);
return(set);
}
public void HashSet_Generic_Constructor_IEnumerable(EnumerableType enumerableType, int setLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
{
IEnumerable <T> enumerable = CreateEnumerable(enumerableType, null, enumerableLength, 0, numberOfDuplicateElements);
PooledSet <T> set = new PooledSet <T>(enumerable);
Assert.True(set.SetEquals(enumerable));
}
private void Validate_IsProperSupersetOf(PooledSet <T> set, Span <T> span)
{
bool isProperSuperset = true;
bool setContainsElementsNotInEnumerable = false;
IEqualityComparer <T> comparer = set.Comparer;
foreach (T value in span)
{
if (!set.Contains(value))
{
isProperSuperset = false;
break;
}
}
foreach (T value in set)
{
if (!SpanContains(span, value, comparer))
{
setContainsElementsNotInEnumerable = true;
break;
}
}
isProperSuperset = isProperSuperset && setContainsElementsNotInEnumerable;
Assert.Equal(isProperSuperset, set.IsProperSupersetOf(span));
}
public static void UsingBorrowBorrowOrIncrementUsage()
{
using var set = PooledSet <int> .Borrow();
using var meh = set.IncrementUsage();
using var meh1 = meh.IncrementUsage();
}
public void HashSet_Generic_Constructor_int(int capacity)
{
PooledSet <T> set = new PooledSet <T>(capacity);
RegisterForDispose(set);
Assert.Equal(0, set.Count);
}
protected override ISet <SimpleInt> GenericISetFactory()
{
var set = new PooledSet <SimpleInt>(new WrapStructural_SimpleInt());
RegisterForDispose(set);
return(set);
}
public void HashSet_Generic_RemoveWhere_AllElements(int setLength)
{
PooledSet <T> set = (PooledSet <T>)GenericISetFactory(setLength);
int removedCount = set.RemoveWhere((value) => { return(true); });
Assert.Equal(setLength, removedCount);
}
private void Validate_IntersectWith(ISet <T> set, IEnumerable <T> enumerable)
{
if (set.Count == 0 || Enumerable.Count(enumerable) == 0)
{
set.IntersectWith(enumerable);
Assert.Equal(0, set.Count);
}
else if (set == enumerable)
{
PooledSet <T> beforeOperation = new PooledSet <T>(set, GetIEqualityComparer());
RegisterForDispose(beforeOperation);
set.IntersectWith(enumerable);
Assert.True(beforeOperation.SetEquals(set));
}
else
{
IEqualityComparer <T> comparer = GetIEqualityComparer();
PooledSet <T> expected = new PooledSet <T>(comparer);
RegisterForDispose(expected);
foreach (T value in set)
{
if (enumerable.Contains(value, comparer))
{
expected.Add(value);
}
}
set.IntersectWith(enumerable);
Assert.Equal(expected.Count, set.Count);
Assert.True(expected.SetEquals(set));
}
}
public void SetComparer_SetEqualsTests()
{
List <T> objects = new List <T>()
{
CreateT(1), CreateT(2), CreateT(3), CreateT(4), CreateT(5), CreateT(6)
};
var set = new PooledSet <PooledSet <T> >()
{
RegisterForDispose(new PooledSet <T> {
objects[0], objects[1], objects[2]
}),
RegisterForDispose(new PooledSet <T> {
objects[3], objects[4], objects[5]
})
};
RegisterForDispose(set);
var noComparerSet = new PooledSet <PooledSet <T> >()
{
RegisterForDispose(new PooledSet <T> {
objects[0], objects[1], objects[2]
}),
RegisterForDispose(new PooledSet <T> {
objects[3], objects[4], objects[5]
})
};
RegisterForDispose(noComparerSet);
var comparerSet1 = new PooledSet <PooledSet <T> >(PooledSet <T> .CreateSetComparer())
{
RegisterForDispose(new PooledSet <T> {
objects[0], objects[1], objects[2]
}),
RegisterForDispose(new PooledSet <T> {
objects[3], objects[4], objects[5]
})
};
RegisterForDispose(comparerSet1);
var comparerSet2 = new PooledSet <PooledSet <T> >(PooledSet <T> .CreateSetComparer())
{
RegisterForDispose(new PooledSet <T> {
objects[3], objects[4], objects[5]
}),
RegisterForDispose(new PooledSet <T> {
objects[0], objects[1], objects[2]
})
};
RegisterForDispose(comparerSet2);
Assert.False(noComparerSet.SetEquals(set));
Assert.True(comparerSet1.SetEquals(set));
Assert.True(comparerSet2.SetEquals(set));
}
public void HashSet_Generic_CopyTo_NegativeCount_ThrowsArgumentOutOfRangeException(int count)
{
PooledSet <T> set = (PooledSet <T>)GenericISetFactory(count);
T[] arr = new T[count];
Assert.Throws <ArgumentOutOfRangeException>(() => set.CopyTo(arr, 0, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => set.CopyTo(arr, 0, int.MinValue));
}
public void HashSet_Generic_Constructor_IEnumerable_IEqualityComparer(EnumerableType enumerableType, int setLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
{
IEnumerable <T> enumerable = CreateEnumerable(enumerableType, null, enumerableLength, 0, 0);
PooledSet <T> set = new PooledSet <T>(enumerable, GetIEqualityComparer());
RegisterForDispose(set);
Assert.True(set.SetEquals(enumerable));
}
public static void UsingBorrowAddForeach()
{
using var set = PooledSet <int> .Borrow();
_ = set.Add(1);
foreach (var i in set)
{
}
}
public void CanBeCastedToISet()
{
PooledSet <T> set = new PooledSet <T>();
RegisterForDispose(set);
ISet <T> iset = (set as ISet <T>);
Assert.NotNull(iset);
}
public void GlobalSetup()
{
var intGenerator = new RandomTGenerator <int>(InstanceCreators.IntGenerator);
int[] startingElements = intGenerator.MakeNewTs(InitialSetSize);
hashSet = new HashSet <int>(startingElements);
pooledSet = new PooledSet <int>(startingElements);
}
public void HashSet_Generic_Constructor_IEnumerable_WithManyDuplicates(int count)
{
IEnumerable <T> items = CreateEnumerable(EnumerableType.List, null, count, 0, 0);
PooledSet <T> hashSetFromDuplicates = new PooledSet <T>(Enumerable.Range(0, 40).SelectMany(i => items).ToArray());
PooledSet <T> hashSetFromNoDuplicates = new PooledSet <T>(items);
RegisterForDispose(hashSetFromDuplicates, hashSetFromNoDuplicates);
Assert.True(hashSetFromNoDuplicates.SetEquals(hashSetFromDuplicates));
}
public void HashSet_Generic_CopyTo_NoIndexDefaultsToZero(int count)
{
PooledSet <T> set = (PooledSet <T>)GenericISetFactory(count);
T[] arr1 = new T[count];
T[] arr2 = new T[count];
set.CopyTo(arr1);
set.CopyTo(arr2, 0);
Assert.True(arr1.SequenceEqual(arr2));
}
public void HashSet_Generic_TrimExcess_Repeatedly(int setLength)
{
PooledSet <T> set = (PooledSet <T>)GenericISetFactory(setLength);
List <T> expected = set.ToList();
set.TrimExcess();
set.TrimExcess();
set.TrimExcess();
Assert.True(set.SetEquals(expected));
}
public void GlobalSetup()
{
var intGenerator = new RandomTGenerator <int>(InstanceCreators.IntGenerator);
int[] startingElements = intGenerator.MakeNewTs(InitialSetSize);
subsetToCheck = intGenerator.GenerateSelectionSubset(startingElements, CountToCheck);
hashSet = new HashSet <int>(startingElements);
pooledSet = new PooledSet <int>(startingElements);
}
public static void UsingBorrowAddForeachCallId()
{
using (var set = PooledSet <int> .Borrow())
{
set.Add(1);
foreach (var i in set)
{
var j = Id(i);
}
}
}
protected static PooledSet <int> CreatePooled(int size)
{
var rand = new Random(RAND_SEED);
var set = new PooledSet <int>(size);
for (int i = 0; i < size; i++)
{
set.Add(rand.Next());
}
return(set);
}
public static void UseSet(PooledSet <int> set)
{
using (set = set.IncrementUsage())
{
_ = set.Add(set.Count);
foreach (var i in set)
{
var j = Id(i);
}
}
}
public void GlobalSetup()
{
var intGenerator = new RandomTGenerator <int>(InstanceCreators.IntGenerator);
int[] startingElements = intGenerator.MakeNewTs(InitialSetSize);
stuffToUnion = intGenerator.GenerateMixedSelection(startingElements, CountToUnion);
hashSet = new HashSet <int>(startingElements);
hashSet.UnionWith(stuffToUnion);
pooledSet = new PooledSet <int>(startingElements);
pooledSet.UnionWith(stuffToUnion);
}
public static void UsingBorrowOrIncrementUsageNull(PooledSet <int> arg)
{
using (var set = arg.IncrementUsage())
{
using (var meh = set.IncrementUsage())
{
using (var meh1 = meh.IncrementUsage())
{
}
}
}
}
public void HashSet_Generic_Constructor_int_AddUpToAndBeyondCapacity(int capacity)
{
PooledSet <T> set = new PooledSet <T>(capacity);
RegisterForDispose(set);
AddToCollection(set, capacity);
Assert.Equal(capacity, set.Count);
AddToCollection(set, capacity + 1);
Assert.Equal(capacity + 1, set.Count);
}
public void GlobalSetup()
{
var intGenerator = new RandomTGenerator <int>(InstanceCreators.IntGenerator);
startingElements = intGenerator.MakeNewTs(InitialSetSize);
stuffToExcept = intGenerator.GenerateMixedSelection(startingElements, CountToIntersect);
hashSet = new HashSet <int>();
hashSetToExcept = new HashSet <int>(stuffToExcept);
pooledSet = new PooledSet <int>();
pooledSetToExcept = new PooledSet <int>(stuffToExcept);
}
private void Validate_IsSupersetOf(PooledSet <T> set, Span <T> span)
{
foreach (T value in span)
{
if (!set.Contains(value))
{
Assert.False(set.IsSupersetOf(span));
return;
}
}
Assert.True(set.IsSupersetOf(span));
}
private void Validate_Overlaps(PooledSet <T> set, Span <T> span)
{
foreach (T value in span)
{
if (set.Contains(value))
{
Assert.True(set.Overlaps(span));
return;
}
}
Assert.False(set.Overlaps(span));
}
public int GetHashCode(PooledSet <T> obj)
{
int hashCode = 0;
if (obj != null)
{
foreach (T t in obj)
{
hashCode ^= (_comparer.GetHashCode(t) & 0x7FFFFFFF);
}
} // else returns hashcode of 0 for null hashsets
return(hashCode);
}
protected override IEnumerable NonGenericIEnumerableFactory(int count)
{
var set = new PooledSet <string>();
RegisterForDispose(set);
int seed = 12354;
while (set.Count < count)
{
set.Add(CreateT(set, seed++));
}
return(set);
}
