public virtual void TestModifyOnUnmodifiable()
{
//System.Diagnostics.Debugger.Break();
CharArraySet set = new CharArraySet(10, true);
set.AddAll(TEST_STOP_WORDS);
int size = set.Count;
set = CharArraySet.UnmodifiableSet(set);
Assert.AreEqual(size, set.Count, "Set size changed due to UnmodifiableSet call");
System.String NOT_IN_SET = "SirGallahad";
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String already exists in set");
Assert.Throws <NotSupportedException>(() => set.Add(NOT_IN_SET.ToCharArray()), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws <NotSupportedException>(() => set.Add(NOT_IN_SET), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws <NotSupportedException>(() => set.Add(new System.Text.StringBuilder(NOT_IN_SET)), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws <NotSupportedException>(() => set.Clear(), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Changed unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws <NotSupportedException>(() => set.Add((object)NOT_IN_SET), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws <NotSupportedException>(() => set.RemoveAll(new List <string>(TEST_STOP_WORDS)), "Modified unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws <NotSupportedException>(() => set.RetainAll(new List <string>(new[] { NOT_IN_SET })), "Modified unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws <NotSupportedException>(() => set.AddAll(new List <string>(new[] { NOT_IN_SET })), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
Assert.IsTrue(set.Contains(TEST_STOP_WORDS[i]));
}
}
/// <summary> </summary>
/// <param name="stopWords">A List of Strings representing the stopwords
/// </param>
/// <param name="ignoreCase">if true, all words are lower cased first
/// </param>
/// <returns> A Set containing the words
/// </returns>
public static ICollection <string> MakeStopSet(ICollection <string> stopWords, bool ignoreCase)
{
CharArraySet stopSet = new CharArraySet(stopWords.Count, ignoreCase);
stopSet.Add(stopWords);
return(stopSet);
}
public static CharArraySet UnmodifiableSet(ICollection <string> items)
{
CharArraySet set = new CharArraySet(items.Count, true);
set.Add(items);
set.IsReadOnly = true;
return(set);
}
public virtual void TestClear()
{
var set = new CharArraySet(10, true);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++) { set.Add(TEST_STOP_WORDS[i]); }
Assert.AreEqual(TEST_STOP_WORDS.Length, set.Count, "Not all words added");
Assert.Throws<NotSupportedException>(set.Clear, "remove is not supported");
Assert.AreEqual(TEST_STOP_WORDS.Length, set.Count, "Not all words added");
}
static StopAnalyzer()
{
{
System.String[] stopWords = new System.String[] { "a", "an", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with" };
CharArraySet stopSet = new CharArraySet(stopWords.Length, false);
stopSet.Add(stopWords);
ENGLISH_STOP_WORDS_SET = CharArraySet.UnmodifiableSet((ICollection <string>)stopSet);
}
}
public virtual void TestRehash()
{
CharArraySet cas = new CharArraySet(0, true);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
cas.Add(TEST_STOP_WORDS[i]);
Assert.AreEqual(TEST_STOP_WORDS.Length, cas.Count);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
Assert.IsTrue(cas.Contains(TEST_STOP_WORDS[i]));
}
public virtual void TestNonZeroOffset()
{
System.String[] words = new System.String[]{"Hello", "World", "this", "is", "a", "test"};
char[] findme = "xthisy".ToCharArray();
CharArraySet set_Renamed = new CharArraySet(10, true);
for (int i = 0; i < words.Length; i++) { set_Renamed.Add(words[i]); }
Assert.IsTrue(set_Renamed.Contains(findme, 1, 4));
Assert.IsTrue(set_Renamed.Contains(new System.String(findme, 1, 4)));
}
/// <summary> </summary>
/// <param name="stopWords">A List of Strings or char[] or any other toString()-able list representing the stopwords </param>
/// <param name="ignoreCase">if true, all words are lower cased first</param>
/// <returns>A Set (<see cref="CharArraySet"/>)containing the words</returns>
public static ISet <string> MakeStopSet(IList <object> stopWords, bool ignoreCase)
{
var stopSet = new CharArraySet(stopWords.Count, ignoreCase);
foreach (var word in stopWords)
{
stopSet.Add(word.ToString());
}
return(stopSet);
}
/// <summary> </summary>
/// <param name="stopWords">
/// </param>
/// <param name="ignoreCase">If true, all words are lower cased first.
/// </param>
/// <returns> a Set containing the words
/// </returns>
public static System.Collections.Hashtable MakeStopSet(System.String[] stopWords, bool ignoreCase)
{
CharArraySet stopSet = new CharArraySet(stopWords.Length, ignoreCase);
for (int i = 0; i < stopWords.Length; i++)
{
stopSet.Add(stopWords[i]);
}
return(stopSet);
}
public virtual void TestObjectContains()
{
CharArraySet set_Renamed = new CharArraySet(10, true);
System.Int32 val = 1;
set_Renamed.Add((System.Object) val);
Assert.IsTrue(set_Renamed.Contains((System.Object) val));
Assert.IsTrue(set_Renamed.Contains((System.Object) 1));
// test unmodifiable
set_Renamed = CharArraySet.UnmodifiableSet(set_Renamed);
Assert.IsTrue(set_Renamed.Contains((System.Object) val));
Assert.IsTrue(set_Renamed.Contains((System.Object) 1));
}
public virtual void TestClear()
{
var set = new CharArraySet(10, true);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
set.Add(TEST_STOP_WORDS[i]);
}
Assert.AreEqual(TEST_STOP_WORDS.Length, set.Count, "Not all words added");
Assert.Throws <NotSupportedException>(set.Clear, "remove is not supported");
Assert.AreEqual(TEST_STOP_WORDS.Length, set.Count, "Not all words added");
}
public virtual void TestObjectContains()
{
CharArraySet set_Renamed = new CharArraySet(10, true);
System.Int32 val = 1;
set_Renamed.Add((System.Object)val);
Assert.IsTrue(set_Renamed.Contains((System.Object)val));
Assert.IsTrue(set_Renamed.Contains((System.Object) 1));
// test unmodifiable
set_Renamed = CharArraySet.UnmodifiableSet(set_Renamed);
Assert.IsTrue(set_Renamed.Contains((System.Object)val));
Assert.IsTrue(set_Renamed.Contains((System.Object) 1));
}
public virtual void TestRehash()
{
CharArraySet cas = new CharArraySet(0, true);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
cas.Add(TEST_STOP_WORDS[i]);
}
Assert.AreEqual(TEST_STOP_WORDS.Length, cas.Count);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
Assert.IsTrue(cas.Contains(TEST_STOP_WORDS[i]));
}
}
public virtual void TestClear()
{
CharArraySet set_Renamed = new CharArraySet(10, true);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++) { set_Renamed.Add(TEST_STOP_WORDS[i]); }
Assert.AreEqual(TEST_STOP_WORDS.Length, set_Renamed.Count, "Not all words added");
try
{
set_Renamed.Clear();
Assert.Fail("remove is not supported");
}
catch (System.NotSupportedException e)
{
// expected
Assert.AreEqual(TEST_STOP_WORDS.Length, set_Renamed.Count, "Not all words added");
}
}
public virtual void TestNonZeroOffset()
{
System.String[] words = new System.String[] { "Hello", "World", "this", "is", "a", "test" };
char[] findme = "xthisy".ToCharArray();
CharArraySet set_Renamed = new CharArraySet(10, true);
for (int i = 0; i < words.Length; i++)
{
set_Renamed.Add(words[i]);
}
Assert.IsTrue(set_Renamed.Contains(findme, 1, 4));
Assert.IsTrue(set_Renamed.Contains(new System.String(findme, 1, 4)));
// test unmodifiable
set_Renamed = CharArraySet.UnmodifiableSet(set_Renamed);
Assert.IsTrue(set_Renamed.Contains(findme, 1, 4));
Assert.IsTrue(set_Renamed.Contains(new System.String(findme, 1, 4)));
}
public virtual void TestClear()
{
CharArraySet set_Renamed = new CharArraySet(10, true);
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
set_Renamed.Add(TEST_STOP_WORDS[i]);
}
Assert.AreEqual(TEST_STOP_WORDS.Length, set_Renamed.Count, "Not all words added");
try
{
set_Renamed.Clear();
Assert.Fail("remove is not supported");
}
catch (System.NotSupportedException e)
{
// expected
Assert.AreEqual(TEST_STOP_WORDS.Length, set_Renamed.Count, "Not all words added");
}
}
public virtual void TestModifyOnUnmodifiable()
{
//System.Diagnostics.Debugger.Break();
CharArraySet set_Renamed = new CharArraySet(10, true);
set_Renamed.AddAll(TEST_STOP_WORDS);
int size = set_Renamed.Count;
set_Renamed = CharArraySet.UnmodifiableSet(set_Renamed);
Assert.AreEqual(size, set_Renamed.Count, "Set size changed due to UnmodifiableSet call");
System.String NOT_IN_SET = "SirGallahad";
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String already exists in set");
try
{
set_Renamed.Add(NOT_IN_SET.ToCharArray());
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Add(NOT_IN_SET);
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Add(new System.Text.StringBuilder(NOT_IN_SET));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Clear();
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Changed unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Add((System.Object) NOT_IN_SET);
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.RemoveAll(new System.Collections.ArrayList(TEST_STOP_WORDS));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.RetainAll(new System.Collections.ArrayList(new System.String[] { NOT_IN_SET }));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.AddAll(new System.Collections.ArrayList(new System.String[] { NOT_IN_SET }));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
}
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
Assert.IsTrue(set_Renamed.Contains(TEST_STOP_WORDS[i]));
}
}
/// <summary> </summary>
/// <param name="stopWords">
/// </param>
/// <param name="ignoreCase">If true, all words are lower cased first.
/// </param>
/// <returns> a Set containing the words
/// </returns>
public static System.Collections.Hashtable MakeStopSet(System.String[] stopWords, bool ignoreCase)
{
CharArraySet stopSet = new CharArraySet(stopWords.Length, ignoreCase);
for (int i = 0; i < stopWords.Length; i++)
{
stopSet.Add(stopWords[i]);
}
return stopSet;
}
public virtual void TestUnmodifiableSet()
{
CharArraySet set_Renamed = new CharArraySet(10, true);
set_Renamed.Add(TEST_STOP_WORDS);
int size = set_Renamed.Count;
set_Renamed = CharArraySet.UnmodifiableSet(set_Renamed);
Assert.AreEqual(size, set_Renamed.Count, "Set size changed due to UnmodifiableSet call");
try
{
CharArraySet.UnmodifiableSet(null);
Assert.Fail("can not make null unmodifiable");
}
catch (System.NullReferenceException e)
{
// expected
}
}
public virtual void TestModifyOnUnmodifiable()
{
//System.Diagnostics.Debugger.Break();
CharArraySet set_Renamed = new CharArraySet(10, true);
set_Renamed.AddAll(TEST_STOP_WORDS);
int size = set_Renamed.Count;
set_Renamed = CharArraySet.UnmodifiableSet(set_Renamed);
Assert.AreEqual(size, set_Renamed.Count, "Set size changed due to UnmodifiableSet call");
System.String NOT_IN_SET = "SirGallahad";
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String already exists in set");
try
{
set_Renamed.Add(NOT_IN_SET.ToCharArray());
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Add(NOT_IN_SET);
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Add(new System.Text.StringBuilder(NOT_IN_SET));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Clear();
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Changed unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.Add((System.Object)NOT_IN_SET);
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.RemoveAll(new System.Collections.ArrayList(TEST_STOP_WORDS));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.RetainAll(new System.Collections.ArrayList(new System.String[] { NOT_IN_SET }));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.AreEqual(size, set_Renamed.Count, "Size of unmodifiable set has changed");
}
try
{
set_Renamed.AddAll(new System.Collections.ArrayList(new System.String[] { NOT_IN_SET }));
Assert.Fail("Modified unmodifiable set");
}
catch (System.NotSupportedException e)
{
// expected
Assert.IsFalse(set_Renamed.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
}
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
Assert.IsTrue(set_Renamed.Contains(TEST_STOP_WORDS[i]));
}
}
/// <summary> </summary>
/// <param name="stopWords">A List of Strings or char[] or any other toString()-able list representing the stopwords </param>
/// <param name="ignoreCase">if true, all words are lower cased first</param>
/// <returns>A Set (<see cref="CharArraySet"/>)containing the words</returns>
public static ISet<string> MakeStopSet(IList<object> stopWords, bool ignoreCase)
{
var stopSet = new CharArraySet(stopWords.Count, ignoreCase);
foreach(var word in stopWords)
stopSet.Add(word.ToString());
return stopSet;
}
/// <summary> </summary>
/// <param name="stopWords">A List of Strings representing the stopwords
/// </param>
/// <param name="ignoreCase">if true, all words are lower cased first
/// </param>
/// <returns> A Set containing the words
/// </returns>
public static ICollection<string> MakeStopSet(ICollection<string> stopWords, bool ignoreCase)
{
CharArraySet stopSet = new CharArraySet(stopWords.Count, ignoreCase);
stopSet.Add(stopWords);
return stopSet;
}
public virtual void TestModifyOnUnmodifiable()
{
//System.Diagnostics.Debugger.Break();
CharArraySet set = new CharArraySet(10, true);
set.AddAll(TEST_STOP_WORDS);
int size = set.Count;
set = CharArraySet.UnmodifiableSet(set);
Assert.AreEqual(size, set.Count, "Set size changed due to UnmodifiableSet call");
System.String NOT_IN_SET = "SirGallahad";
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String already exists in set");
Assert.Throws<NotSupportedException>(() => set.Add(NOT_IN_SET.ToCharArray()), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws<NotSupportedException>(() => set.Add(NOT_IN_SET), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws<NotSupportedException>(() => set.Add(new System.Text.StringBuilder(NOT_IN_SET)), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws<NotSupportedException>(() => set.Clear(), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Changed unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws<NotSupportedException>(() => set.Add((object)NOT_IN_SET), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws<NotSupportedException>(() => set.RemoveAll(new List<string>(TEST_STOP_WORDS)), "Modified unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws<NotSupportedException>(() => set.RetainAll(new List<string>(new[] { NOT_IN_SET })), "Modified unmodifiable set");
Assert.AreEqual(size, set.Count, "Size of unmodifiable set has changed");
Assert.Throws<NotSupportedException>(() => set.AddAll(new List<string>(new[] { NOT_IN_SET })), "Modified unmodifiable set");
Assert.IsFalse(set.Contains(NOT_IN_SET), "Test String has been added to unmodifiable set");
for (int i = 0; i < TEST_STOP_WORDS.Length; i++)
{
Assert.IsTrue(set.Contains(TEST_STOP_WORDS[i]));
}
}
static StopAnalyzer()
{
{
System.String[] stopWords = new System.String[]{"a", "an", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"};
CharArraySet stopSet = new CharArraySet(stopWords.Length, false);
stopSet.Add(stopWords);
ENGLISH_STOP_WORDS_SET = CharArraySet.UnmodifiableSet((ICollection<string>)stopSet);
}
}
