public static void Ctor_HashCodeProvider_Comparer_NullInputs(bool nullProvider, bool nullComparer)
{
var hash = new ComparableHashtable(
nullProvider ? null : CaseInsensitiveHashCodeProvider.DefaultInvariant,
nullComparer ? null : StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash, null, hash.EqualityComparer);
}
public void Ctor_IDictionary_IEqualityComparer()
{
RemoteInvoke(() =>
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), null);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(), null), null), null), null), null);
Assert.Equal(0, hash1.Count);
// Null comparer
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, null);
VerifyHashtable(hash1, hash2, null);
// Custom comparer
hash2 = Helpers.CreateIntHashtable(100);
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash1 = new ComparableHashtable(hash2, comparer);
VerifyHashtable(hash1, hash2, comparer);
return(SuccessExitCode);
}).Dispose();
}
public static void Ctor_IDictionary_Int_IEqualityComparer()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), 1f, null);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(
new Hashtable(new Hashtable(new Hashtable(), 1f, null), 1f, null), 1f, null), 1f, null), 1f, null);
Assert.Equal(0, hash1.Count);
// Null comparer
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, 1f, null);
VerifyHashtable(hash1, hash2, null);
hash2 = Helpers.CreateIntHashtable(100);
// Custom comparer
Helpers.PerformActionOnCustomCulture(() =>
{
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash1 = new ComparableHashtable(hash2, 1f, comparer);
VerifyHashtable(hash1, hash2, comparer);
});
}
public static void Ctor_HashCodeProvider_Comparer()
{
var hash = new ComparableHashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash, null, hash.EqualityComparer);
Assert.Same(CaseInsensitiveHashCodeProvider.DefaultInvariant, hash.HashCodeProvider);
Assert.Same(StringComparer.OrdinalIgnoreCase, hash.Comparer);
}
public void Ctor_HashCodeProvider_Comparer_NullInputs(bool nullProvider, bool nullComparer)
{
var hash = new ComparableHashtable(
nullProvider ? null : CaseInsensitiveHashCodeProvider.DefaultInvariant,
nullComparer ? null : StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash, null, hash.EqualityComparer);
}
public void Ctor_HashCodeProvider_Comparer()
{
var hash = new ComparableHashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash, null, hash.EqualityComparer);
Assert.Same(CaseInsensitiveHashCodeProvider.DefaultInvariant, hash.HashCodeProvider);
Assert.Same(StringComparer.OrdinalIgnoreCase, hash.Comparer);
}
public void HashCodeProvider_Comparer_IncompatibleGetSet_Throws()
{
var hash = new ComparableHashtable(StringComparer.CurrentCulture);
AssertExtensions.Throws <ArgumentException>(null, () => hash.HashCodeProvider);
AssertExtensions.Throws <ArgumentException>(null, () => hash.Comparer);
AssertExtensions.Throws <ArgumentException>(null, () => hash.HashCodeProvider = CaseInsensitiveHashCodeProvider.DefaultInvariant);
AssertExtensions.Throws <ArgumentException>(null, () => hash.Comparer = StringComparer.OrdinalIgnoreCase);
}
public void Ctor_Int()
{
var hash = new ComparableHashtable(0);
VerifyHashtable(hash, null);
hash = new ComparableHashtable(10);
VerifyHashtable(hash, null);
hash = new ComparableHashtable(100);
VerifyHashtable(hash, null);
}
public void Ctor_IEqualityComparer()
{
// Null comparer
var hash = new ComparableHashtable((IEqualityComparer)null);
VerifyHashtable(hash, null, null);
// Custom comparer
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(comparer);
VerifyHashtable(hash, null, comparer);
}
public static void TestCtor_IDictionary_LoadFactor()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), 1f);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(), 1f), 1f), 1f), 1f), 1f);
Assert.Equal(0, hash1.Count);
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, 1f);
VerifyHashtable(hash1, hash2, null);
}
public void Ctor_Int_Int_IEqualityComparer(int capacity, float loadFactor)
{
// Null comparer
var hash = new ComparableHashtable(capacity, loadFactor, null);
VerifyHashtable(hash, null, null);
Assert.Null(hash.EqualityComparer);
// Custom compare
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(capacity, loadFactor, comparer);
VerifyHashtable(hash, null, comparer);
}
public static void TestCtor_IEqualityComparer()
{
// Null comparer
var hash = new ComparableHashtable((IEqualityComparer)null);
VerifyHashtable(hash, null, null);
// Custom comparer
Helpers.PerformActionOnCustomCulture(() =>
{
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(comparer);
VerifyHashtable(hash, null, comparer);
});
}
public static void Ctor_IDictionary_HashCodeProvider_Comparer()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable())))), CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
Assert.Equal(0, hash1.Count);
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash1, hash2, hash1.EqualityComparer);
}
public void Ctor_IDictionary()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable());
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable());
Assert.Equal(0, hash1.Count);
Hashtable hash2 = CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2);
VerifyHashtable(hash1, hash2);
}
public static void Ctor_IEqualityComparer()
{
// Null comparer
var hash = new ComparableHashtable((IEqualityComparer)null);
VerifyHashtable(hash, null, null);
// Custom comparer
Helpers.PerformActionOnCustomCulture(() =>
{
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(comparer);
VerifyHashtable(hash, null, comparer);
});
}
public void Ctor_IDictionary()
{
// No exception
var hash1 = new ComparableHashtable(new HashtableEx());
Assert.AreEqual(0, hash1.Count);
hash1 = new ComparableHashtable(new HashtableEx(new HashtableEx(new HashtableEx(new HashtableEx(new HashtableEx())))));
Assert.AreEqual(0, hash1.Count);
HashtableEx hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2);
VerifyHashtable(hash1, hash2, null);
}
public void Ctor_IDictionary_HashCodeProvider_Comparer()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable())))), CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
Assert.Equal(0, hash1.Count);
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash1, hash2, hash1.EqualityComparer);
}
public void Ctor_IEqualityComparer()
{
RemoteInvoke(() =>
{
// Null comparer
var hash = new ComparableHashtable((IEqualityComparer)null);
VerifyHashtable(hash, null, null);
// Custom comparer
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(comparer);
VerifyHashtable(hash, null, comparer);
return(SuccessExitCode);
}).Dispose();
}
public static void Ctor_Int_Int_IEqualityComparer(int capacity, float loadFactor)
{
// Null comparer
var hash = new ComparableHashtable(capacity, loadFactor, null);
VerifyHashtable(hash, null, null);
Assert.Null(hash.EqualityComparer);
// Custom comparer
Helpers.PerformActionOnCustomCulture(() =>
{
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(capacity, loadFactor, comparer);
VerifyHashtable(hash, null, comparer);
});
}
public void Ctor_IDictionary_Int_HashCodeProvider_Comparer()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), 1f);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(), 1f), 1f), 1f), 1f), 1f);
Assert.Equal(0, hash1.Count);
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, 1f);
VerifyHashtable(hash1, hash2, null);
}
public void Ctor_IDictionary_Int()
{
// No exception
var hash1 = new ComparableHashtable(new HashtableEx(), 1f, StringComparer.OrdinalIgnoreCase);
Assert.AreEqual(0, hash1.Count);
hash1 = new ComparableHashtable(new HashtableEx(new HashtableEx(new HashtableEx(new HashtableEx(new HashtableEx(), 1f), 1f), 1f), 1f), 1f,
StringComparer.OrdinalIgnoreCase);
Assert.AreEqual(0, hash1.Count);
HashtableEx hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, 1f, StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash1, hash2, hash1.EqualityComparer);
}
public void Ctor_Int_IEqualityComparer(int capacity)
{
RemoteInvoke((rcapacity) =>
{
int.TryParse(rcapacity, out int capacityint);
// Null comparer
var hash = new ComparableHashtable(capacityint, null);
VerifyHashtable(hash, null, null);
// Custom comparer
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(capacityint, comparer);
VerifyHashtable(hash, null, comparer);
return(SuccessExitCode);
}, capacity.ToString()).Dispose();
}
public void HashCodeProvider_Comparer_CompatibleGetSet_Success()
{
var hash = new ComparableHashtable();
Assert.Null(hash.HashCodeProvider);
Assert.Null(hash.Comparer);
hash = new ComparableHashtable();
hash.HashCodeProvider = null;
hash.Comparer = null;
hash = new ComparableHashtable();
hash.Comparer = null;
hash.HashCodeProvider = null;
hash.HashCodeProvider = CaseInsensitiveHashCodeProvider.DefaultInvariant;
hash.Comparer = StringComparer.OrdinalIgnoreCase;
}
public void Ctor_Int_Int_GenerateNewPrime()
{
// The ctor for Hashtable performs the following calculation:
// rawSize = capacity / (loadFactor * 0.72)
// If rawSize is > 3, then it calls HashHelpers.GetPrime(rawSize) to generate a prime.
// Then, if the rawSize > 7,199,369 (the largest number in a list of known primes), we have to generate a prime programatically
// This test makes sure this works.
int capacity = 8000000;
float loadFactor = 0.1f / 0.72f;
try
{
var hash = new ComparableHashtable(capacity, loadFactor);
}
catch (OutOfMemoryException)
{
// On memory constrained devices, we can get an OutOfMemoryException, which we can safely ignore.
}
}
public void Comparer_Set_ImpactsSearch()
{
var hash = new ComparableHashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
hash.Add("test", "test");
// Should be able to find with the same and different casing
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
// Changing the comparer, should only be able to find the matching case
hash.Comparer = StringComparer.Ordinal;
Assert.True(hash.ContainsKey("test"));
Assert.False(hash.ContainsKey("TEST"));
// Changing it back, should be able to find both again
hash.Comparer = StringComparer.OrdinalIgnoreCase;
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
}
public void Ctor_Int_Int_IEqualityComparer(int capacity, float loadFactor)
{
RemoteInvoke((rcapacity, rloadFactor) =>
{
int.TryParse(rcapacity, out int capacityint);
float.TryParse(rloadFactor, out float loadFactorFloat);
// Null comparer
var hash = new ComparableHashtable(capacityint, loadFactorFloat, null);
VerifyHashtable(hash, null, null);
Assert.Null(hash.EqualityComparer);
// Custom compare
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(capacityint, loadFactorFloat, comparer);
VerifyHashtable(hash, null, comparer);
return(SuccessExitCode);
}, capacity.ToString(), loadFactor.ToString()).Dispose();
}
private static void VerifyHashtable(ComparableHashtable hash1, Hashtable hash2, IEqualityComparer ikc)
{
if (hash2 == null)
{
Assert.Equal(0, hash1.Count);
}
else
{
// Make sure that construtor imports all keys and values
Assert.Equal(hash2.Count, hash1.Count);
for (int i = 0; i < 100; i++)
{
Assert.True(hash1.ContainsKey(i));
Assert.True(hash1.ContainsValue(i));
}
// Make sure the new and old hashtables are not linked
hash2.Clear();
for (int i = 0; i < 100; i++)
{
Assert.True(hash1.ContainsKey(i));
Assert.True(hash1.ContainsValue(i));
}
}
Assert.Equal(ikc, hash1.EqualityComparer);
Assert.False(hash1.IsFixedSize);
Assert.False(hash1.IsReadOnly);
Assert.False(hash1.IsSynchronized);
// Make sure we can add to the hashtable
int count = hash1.Count;
for (int i = count; i < count + 100; i++)
{
hash1.Add(i, i);
Assert.True(hash1.ContainsKey(i));
Assert.True(hash1.ContainsValue(i));
}
}
public void Ctor_IDictionary_IEqualityComparer()
{
// No exception
var hash1 = new ComparableHashtable(new HashtableEx(), null);
Assert.AreEqual(0, hash1.Count);
hash1 = new ComparableHashtable(new HashtableEx(new HashtableEx(new HashtableEx(new HashtableEx(new HashtableEx(), null), null), null), null), null);
Assert.AreEqual(0, hash1.Count);
// Null comparer
HashtableEx hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, null);
VerifyHashtable(hash1, hash2, null);
// Custom comparer
hash2 = Helpers.CreateIntHashtable(100);
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash1 = new ComparableHashtable(hash2, comparer);
VerifyHashtable(hash1, hash2, comparer);
}
public void HashCodeProvider_Set_ImpactsSearch()
{
var hash = new ComparableHashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
hash.Add("test", "test");
// Should be able to find with the same and different casing
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
// Changing the hash code provider, we shouldn't be able to find either
hash.HashCodeProvider = new FixedHashCodeProvider
{
FixedHashCode = CaseInsensitiveHashCodeProvider.DefaultInvariant.GetHashCode("test") + 1
};
Assert.False(hash.ContainsKey("test"));
Assert.False(hash.ContainsKey("TEST"));
// Changing it back, should be able to find both again
hash.HashCodeProvider = CaseInsensitiveHashCodeProvider.DefaultInvariant;
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
}
public static void Ctor_Int_Int_HashCodeProvider_Comparer(int capacity, float loadFactor)
{
var hash = new ComparableHashtable(capacity, loadFactor, CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash, null, hash.EqualityComparer);
}
public static void HashCodeProvider_Set_ImpactsSearch()
{
var hash = new ComparableHashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
hash.Add("test", "test");
// Should be able to find with the same and different casing
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
// Changing the hash code provider, we shouldn't be able to find either
hash.HashCodeProvider = new FixedHashCodeProvider
{
FixedHashCode = CaseInsensitiveHashCodeProvider.DefaultInvariant.GetHashCode("test") + 1
};
Assert.False(hash.ContainsKey("test"));
Assert.False(hash.ContainsKey("TEST"));
// Changing it back, should be able to find both again
hash.HashCodeProvider = CaseInsensitiveHashCodeProvider.DefaultInvariant;
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
}
public static void HashCodeProvider_Comparer_CompatibleGetSet_Success()
{
var hash = new ComparableHashtable();
Assert.Null(hash.HashCodeProvider);
Assert.Null(hash.Comparer);
hash = new ComparableHashtable();
hash.HashCodeProvider = null;
hash.Comparer = null;
hash = new ComparableHashtable();
hash.Comparer = null;
hash.HashCodeProvider = null;
hash.HashCodeProvider = CaseInsensitiveHashCodeProvider.DefaultInvariant;
hash.Comparer = StringComparer.OrdinalIgnoreCase;
}
public static void HashCodeProvider_Comparer_IncompatibleGetSet_Throws()
{
var hash = new ComparableHashtable(StringComparer.CurrentCulture);
Assert.Throws<ArgumentException>(() => hash.HashCodeProvider);
Assert.Throws<ArgumentException>(() => hash.Comparer);
Assert.Throws<ArgumentException>(() => hash.HashCodeProvider = CaseInsensitiveHashCodeProvider.DefaultInvariant);
Assert.Throws<ArgumentException>(() => hash.Comparer = StringComparer.OrdinalIgnoreCase);
}
public static void TestCtor_Capacity_LoadFactor_IEqualityComparer(int capacity, float loadFactor)
{
// Null comparer
var hash = new ComparableHashtable(capacity, loadFactor, null);
VerifyHashtable(hash, null, null);
Assert.Null(hash.EqualityComparer);
// Custom comparer
Helpers.PerformActionOnCustomCulture(() =>
{
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash = new ComparableHashtable(capacity, loadFactor, comparer);
VerifyHashtable(hash, null, comparer);
});
}
public static void Comparer_Set_ImpactsSearch()
{
var hash = new ComparableHashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
hash.Add("test", "test");
// Should be able to find with the same and different casing
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
// Changing the comparer, should only be able to find the matching case
hash.Comparer = StringComparer.Ordinal;
Assert.True(hash.ContainsKey("test"));
Assert.False(hash.ContainsKey("TEST"));
// Changing it back, should be able to find both again
hash.Comparer = StringComparer.OrdinalIgnoreCase;
Assert.True(hash.ContainsKey("test"));
Assert.True(hash.ContainsKey("TEST"));
}
public static void TestCtor_Empty()
{
var hash = new ComparableHashtable();
VerifyHashtable(hash, null, null);
}
public static void TestCtor_Capacity_LoadFactor(int capacity, float loadFactor)
{
var hash = new ComparableHashtable(capacity, loadFactor);
VerifyHashtable(hash, null, null);
}
public void Ctor_Int_Int(int capacity, float loadFactor)
{
var hash = new ComparableHashtable(capacity, loadFactor);
VerifyHashtable(hash, null, null);
}
public void Ctor_Int_Int_HashCodeProvider_Comparer(int capacity, float loadFactor)
{
var hash = new ComparableHashtable(capacity, loadFactor, CaseInsensitiveHashCodeProvider.DefaultInvariant, StringComparer.OrdinalIgnoreCase);
VerifyHashtable(hash, null, hash.EqualityComparer);
}
public static void TestCtor_IDictionary_LoadFactor_IEqualityComparer()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), 1f, null);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(
new Hashtable(new Hashtable(new Hashtable(), 1f, null), 1f, null), 1f, null), 1f, null), 1f, null);
Assert.Equal(0, hash1.Count);
// Null comparer
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, 1f, null);
VerifyHashtable(hash1, hash2, null);
hash2 = Helpers.CreateIntHashtable(100);
// Custom comparer
Helpers.PerformActionOnCustomCulture(() =>
{
IEqualityComparer comparer = StringComparer.CurrentCulture;
hash1 = new ComparableHashtable(hash2, 1f, comparer);
VerifyHashtable(hash1, hash2, comparer);
});
}
public void Ctor_Empty()
{
var hash = new ComparableHashtable();
VerifyHashtable(hash, null, null);
}
public void Ctor_Int(int capacity)
{
var hash = new ComparableHashtable(capacity);
VerifyHashtable(hash, null, null);
}
public static void Ctor_IDictionary_Int_HashCodeProvider_Comparer()
{
// No exception
var hash1 = new ComparableHashtable(new Hashtable(), 1f);
Assert.Equal(0, hash1.Count);
hash1 = new ComparableHashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(), 1f), 1f), 1f), 1f), 1f);
Assert.Equal(0, hash1.Count);
Hashtable hash2 = Helpers.CreateIntHashtable(100);
hash1 = new ComparableHashtable(hash2, 1f);
VerifyHashtable(hash1, hash2, null);
}
private static void VerifyHashtable(ComparableHashtable hash1, Hashtable hash2, IEqualityComparer ikc)
{
if (hash2 == null)
{
Assert.Equal(0, hash1.Count);
}
else
{
// Make sure that construtor imports all keys and values
Assert.Equal(hash2.Count, hash1.Count);
for (int i = 0; i < 100; i++)
{
Assert.True(hash1.ContainsKey(i));
Assert.True(hash1.ContainsValue(i));
}
// Make sure the new and old hashtables are not linked
hash2.Clear();
for (int i = 0; i < 100; i++)
{
Assert.True(hash1.ContainsKey(i));
Assert.True(hash1.ContainsValue(i));
}
}
Assert.Equal(ikc, hash1.EqualityComparer);
Assert.False(hash1.IsFixedSize);
Assert.False(hash1.IsReadOnly);
Assert.False(hash1.IsSynchronized);
// Make sure we can add to the hashtable
int count = hash1.Count;
for (int i = count; i < count + 100; i++)
{
hash1.Add(i, i);
Assert.True(hash1.ContainsKey(i));
Assert.True(hash1.ContainsValue(i));
}
}
public static void TestCtor_Capacity_LoadFactor_GenerateNewPrime()
{
// The ctor for Hashtable performs the following calculation:
// rawSize = capacity / (loadFactor * 0.72)
// If rawSize is > 3, then it calls HashHelpers.GetPrime(rawSize) to generate a prime.
// Then, if the rawSize > 7,199,369 (the largest number in a list of known primes), we have to generate a prime programatically
// This test makes sure this works.
int capacity = 8000000;
float loadFactor = 0.1f / 0.72f;
try
{
var hash = new ComparableHashtable(capacity, loadFactor);
}
catch (OutOfMemoryException)
{
// On memory constrained devices, we can get an OutOfMemoryException, which we can safely ignore.
}
}
public static void TestCtor_Capacity(int capacity)
{
var hash = new ComparableHashtable(capacity);
VerifyHashtable(hash, null, null);
}