public virtual void TestUnionWithObject()
{
var originalValues = new string[] { "sally", "sells", "seashells", "by", "the", "sea", "shore" };
CharArraySet target = new CharArraySet(TEST_VERSION_CURRENT, originalValues, false);
var existingValuesAsObject = new List <object> {
"seashells", "sea", "shore"
};
var mixedExistingNonExistingValuesAsObject = new List <object> {
"true", "set", "of", "unique", "values", "except", "sells"
};
var nonExistingMixedTypes = new object[] { true, (byte)55, (short)44, (int)33, (sbyte)22, (long)11, (char)'\n', "hurray", (uint)99, (ulong)89, (ushort)79, new char[] { 't', 'w', 'o' }, new StringCharSequence("testing") };
// Add existing values
assertFalse(target.UnionWith(existingValuesAsObject));
assertEquals(7, target.Count);
CollectionAssert.AreEquivalent(originalValues, target);
// Add mixed existing/non-existing values
assertTrue(target.UnionWith(mixedExistingNonExistingValuesAsObject));
assertEquals(13, target.Count);
CollectionAssert.AreEquivalent(new string[] { "sally", "sells", "seashells", "by", "the", "sea", "shore",
"true", "set", "of", "unique", "values", "except" }, target);
target.Clear();
assertEquals(0, target.Count);
assertTrue(target.UnionWith(originalValues.Cast <object>())); // Need to cast here because the .NET return type is void for UnionWith.
CollectionAssert.AreEquivalent(originalValues, target);
// Add mixed types as object
assertTrue(target.UnionWith(nonExistingMixedTypes));
assertEquals(20, target.Count);
assertTrue(target.Contains(true));
assertTrue(target.Contains((byte)55));
assertTrue(target.Contains((short)44));
assertTrue(target.Contains((int)33));
assertTrue(target.Contains((sbyte)22));
assertTrue(target.Contains((long)11));
assertTrue(target.Contains((char)'\n'));
assertTrue(target.Contains("hurray"));
assertTrue(target.Contains((uint)99));
assertTrue(target.Contains((ulong)89));
assertTrue(target.Contains((ushort)79));
assertTrue(target.Contains(new char[] { 't', 'w', 'o' }));
assertTrue(target.Contains(new StringCharSequence("testing")));
}
public virtual void TestClear()
{
var set = new CharArraySet(TEST_VERSION_CURRENT, 10, true);
set.AddAll(TEST_STOP_WORDS);
assertEquals("Not all words added", TEST_STOP_WORDS.Length, set.size());
set.Clear();
assertEquals("not empty", 0, set.size());
for (var i = 0; i < TEST_STOP_WORDS.Length; i++)
{
assertFalse(set.Contains(TEST_STOP_WORDS[i]));
}
set.AddAll(TEST_STOP_WORDS);
assertEquals("Not all words added", TEST_STOP_WORDS.Length, set.size());
for (var i = 0; i < TEST_STOP_WORDS.Length; i++)
{
assertTrue("Set doesn't contain " + TEST_STOP_WORDS[i], set.Contains(TEST_STOP_WORDS[i]));
}
}
public virtual void TestEquality()
{
var values = new List <string> {
"sally", "sells", "seashells", "by", "the", "sea", "shore"
};
var charArraySet = new CharArraySet(TEST_VERSION_CURRENT, values, false);
var charArraySetCopy = new CharArraySet(TEST_VERSION_CURRENT, values, false);
values.Reverse();
var charArraySetReverse = new CharArraySet(TEST_VERSION_CURRENT, values, false);
var equatableSetReverse = new JCG.HashSet <string>(values);
assertTrue(charArraySet.GetHashCode().Equals(charArraySetCopy.GetHashCode()));
assertTrue(charArraySet.Equals(charArraySetCopy));
assertTrue(charArraySet.GetHashCode().Equals(charArraySetReverse.GetHashCode()));
assertTrue(charArraySet.Equals(charArraySetReverse));
assertTrue(charArraySet.GetHashCode().Equals(equatableSetReverse.GetHashCode()));
assertTrue(charArraySet.Equals(equatableSetReverse));
values = new List <string> {
"sally", "seashells", "by", "the", "sea", "shore"
};
charArraySet.Clear();
charArraySet.UnionWith(values);
assertFalse(charArraySet.GetHashCode().Equals(charArraySetCopy.GetHashCode()));
assertFalse(charArraySet.Equals(charArraySetCopy));
assertFalse(charArraySet.GetHashCode().Equals(charArraySetReverse.GetHashCode()));
assertFalse(charArraySet.Equals(charArraySetReverse));
assertFalse(charArraySet.GetHashCode().Equals(equatableSetReverse.GetHashCode()));
assertFalse(charArraySet.Equals(equatableSetReverse));
equatableSetReverse.Remove("sells");
assertTrue(charArraySet.GetHashCode().Equals(equatableSetReverse.GetHashCode()));
assertTrue(charArraySet.Equals(equatableSetReverse));
}
public virtual void TestMethods()
{
CharArrayMap <int?> cm = new CharArrayMap <int?>(TEST_VERSION_CURRENT, 2, false);
Dictionary <string, int?> hm = new Dictionary <string, int?>();
hm["foo"] = 1;
hm["bar"] = 2;
cm.PutAll(hm);
assertEquals(hm.Count, cm.Count);
hm["baz"] = 3;
cm.PutAll(hm);
assertEquals(hm.Count, cm.Count);
// LUCENENET: Need to cast here - no implicit conversion.
CharArraySet cs = cm.Keys as CharArraySet;
int n = 0;
foreach (string o in cs)
{
assertTrue(cm.ContainsKey(o));
char[] co = o.ToCharArray();
assertTrue(cm.ContainsKey(co, 0, co.Length));
n++;
}
assertEquals(hm.Count, n);
assertEquals(hm.Count, cs.Count);
assertEquals(cm.Count, cs.Count);
cs.Clear();
assertEquals(0, cs.Count);
assertEquals(0, cm.Count);
try
{
cs.Add("test");
fail("keySet() allows adding new keys");
}
catch (System.NotSupportedException)
{
// pass
}
cm.PutAll(hm);
assertEquals(hm.Count, cs.Count);
assertEquals(cm.Count, cs.Count);
// LUCENENET: Need to cast here - no implicit conversion
IEnumerator <KeyValuePair <string, int?> > iter1 = (IEnumerator <KeyValuePair <string, int?> >)cm.EntrySet().GetEnumerator();
n = 0;
while (iter1.MoveNext())
{
KeyValuePair <string, int?> entry = iter1.Current;
object key = entry.Key;
int? val = entry.Value;
assertEquals(cm.Get(key), val);
// LUCENENET: Need a cast to get to this method because it is not part of the IEnumerator<T> interface
((CharArrayMap <int?> .EntryIterator)iter1).SetValue(val * 100);
assertEquals(val * 100, (int)cm.Get(key));
n++;
}
assertEquals(hm.Count, n);
cm.Clear();
cm.PutAll(hm);
assertEquals(cm.size(), n);
CharArrayMap <int?> .EntryIterator iter2 = cm.EntrySet().GetEnumerator() as CharArrayMap <int?> .EntryIterator;
n = 0;
while (iter2.MoveNext())
{
var keyc = iter2.Current.Key;
int?val = iter2.Current.Value;
assertEquals(hm[keyc], val);
iter2.SetValue(val * 100);
assertEquals(val * 100, (int)cm.Get(keyc));
n++;
}
assertEquals(hm.Count, n);
cm.EntrySet().Clear();
assertEquals(0, cm.size());
assertEquals(0, cm.EntrySet().size());
assertTrue(cm.Count == 0);
}