From 7c2fd74b4563e00f9ad145ee173382405a91a7a7 Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Tue, 4 Aug 2026 09:25:38 +0200 Subject: [PATCH 1/8] feat: add ignoreKeywords flag to PatternReplaceFilter Co-authored-by: aider (openrouter/anthropic/claude-sonnet-4) --- .../pattern/PatternReplaceFilter.java | 24 +++++++++++++++++++ .../pattern/PatternReplaceFilterFactory.java | 4 +++- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java index 49ac24547296..88d8c76a5718 100644 --- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java +++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java @@ -22,6 +22,7 @@ import org.apache.lucene.analysis.TokenFilter; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; +import org.apache.lucene.analysis.tokenattributes.KeywordAttribute; /** * A TokenFilter which applies a Pattern to each token in the stream, replacing match occurrences @@ -35,7 +36,9 @@ public final class PatternReplaceFilter extends TokenFilter { private final String replacement; private final boolean all; + private final boolean ignoreKeywords; private final CharTermAttribute termAtt = addAttribute(CharTermAttribute.class); + private final KeywordAttribute keywordAtt = addAttribute(KeywordAttribute.class); private final Matcher m; /** @@ -50,9 +53,26 @@ public final class PatternReplaceFilter extends TokenFilter { * @see Matcher#quoteReplacement */ public PatternReplaceFilter(TokenStream in, Pattern p, String replacement, boolean all) { + this(in, p, replacement, all, false); + } + + /** + * Constructs an instance to replace either the first, or all occurrences + * + * @param in the TokenStream to process + * @param p the patterm to apply to each Token + * @param replacement the "replacement string" to substitute, if null a blank string will be used. + * Note that this is not the literal string that will be used, '$' and '\' have special + * meaning. + * @param all if true, all matches will be replaced otherwise just the first match. + * @param ignoreKeywords if true, tokens with KeywordAttribute set to true will not be processed + * @see Matcher#quoteReplacement + */ + public PatternReplaceFilter(TokenStream in, Pattern p, String replacement, boolean all, boolean ignoreKeywords) { super(in); this.replacement = (null == replacement) ? "" : replacement; this.all = all; + this.ignoreKeywords = ignoreKeywords; this.m = p.matcher(termAtt); } @@ -60,6 +80,10 @@ public PatternReplaceFilter(TokenStream in, Pattern p, String replacement, boole public boolean incrementToken() throws IOException { if (!input.incrementToken()) return false; + if (ignoreKeywords && keywordAtt.isKeyword()) { + return true; + } + m.reset(); if (m.find()) { // replaceAll/replaceFirst will reset() this previous find. diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilterFactory.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilterFactory.java index 3672209af75e..1c6e4ab476e4 100644 --- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilterFactory.java +++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilterFactory.java @@ -46,6 +46,7 @@ public class PatternReplaceFilterFactory extends TokenFilterFactory { final Pattern pattern; final String replacement; final boolean replaceAll; + final boolean ignoreKeywords; /** Creates a new PatternReplaceFilterFactory */ public PatternReplaceFilterFactory(Map args) { @@ -53,6 +54,7 @@ public PatternReplaceFilterFactory(Map args) { pattern = getPattern(args, "pattern"); replacement = get(args, "replacement"); replaceAll = "all".equals(get(args, "replace", Arrays.asList("all", "first"), "all")); + ignoreKeywords = getBoolean(args, "ignoreKeywords", false); if (!args.isEmpty()) { throw new IllegalArgumentException("Unknown parameters: " + args); } @@ -65,6 +67,6 @@ public PatternReplaceFilterFactory() { @Override public PatternReplaceFilter create(TokenStream input) { - return new PatternReplaceFilter(input, pattern, replacement, replaceAll); + return new PatternReplaceFilter(input, pattern, replacement, replaceAll, ignoreKeywords); } } From 1c9fa3ff387fb99faf53117025b337ded0fce68d Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Tue, 4 Aug 2026 10:25:47 +0200 Subject: [PATCH 2/8] refactor: remove overloaded constructor from PatternReplaceFilter Co-authored-by: aider (openrouter/anthropic/claude-sonnet-4) --- .../analysis/pattern/PatternReplaceFilter.java | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java index 88d8c76a5718..4371c073b1bd 100644 --- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java +++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java @@ -41,21 +41,6 @@ public final class PatternReplaceFilter extends TokenFilter { private final KeywordAttribute keywordAtt = addAttribute(KeywordAttribute.class); private final Matcher m; - /** - * Constructs an instance to replace either the first, or all occurrences - * - * @param in the TokenStream to process - * @param p the patterm to apply to each Token - * @param replacement the "replacement string" to substitute, if null a blank string will be used. - * Note that this is not the literal string that will be used, '$' and '\' have special - * meaning. - * @param all if true, all matches will be replaced otherwise just the first match. - * @see Matcher#quoteReplacement - */ - public PatternReplaceFilter(TokenStream in, Pattern p, String replacement, boolean all) { - this(in, p, replacement, all, false); - } - /** * Constructs an instance to replace either the first, or all occurrences * From 22286e30daa1e1a946b87beca936a543c0d47bda Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Tue, 4 Aug 2026 10:28:16 +0200 Subject: [PATCH 3/8] test: update PatternReplaceFilter constructor calls with ignoreKeywords parameter Co-authored-by: aider (openrouter/anthropic/claude-sonnet-4) --- .../pattern/TestPatternReplaceFilter.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java index c45b13889004..9f9eed5fc8e9 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java @@ -30,7 +30,7 @@ public class TestPatternReplaceFilter extends BaseTokenStreamTestCase { public void testReplaceAll() throws Exception { String input = "aabfooaabfooabfoob ab caaaaaaaaab"; TokenStream ts = - new PatternReplaceFilter(whitespaceMockTokenizer(input), Pattern.compile("a*b"), "-", true); + new PatternReplaceFilter(whitespaceMockTokenizer(input), Pattern.compile("a*b"), "-", true, false); assertTokenStreamContents(ts, new String[] {"-foo-foo-foo-", "-", "c-"}); } @@ -38,7 +38,7 @@ public void testReplaceFirst() throws Exception { String input = "aabfooaabfooabfoob ab caaaaaaaaab"; TokenStream ts = new PatternReplaceFilter( - whitespaceMockTokenizer(input), Pattern.compile("a*b"), "-", false); + whitespaceMockTokenizer(input), Pattern.compile("a*b"), "-", false, false); assertTokenStreamContents(ts, new String[] {"-fooaabfooabfoob", "-", "c-"}); } @@ -46,7 +46,7 @@ public void testStripFirst() throws Exception { String input = "aabfooaabfooabfoob ab caaaaaaaaab"; TokenStream ts = new PatternReplaceFilter( - whitespaceMockTokenizer(input), Pattern.compile("a*b"), null, false); + whitespaceMockTokenizer(input), Pattern.compile("a*b"), null, false, false); assertTokenStreamContents(ts, new String[] {"fooaabfooabfoob", "", "c"}); } @@ -54,7 +54,7 @@ public void testStripAll() throws Exception { String input = "aabfooaabfooabfoob ab caaaaaaaaab"; TokenStream ts = new PatternReplaceFilter( - whitespaceMockTokenizer(input), Pattern.compile("a*b"), null, true); + whitespaceMockTokenizer(input), Pattern.compile("a*b"), null, true, false); assertTokenStreamContents(ts, new String[] {"foofoofoo", "", "c"}); } @@ -62,7 +62,7 @@ public void testReplaceAllWithBackRef() throws Exception { String input = "aabfooaabfooabfoob ab caaaaaaaaab"; TokenStream ts = new PatternReplaceFilter( - whitespaceMockTokenizer(input), Pattern.compile("(a*)b"), "$1\\$", true); + whitespaceMockTokenizer(input), Pattern.compile("(a*)b"), "$1\\$", true, false); assertTokenStreamContents(ts, new String[] {"aa$fooaa$fooa$foo$", "a$", "caaaaaaaaa$"}); } @@ -74,7 +74,7 @@ public void testRandomStrings() throws Exception { protected TokenStreamComponents createComponents(String fieldName) { Tokenizer tokenizer = new MockTokenizer(MockTokenizer.WHITESPACE, false); TokenStream filter = - new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", false); + new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", false, false); return new TokenStreamComponents(tokenizer, filter); } }; @@ -87,7 +87,7 @@ protected TokenStreamComponents createComponents(String fieldName) { protected TokenStreamComponents createComponents(String fieldName) { Tokenizer tokenizer = new MockTokenizer(MockTokenizer.WHITESPACE, false); TokenStream filter = - new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", true); + new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", true, false); return new TokenStreamComponents(tokenizer, filter); } }; @@ -102,7 +102,7 @@ public void testEmptyTerm() throws IOException { protected TokenStreamComponents createComponents(String fieldName) { Tokenizer tokenizer = new KeywordTokenizer(); return new TokenStreamComponents( - tokenizer, new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", true)); + tokenizer, new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", true, false)); } }; checkOneTerm(a, "", ""); From 4b54d3e81430a60bef61ac32fc015ff7fbacb40e Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Tue, 4 Aug 2026 10:51:49 +0200 Subject: [PATCH 4/8] gradlew tidy --- .../lucene/analysis/pattern/PatternReplaceFilter.java | 3 ++- .../lucene/analysis/pattern/TestPatternReplaceFilter.java | 6 ++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java index 4371c073b1bd..79ff3094431d 100644 --- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java +++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/pattern/PatternReplaceFilter.java @@ -53,7 +53,8 @@ public final class PatternReplaceFilter extends TokenFilter { * @param ignoreKeywords if true, tokens with KeywordAttribute set to true will not be processed * @see Matcher#quoteReplacement */ - public PatternReplaceFilter(TokenStream in, Pattern p, String replacement, boolean all, boolean ignoreKeywords) { + public PatternReplaceFilter( + TokenStream in, Pattern p, String replacement, boolean all, boolean ignoreKeywords) { super(in); this.replacement = (null == replacement) ? "" : replacement; this.all = all; diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java index 9f9eed5fc8e9..52c585742b91 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java @@ -30,7 +30,8 @@ public class TestPatternReplaceFilter extends BaseTokenStreamTestCase { public void testReplaceAll() throws Exception { String input = "aabfooaabfooabfoob ab caaaaaaaaab"; TokenStream ts = - new PatternReplaceFilter(whitespaceMockTokenizer(input), Pattern.compile("a*b"), "-", true, false); + new PatternReplaceFilter( + whitespaceMockTokenizer(input), Pattern.compile("a*b"), "-", true, false); assertTokenStreamContents(ts, new String[] {"-foo-foo-foo-", "-", "c-"}); } @@ -102,7 +103,8 @@ public void testEmptyTerm() throws IOException { protected TokenStreamComponents createComponents(String fieldName) { Tokenizer tokenizer = new KeywordTokenizer(); return new TokenStreamComponents( - tokenizer, new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", true, false)); + tokenizer, + new PatternReplaceFilter(tokenizer, Pattern.compile("a"), "b", true, false)); } }; checkOneTerm(a, "", ""); From de80a5524f5b878c53a6aaa3c117b3a83924fef4 Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Tue, 4 Aug 2026 11:47:03 +0200 Subject: [PATCH 5/8] test: add ignoreKeywords functionality test for PatternReplaceFilter Co-authored-by: aider (openrouter/anthropic/claude-sonnet-4) --- .../pattern/TestPatternReplaceFilter.java | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java index 52c585742b91..3a214c9376d9 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java @@ -22,6 +22,8 @@ import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.analysis.Tokenizer; import org.apache.lucene.analysis.core.KeywordTokenizer; +import org.apache.lucene.analysis.miscellaneous.KeywordMarkerFilter; +import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.tests.analysis.BaseTokenStreamTestCase; import org.apache.lucene.tests.analysis.MockTokenizer; @@ -110,4 +112,77 @@ protected TokenStreamComponents createComponents(String fieldName) { checkOneTerm(a, "", ""); a.close(); } + + public void testIgnoreKeywords() throws Exception { + Analyzer a = + new Analyzer() { + @Override + protected TokenStreamComponents createComponents(String fieldName) { + Tokenizer tokenizer = new MockTokenizer(MockTokenizer.WHITESPACE, false); + KeywordMarkerFilter keywordFilter = + new KeywordMarkerFilter(tokenizer) { + private final CharTermAttribute term = addAttribute(CharTermAttribute.class); + + @Override + public boolean isKeyword() { + // Mark terms starting with 'k' as keywords + return term.toString().startsWith("k"); + } + }; + return new TokenStreamComponents( + tokenizer, + new PatternReplaceFilter(keywordFilter, Pattern.compile("a"), "X", true, true)); + } + }; + + // Without ignoreKeywords=true, both terms would have 'a' replaced with 'X' + // With ignoreKeywords=true, only non-keyword terms should be modified + assertAnalyzesTo( + a, + "banana kappa alpha", + new String[] {"bXnXnX", "kappa", "XlphX"}, // kappa unchanged, others modified + new int[] {0, 7, 13}, + new int[] {6, 12, 18}, + null, + new int[] {1, 1, 1}, + null, + false); + + a.close(); + + // Test with ignoreKeywords=false for comparison + Analyzer b = + new Analyzer() { + @Override + protected TokenStreamComponents createComponents(String fieldName) { + Tokenizer tokenizer = new MockTokenizer(MockTokenizer.WHITESPACE, false); + KeywordMarkerFilter keywordFilter = + new KeywordMarkerFilter(tokenizer) { + private final CharTermAttribute term = addAttribute(CharTermAttribute.class); + + @Override + public boolean isKeyword() { + return term.toString().startsWith("k"); + } + }; + return new TokenStreamComponents( + tokenizer, + new PatternReplaceFilter(keywordFilter, Pattern.compile("a"), "X", true, false)); + } + }; + + // With ignoreKeywords=false, all terms should be modified regardless of keyword status + assertAnalyzesTo( + b, + "banana kappa alpha", + new String[] {"bXnXnX", "kXppX", "XlphX"}, // all terms modified + new int[] {0, 7, 13}, + new int[] {6, 12, 18}, + null, + new int[] {1, 1, 1}, + null, + false); + + b.close(); + } } From 5675c8dadc9773d28ca0284daa44d283e88d9007 Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Tue, 4 Aug 2026 11:55:00 +0200 Subject: [PATCH 6/8] refactor: extract keywordTestAnalyzer helper method to reduce duplication Co-authored-by: aider (openrouter/anthropic/claude-sonnet-4) --- .../pattern/TestPatternReplaceFilter.java | 76 ++++++------------- 1 file changed, 25 insertions(+), 51 deletions(-) diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java index 3a214c9376d9..c66d4aa56dd0 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java @@ -113,32 +113,9 @@ protected TokenStreamComponents createComponents(String fieldName) { a.close(); } - public void testIgnoreKeywords() throws Exception { - Analyzer a = - new Analyzer() { - @Override - protected TokenStreamComponents createComponents(String fieldName) { - Tokenizer tokenizer = new MockTokenizer(MockTokenizer.WHITESPACE, false); - KeywordMarkerFilter keywordFilter = - new KeywordMarkerFilter(tokenizer) { - private final CharTermAttribute term = addAttribute(CharTermAttribute.class); - - @Override - public boolean isKeyword() { - // Mark terms starting with 'k' as keywords - return term.toString().startsWith("k"); - } - }; - return new TokenStreamComponents( - tokenizer, - new PatternReplaceFilter(keywordFilter, Pattern.compile("a"), "X", true, true)); - } - }; - - // Without ignoreKeywords=true, both terms would have 'a' replaced with 'X' - // With ignoreKeywords=true, only non-keyword terms should be modified + public void testKeywordFilter() throws Exception { assertAnalyzesTo( - a, + keywordTestAnalyzer(true), "banana kappa alpha", new String[] {"bXnXnX", "kappa", "XlphX"}, // kappa unchanged, others modified new int[] {0, 7, 13}, @@ -148,32 +125,8 @@ public boolean isKeyword() { null, false); - a.close(); - - // Test with ignoreKeywords=false for comparison - Analyzer b = - new Analyzer() { - @Override - protected TokenStreamComponents createComponents(String fieldName) { - Tokenizer tokenizer = new MockTokenizer(MockTokenizer.WHITESPACE, false); - KeywordMarkerFilter keywordFilter = - new KeywordMarkerFilter(tokenizer) { - private final CharTermAttribute term = addAttribute(CharTermAttribute.class); - - @Override - public boolean isKeyword() { - return term.toString().startsWith("k"); - } - }; - return new TokenStreamComponents( - tokenizer, - new PatternReplaceFilter(keywordFilter, Pattern.compile("a"), "X", true, false)); - } - }; - - // With ignoreKeywords=false, all terms should be modified regardless of keyword status assertAnalyzesTo( - b, + keywordTestAnalyzer(false), "banana kappa alpha", new String[] {"bXnXnX", "kXppX", "XlphX"}, // all terms modified new int[] {0, 7, 13}, @@ -182,7 +135,28 @@ public boolean isKeyword() { new int[] {1, 1, 1}, null, false); + } - b.close(); + private Analyzer keywordTestAnalyzer(boolean ignoreKeywords) throws Exception { + return new Analyzer() { + @Override + protected TokenStreamComponents createComponents(String fieldName) { + Tokenizer tokenizer = new MockTokenizer(MockTokenizer.WHITESPACE, false); + KeywordMarkerFilter keywordFilter = + new KeywordMarkerFilter(tokenizer) { + private final CharTermAttribute term = addAttribute(CharTermAttribute.class); + + @Override + public boolean isKeyword() { + // Mark terms starting with 'k' as keywords + return term.toString().startsWith("k"); + } + }; + return new TokenStreamComponents( + tokenizer, + new PatternReplaceFilter( + keywordFilter, Pattern.compile("a"), "X", true, ignoreKeywords)); + } + }; } } From 7a91b9dd156d168b983d267194ef12385ec82604 Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Sun, 9 Aug 2026 12:42:51 +0200 Subject: [PATCH 7/8] Simplify test and fix sporadic fail --- .../pattern/TestPatternReplaceFilter.java | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java index c66d4aa56dd0..b7b0b1b41a18 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java @@ -117,24 +117,12 @@ public void testKeywordFilter() throws Exception { assertAnalyzesTo( keywordTestAnalyzer(true), "banana kappa alpha", - new String[] {"bXnXnX", "kappa", "XlphX"}, // kappa unchanged, others modified - new int[] {0, 7, 13}, - new int[] {6, 12, 18}, - null, - new int[] {1, 1, 1}, - null, - false); + new String[] {"bXnXnX", "kappa", "XlphX"}); assertAnalyzesTo( keywordTestAnalyzer(false), "banana kappa alpha", - new String[] {"bXnXnX", "kXppX", "XlphX"}, // all terms modified - new int[] {0, 7, 13}, - new int[] {6, 12, 18}, - null, - new int[] {1, 1, 1}, - null, - false); + new String[] {"bXnXnX", "kXppX", "XlphX"}); } private Analyzer keywordTestAnalyzer(boolean ignoreKeywords) throws Exception { From 8a060fa4470726ee817a04324771fd3156c4cf5c Mon Sep 17 00:00:00 2001 From: Nathan Gass Date: Sun, 9 Aug 2026 12:47:03 +0200 Subject: [PATCH 8/8] gradlew tidy --- .../lucene/analysis/pattern/TestPatternReplaceFilter.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java index b7b0b1b41a18..bb87657757c2 100644 --- a/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java +++ b/lucene/analysis/common/src/test/org/apache/lucene/analysis/pattern/TestPatternReplaceFilter.java @@ -115,9 +115,7 @@ protected TokenStreamComponents createComponents(String fieldName) { public void testKeywordFilter() throws Exception { assertAnalyzesTo( - keywordTestAnalyzer(true), - "banana kappa alpha", - new String[] {"bXnXnX", "kappa", "XlphX"}); + keywordTestAnalyzer(true), "banana kappa alpha", new String[] {"bXnXnX", "kappa", "XlphX"}); assertAnalyzesTo( keywordTestAnalyzer(false),