public void TrimExcess_NoArgument_TrimAfterEachBulkAddOrRemove_TrimsToAtLeastCount(int initialCount, int numRemove, int numAdd, int newCount, int newCapacity)
{
Random random = new Random(32);
var dictionary = new LinkedDictionary <int, int>();
dictionary.TrimExcess();
Assert.InRange(dictionary.EnsureCapacity(0), dictionary.Count, int.MaxValue);
var initialKeys = new int[initialCount];
for (int i = 0; i < initialCount; i++)
{
initialKeys[i] = i;
}
random.Shuffle(initialKeys);
foreach (var key in initialKeys)
{
dictionary.Add(key, 0);
}
dictionary.TrimExcess();
Assert.InRange(dictionary.EnsureCapacity(0), dictionary.Count, int.MaxValue);
random.Shuffle(initialKeys);
for (int i = 0; i < numRemove; i++)
{
dictionary.Remove(initialKeys[i]);
}
dictionary.TrimExcess();
Assert.InRange(dictionary.EnsureCapacity(0), dictionary.Count, int.MaxValue);
var moreKeys = new int[numAdd];
for (int i = 0; i < numAdd; i++)
{
moreKeys[i] = i + initialCount;
}
random.Shuffle(moreKeys);
foreach (var key in moreKeys)
{
dictionary.Add(key, 0);
}
int currentCount = dictionary.Count;
dictionary.TrimExcess();
Assert.InRange(dictionary.EnsureCapacity(0), currentCount, int.MaxValue);
int[] existingKeys = new int[currentCount];
Array.Copy(initialKeys, numRemove, existingKeys, 0, initialCount - numRemove);
Array.Copy(moreKeys, 0, existingKeys, initialCount - numRemove, numAdd);
random.Shuffle(existingKeys);
for (int i = 0; i < currentCount - newCount; i++)
{
dictionary.Remove(existingKeys[i]);
}
dictionary.TrimExcess();
int finalCapacity = dictionary.EnsureCapacity(0);
Assert.InRange(finalCapacity, newCount, initialCount);
Assert.Equal(newCapacity, finalCapacity);
}
public void TrimExcess_Generic_DictionaryNotInitialized_CapacityRemainsAsMinPossible()
{
var dictionary = new LinkedDictionary <TKey, TValue>();
Assert.Equal(0, dictionary.EnsureCapacity(0));
dictionary.TrimExcess();
Assert.Equal(0, dictionary.EnsureCapacity(0));
}
public void EnsureCapacity_Generic_ExistingCapacityRequested_SameValueReturned(int capacity)
{
var dictionary = new LinkedDictionary <TKey, TValue>(capacity);
Assert.Equal(capacity, dictionary.EnsureCapacity(capacity));
dictionary = (LinkedDictionary <TKey, TValue>)GenericIDictionaryFactory(capacity);
Assert.Equal(capacity, dictionary.EnsureCapacity(capacity));
}
public void TrimExcess_Generic_TrimToLargerThanExistingCapacity_DoesNothing(int suggestedCapacity)
{
var dictionary = new LinkedDictionary <TKey, TValue>();
int capacity = dictionary.EnsureCapacity(0);
dictionary.TrimExcess(suggestedCapacity);
Assert.Equal(capacity, dictionary.EnsureCapacity(0));
dictionary = new LinkedDictionary <TKey, TValue>(suggestedCapacity / 2);
capacity = dictionary.EnsureCapacity(0);
dictionary.TrimExcess(suggestedCapacity);
Assert.Equal(capacity, dictionary.EnsureCapacity(0));
}
public void TrimExcess_Generic_LargeInitialCapacity_TrimReducesSize()
{
var dictionary = new LinkedDictionary <TKey, TValue>(20);
dictionary.TrimExcess(7);
Assert.Equal(7, dictionary.EnsureCapacity(0));
}
public void TrimExcess_Generic_ClearThenTrimNonEmptyDictionary_SetsCapacityTo3(int count)
{
LinkedDictionary <TKey, TValue> dictionary = (LinkedDictionary <TKey, TValue>)GenericIDictionaryFactory(count);
Assert.Equal(count, dictionary.Count);
// The smallest possible capacity size after clearing a dictionary is 3
dictionary.Clear();
dictionary.TrimExcess();
Assert.Equal(3, dictionary.EnsureCapacity(0));
}
public void TrimExcess_NoArguments_TrimsToAtLeastCount(int count)
{
var dictionary = new LinkedDictionary <int, int>(20);
for (int i = 0; i < count; i++)
{
dictionary.Add(i, 0);
}
dictionary.TrimExcess();
Assert.InRange(dictionary.EnsureCapacity(0), count, int.MaxValue);
}
public void EnsureCapacity_Generic_RequestedCapacitySmallerThanCurrent_CapacityUnchanged(int currentCapacity)
{
LinkedDictionary <TKey, TValue> dictionary;
// assert capacity remains the same when ensuring a capacity smaller or equal than existing
for (int i = 0; i <= currentCapacity; i++)
{
dictionary = new LinkedDictionary <TKey, TValue>(currentCapacity);
Assert.Equal(currentCapacity, dictionary.EnsureCapacity(i));
}
}
public void TrimExcess_WithArguments_OnDictionaryWithManyElementsRemoved_TrimsToAtLeastRequested(int finalCount)
{
const int InitToFinalRatio = 10;
int initialCount = InitToFinalRatio * finalCount;
var dictionary = new LinkedDictionary <int, int>(initialCount);
Assert.InRange(dictionary.EnsureCapacity(0), initialCount, int.MaxValue);
for (int i = 0; i < initialCount; i++)
{
dictionary.Add(i, 0);
}
for (int i = 0; i < initialCount - finalCount; i++)
{
dictionary.Remove(i);
}
for (int i = InitToFinalRatio; i > 0; i--)
{
dictionary.TrimExcess(i * finalCount);
Assert.InRange(dictionary.EnsureCapacity(0), i * finalCount, int.MaxValue);
}
}
public void EnsureCapacity_Generic_CapacityIsSetToPrimeNumberLargerOrEqualToRequested()
{
var dictionary = new LinkedDictionary <TKey, TValue>();
Assert.Equal(17, dictionary.EnsureCapacity(17));
dictionary = new LinkedDictionary <TKey, TValue>();
Assert.Equal(17, dictionary.EnsureCapacity(15));
dictionary = new LinkedDictionary <TKey, TValue>();
Assert.Equal(17, dictionary.EnsureCapacity(13));
}
public void EnsureCapacity_Generic_DictionaryNotInitialized_RequestedNonZero_CapacityIsSetToAtLeastTheRequested(int requestedCapacity)
{
var dictionary = new LinkedDictionary <TKey, TValue>();
Assert.InRange(dictionary.EnsureCapacity(requestedCapacity), requestedCapacity, int.MaxValue);
}
public void EnsureCapacity_Generic_DictionaryNotInitialized_RequestedZero_ReturnsZero()
{
var dictionary = new LinkedDictionary <TKey, TValue>();
Assert.Equal(0, dictionary.EnsureCapacity(0));
}
public void EnsureCapacity_Generic_NegativeCapacityRequested_Throws()
{
var dictionary = new LinkedDictionary <TKey, TValue>();
AssertExtensions.Throws <ArgumentOutOfRangeException>("capacity", () => dictionary.EnsureCapacity(-1));
}
