public virtual void TestUnmodifiableSet() { var set = new CharArraySet(TEST_VERSION_CURRENT, 10, true); set.UnionWith(TEST_STOP_WORDS); set.Add(Convert.ToInt32(1)); int size = set.size(); set = CharArraySet.UnmodifiableSet(set); assertEquals("Set size changed due to unmodifiableSet call", size, set.size()); foreach (var stopword in TEST_STOP_WORDS) { assertTrue(set.Contains(stopword)); } assertTrue(set.Contains(Convert.ToInt32(1))); assertTrue(set.Contains("1")); assertTrue(set.Contains(new[] { '1' })); try { CharArraySet.UnmodifiableSet(null); fail("can not make null unmodifiable"); } catch (System.ArgumentNullException) // NOTE: In .NET we throw an ArgumentExcpetion, not a NullReferenceExeption { // expected } }
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.UnionWith(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.UnionWith(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 TestUnionWithCharSequence() { var originalValues = new string[] { "sally", "sells", "seashells", "by", "the", "sea", "shore" }; CharArraySet target = new CharArraySet(TEST_VERSION_CURRENT, originalValues, false); var existingValues = new List <ICharSequence> { new StringCharSequence("seashells"), new StringCharSequence("sea"), new StringCharSequence("shore") }; var mixedExistingNonExistingValues = new List <ICharSequence> { new StringCharSequence("true"), new StringCharSequence("set"), new StringCharSequence("of"), new StringCharSequence("unique"), new StringCharSequence("values"), new StringCharSequence("except"), new StringCharSequence("sells") }; // Add existing values assertFalse(target.UnionWith(existingValues)); assertEquals(7, target.Count); CollectionAssert.AreEquivalent(originalValues, target); // Add mixed existing/non-existing values assertTrue(target.UnionWith(mixedExistingNonExistingValues)); assertEquals(13, target.Count); CollectionAssert.AreEquivalent(new string[] { "sally", "sells", "seashells", "by", "the", "sea", "shore", "true", "set", "of", "unique", "values", "except" }, target); }
public virtual void TestNonZeroOffset() { string[] words = new string[] { "Hello", "World", "this", "is", "a", "test" }; char[] findme = "xthisy".ToCharArray(); CharArraySet set = new CharArraySet(TEST_VERSION_CURRENT, 10, true); set.UnionWith(words); assertTrue(set.Contains(findme, 1, 4)); assertTrue(set.Contains(new string(findme, 1, 4))); // test unmodifiable set = CharArraySet.UnmodifiableSet(set); assertTrue(set.Contains(findme, 1, 4)); assertTrue(set.Contains(new string(findme, 1, 4))); }
/// <summary> /// Returns as <seealso cref="CharArraySet"/> from wordFiles, which /// can be a comma-separated list of filenames /// </summary> protected internal CharArraySet GetWordSet(IResourceLoader loader, string wordFiles, bool ignoreCase) { AssureMatchVersion(); IEnumerable <string> files = SplitFileNames(wordFiles); CharArraySet words = null; if (files.Count() > 0) { // default stopwords list has 35 or so words, but maybe don't make it that // big to start words = new CharArraySet(luceneMatchVersion, files.Count() * 10, ignoreCase); foreach (string file in files) { var wlist = GetLines(loader, file.Trim()); words.UnionWith(StopFilter.MakeStopSet(luceneMatchVersion, wlist, ignoreCase)); } } return(words); }
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 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 (Exception e) when(e.IsUnsupportedOperationException()) { // 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 (Exception e) when(e.IsUnsupportedOperationException()) { // 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 (Exception e) when(e.IsUnsupportedOperationException()) { // 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 (Exception e) when(e.IsUnsupportedOperationException()) { // 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 (Exception e) when(e.IsUnsupportedOperationException()) { // 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 (Exception e) when (e.IsUnsupportedOperationException()) //{ // // expected // assertEquals("Size of unmodifiable set has changed", size, set.size()); //} #region LUCENENET 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 (Exception e) when(e.IsUnsupportedOperationException()) { // expected assertEquals("Size of unmodifiable set has changed", size, set.size()); } // LUCENENET Specific - added to test .NETified UnionWith method try { set.UnionWith(new[] { NOT_IN_SET }); fail("Modified unmodifiable set"); } catch (Exception e) when(e.IsUnsupportedOperationException()) { // expected assertFalse("Test String has been added to unmodifiable set", set.contains(NOT_IN_SET)); } #endregion LUCENENET Added for better .NET support try { set.retainAll(new CharArraySet(TEST_VERSION_CURRENT, new [] { NOT_IN_SET }, true)); fail("Modified unmodifiable set"); } catch (Exception e) when(e.IsUnsupportedOperationException()) { // expected assertEquals("Size of unmodifiable set has changed", size, set.size()); } try { set.addAll(new[] { NOT_IN_SET }); fail("Modified unmodifiable set"); } catch (Exception e) when(e.IsUnsupportedOperationException()) { // 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])); } }