/** * @deprecated (3.1) remove this test when lucene 3.0 "broken unicode 4" support is no longer * needed. */ @Deprecated public void testSingleHighSurrogateBWComapt() { String missing = "Term %s is missing in the set"; String falsePos = "Term %s is in the set but shouldn't"; String[] upperArr = new String[] {"ABC\uD800", "ABC\uD800EfG", "\uD800EfG", "\uD800\ud801\udc1cB"}; String[] lowerArr = new String[] {"abc\uD800", "abc\uD800efg", "\uD800efg", "\uD800\ud801\udc44b"}; CharArraySet set = new CharArraySet(Version.LUCENE_3_0, Arrays.asList(TEST_STOP_WORDS), true); for (String upper : upperArr) { set.add(upper); } for (int i = 0; i < upperArr.length; i++) { assertTrue(String.format(Locale.ROOT, missing, upperArr[i]), set.contains(upperArr[i])); if (i == lowerArr.length - 1) assertFalse(String.format(Locale.ROOT, falsePos, lowerArr[i]), set.contains(lowerArr[i])); else assertTrue(String.format(Locale.ROOT, missing, lowerArr[i]), set.contains(lowerArr[i])); } set = new CharArraySet(Version.LUCENE_3_0, Arrays.asList(TEST_STOP_WORDS), false); for (String upper : upperArr) { set.add(upper); } for (int i = 0; i < upperArr.length; i++) { assertTrue(String.format(Locale.ROOT, missing, upperArr[i]), set.contains(upperArr[i])); assertFalse(String.format(Locale.ROOT, falsePos, lowerArr[i]), set.contains(lowerArr[i])); } }
/** * @deprecated (3.1) remove this test when lucene 3.0 "broken unicode 4" support is no longer * needed. */ @Deprecated public void testSupplementaryCharsBWCompat() { String missing = "Term %s is missing in the set"; String falsePos = "Term %s is in the set but shouldn't"; // for reference see // http://unicode.org/cldr/utility/list-unicodeset.jsp?a=[[%3ACase_Sensitive%3DTrue%3A]%26[^[\u0000-\uFFFF]]]&esc=on String[] upperArr = new String[] {"Abc\ud801\udc1c", "\ud801\udc1c\ud801\udc1cCDE", "A\ud801\udc1cB"}; String[] lowerArr = new String[] {"abc\ud801\udc44", "\ud801\udc44\ud801\udc44cde", "a\ud801\udc44b"}; CharArraySet set = new CharArraySet(Version.LUCENE_3_0, Arrays.asList(TEST_STOP_WORDS), true); for (String upper : upperArr) { set.add(upper); } for (int i = 0; i < upperArr.length; i++) { assertTrue(String.format(Locale.ROOT, missing, upperArr[i]), set.contains(upperArr[i])); assertFalse(String.format(Locale.ROOT, falsePos, lowerArr[i]), set.contains(lowerArr[i])); } set = new CharArraySet(Version.LUCENE_3_0, Arrays.asList(TEST_STOP_WORDS), false); for (String upper : upperArr) { set.add(upper); } for (int i = 0; i < upperArr.length; i++) { assertTrue(String.format(Locale.ROOT, missing, upperArr[i]), set.contains(upperArr[i])); assertFalse(String.format(Locale.ROOT, falsePos, lowerArr[i]), set.contains(lowerArr[i])); } }
public void testToString() { CharArraySet set = CharArraySet.copy(TEST_VERSION_CURRENT, Collections.singleton("test")); assertEquals("[test]", set.toString()); set.add("test2"); assertTrue(set.toString().contains(", ")); set = CharArraySet.copy(Version.LUCENE_3_0, Collections.singleton("test")); assertEquals("[test]", set.toString()); set.add("test2"); assertTrue(set.toString().contains(", ")); }
@SuppressWarnings("deprecated") public void testCopyCharArraySetBWCompat() { CharArraySet setIngoreCase = new CharArraySet(TEST_VERSION_CURRENT, 10, true); CharArraySet setCaseSensitive = new CharArraySet(TEST_VERSION_CURRENT, 10, false); List<String> stopwords = Arrays.asList(TEST_STOP_WORDS); List<String> stopwordsUpper = new ArrayList<>(); for (String string : stopwords) { stopwordsUpper.add(string.toUpperCase(Locale.ROOT)); } setIngoreCase.addAll(Arrays.asList(TEST_STOP_WORDS)); setIngoreCase.add(Integer.valueOf(1)); setCaseSensitive.addAll(Arrays.asList(TEST_STOP_WORDS)); setCaseSensitive.add(Integer.valueOf(1)); CharArraySet copy = CharArraySet.copy(TEST_VERSION_CURRENT, setIngoreCase); CharArraySet copyCaseSens = CharArraySet.copy(TEST_VERSION_CURRENT, setCaseSensitive); assertEquals(setIngoreCase.size(), copy.size()); assertEquals(setCaseSensitive.size(), copy.size()); assertTrue(copy.containsAll(stopwords)); assertTrue(copy.containsAll(stopwordsUpper)); assertTrue(copyCaseSens.containsAll(stopwords)); for (String string : stopwordsUpper) { assertFalse(copyCaseSens.contains(string)); } // test adding terms to the copy List<String> newWords = new ArrayList<>(); for (String string : stopwords) { newWords.add(string + "_1"); } copy.addAll(newWords); assertTrue(copy.containsAll(stopwords)); assertTrue(copy.containsAll(stopwordsUpper)); assertTrue(copy.containsAll(newWords)); // new added terms are not in the source set for (String string : newWords) { assertFalse(setIngoreCase.contains(string)); assertFalse(setCaseSensitive.contains(string)); } }
@Override public void init(Map<String, String> args) { super.init(args); String k = args.get(KEEP); if (k != null) { StringTokenizer st = new StringTokenizer(k); boolean ignoreCase = false; String ignoreStr = args.get(KEEP_IGNORE_CASE); if ("true".equalsIgnoreCase(ignoreStr)) { ignoreCase = true; } keep = new CharArraySet(10, ignoreCase); while (st.hasMoreTokens()) { k = st.nextToken().trim(); keep.add(k.toCharArray()); } } k = args.get(OK_PREFIX); if (k != null) { okPrefix = new ArrayList<char[]>(); StringTokenizer st = new StringTokenizer(k); while (st.hasMoreTokens()) { okPrefix.add(st.nextToken().trim().toCharArray()); } } k = args.get(MIN_WORD_LENGTH); if (k != null) { minWordLength = Integer.valueOf(k); } k = args.get(MAX_WORD_COUNT); if (k != null) { maxWordCount = Integer.valueOf(k); } k = args.get(MAX_TOKEN_LENGTH); if (k != null) { maxTokenLength = Integer.valueOf(k); } k = args.get(ONLY_FIRST_WORD); if (k != null) { onlyFirstWord = Boolean.valueOf(k); } k = args.get(FORCE_FIRST_LETTER); if (k != null) { forceFirstLetter = Boolean.valueOf(k); } }
public void testObjectContains() { CharArraySet set = new CharArraySet(TEST_VERSION_CURRENT, 10, true); Integer val = Integer.valueOf(1); set.add(val); assertTrue(set.contains(val)); assertTrue(set.contains(new Integer(1))); // another integer assertTrue(set.contains("1")); assertTrue(set.contains(new char[] {'1'})); // test unmodifiable set = CharArraySet.unmodifiableSet(set); assertTrue(set.contains(val)); assertTrue(set.contains(new Integer(1))); // another integer assertTrue(set.contains("1")); assertTrue(set.contains(new char[] {'1'})); }
public void testUnmodifiableSet() { CharArraySet set = new CharArraySet(TEST_VERSION_CURRENT, 10, true); set.addAll(Arrays.asList(TEST_STOP_WORDS)); set.add(Integer.valueOf(1)); final int size = set.size(); set = CharArraySet.unmodifiableSet(set); assertEquals("Set size changed due to unmodifiableSet call", size, set.size()); for (String stopword : TEST_STOP_WORDS) { assertTrue(set.contains(stopword)); } assertTrue(set.contains(Integer.valueOf(1))); assertTrue(set.contains("1")); assertTrue(set.contains(new char[] {'1'})); try { CharArraySet.unmodifiableSet(null); fail("can not make null unmodifiable"); } catch (NullPointerException e) { // expected } }
public void testModifyOnUnmodifiable() { CharArraySet set = new CharArraySet(TEST_VERSION_CURRENT, 10, true); set.addAll(Arrays.asList(TEST_STOP_WORDS)); final 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 (UnsupportedOperationException e) { // 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 (UnsupportedOperationException e) { // 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 (UnsupportedOperationException e) { // 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 (UnsupportedOperationException e) { // expected assertFalse("Changed unmodifiable set", set.contains(NOT_IN_SET)); assertEquals("Size of unmodifiable set has changed", size, set.size()); } try { set.add((Object) NOT_IN_SET); fail("Modified unmodifiable set"); } catch (UnsupportedOperationException e) { // 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()); } // 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, Arrays.asList(TEST_STOP_WORDS), true)); fail("Modified unmodifiable set"); } catch (UnsupportedOperationException e) { // expected assertEquals("Size of unmodifiable set has changed", size, set.size()); } try { set.retainAll(new CharArraySet(TEST_VERSION_CURRENT, Arrays.asList(NOT_IN_SET), true)); fail("Modified unmodifiable set"); } catch (UnsupportedOperationException e) { // expected assertEquals("Size of unmodifiable set has changed", size, set.size()); } try { set.addAll(Arrays.asList(NOT_IN_SET)); fail("Modified unmodifiable set"); } catch (UnsupportedOperationException e) { // 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 void testRehash() throws Exception { CharArraySet cas = new CharArraySet(TEST_VERSION_CURRENT, 0, true); for (int i = 0; i < TEST_STOP_WORDS.length; i++) cas.add(TEST_STOP_WORDS[i]); assertEquals(TEST_STOP_WORDS.length, cas.size()); for (int i = 0; i < TEST_STOP_WORDS.length; i++) assertTrue(cas.contains(TEST_STOP_WORDS[i])); }