public virtual void TestCopyEmptySet()
{
assertSame(CharArraySet.EMPTY_SET, CharArraySet.Copy(TEST_VERSION_CURRENT, CharArraySet.EMPTY_SET));
}
/// <summary>
/// Creates a new instance initialized with the given stopword set
/// </summary>
/// <param name="version">
/// the Lucene version for cross version compatibility </param>
/// <param name="stopwords">
/// the analyzer's stopword set </param>
protected internal StopwordAnalyzerBase(Version version, CharArraySet stopwords)
{
matchVersion = version;
// analyzers should use char array set for stopwords!
this.stopwords = stopwords == null ? CharArraySet.EMPTY_SET : CharArraySet.UnmodifiableSet(CharArraySet.Copy(version, stopwords));
}
public virtual void TestModifyOnUnmodifiable()
{
CharArraySet set = new CharArraySet(TEST_VERSION_CURRENT, 10, true);
set.UnionWith(TEST_STOP_WORDS);
int size = set.size();
set = CharArraySet.UnmodifiableSet(set);
assertEquals("Set size changed due to unmodifiableSet call", size, set.size());
string NOT_IN_SET = "SirGallahad";
assertFalse("Test String already exists in set", set.Contains(NOT_IN_SET));
try
{
set.Add(NOT_IN_SET.ToCharArray());
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable set", set.contains(NOT_IN_SET));
assertEquals("Size of unmodifiable set has changed", size, set.size());
}
try
{
set.add(NOT_IN_SET);
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable set", set.contains(NOT_IN_SET));
assertEquals("Size of unmodifiable set has changed", size, set.size());
}
try
{
set.Add(new StringBuilder(NOT_IN_SET));
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable set", set.contains(NOT_IN_SET));
assertEquals("Size of unmodifiable set has changed", size, set.size());
}
try
{
set.clear();
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertFalse("Changed unmodifiable set", set.contains(NOT_IN_SET));
assertEquals("Size of unmodifiable set has changed", size, set.size());
}
try
{
set.add(NOT_IN_SET);
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable set", set.contains(NOT_IN_SET));
assertEquals("Size of unmodifiable set has changed", size, set.size());
}
// NOTE: This results in a StackOverflow exception. Since this is not a public member of CharArraySet,
// but an extension method for the test fixture (which apparently has a bug), this test is non-critical
//// This test was changed in 3.1, as a contains() call on the given Collection using the "correct" iterator's
//// current key (now a char[]) on a Set<String> would not hit any element of the CAS and therefor never call
//// remove() on the iterator
//try
//{
// set.removeAll(new CharArraySet(TEST_VERSION_CURRENT, TEST_STOP_WORDS, true));
// fail("Modified unmodifiable set");
//}
//catch (NotSupportedException)
//{
// // expected
// assertEquals("Size of unmodifiable set has changed", size, set.size());
//}
#region Added for better .NET support
// This test was added for .NET to check the Remove method, since the extension method
// above fails to execute.
try
{
#pragma warning disable 612, 618
set.Remove(TEST_STOP_WORDS[0]);
#pragma warning restore 612, 618
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable set has changed", size, set.size());
}
#endregion
try
{
set.retainAll(new CharArraySet(TEST_VERSION_CURRENT, new [] { NOT_IN_SET }, true));
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable set has changed", size, set.size());
}
try
{
set.addAll(new[] { NOT_IN_SET });
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable set", set.contains(NOT_IN_SET));
}
// LUCENENET Specific - added to test .NETified UnionWith method
try
{
set.UnionWith(new[] { NOT_IN_SET });
fail("Modified unmodifiable set");
}
catch (NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable set", set.contains(NOT_IN_SET));
}
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
assertTrue(set.contains(TEST_STOP_WORDS[i]));
}
}
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 (Exception ue) when(ue.IsUnsupportedOperationException())
{
// 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);
}