← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/src/test/org/apache/lucene/analysis/TestCharTokenizers.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/src/test/org/apache/lucene/analysis/TestCharTokenizers.java
1
 
package org.apache.lucene.analysis;
2
 
 
3
 
/**
4
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
5
 
 * contributor license agreements.  See the NOTICE file distributed with
6
 
 * this work for additional information regarding copyright ownership.
7
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
8
 
 * (the "License"); you may not use this file except in compliance with
9
 
 * the License.  You may obtain a copy of the License at
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
13
 
 * Unless required by applicable law or agreed to in writing, software
14
 
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 
 * See the License for the specific language governing permissions and
17
 
 * limitations under the License.
18
 
 */
19
 
 
20
 
import java.io.IOException;
21
 
import java.io.Reader;
22
 
import java.io.StringReader;
23
 
 
24
 
import org.apache.lucene.util.Version;
25
 
 
26
 
/**
27
 
 * Testcase for {@link CharTokenizer} subclasses
28
 
 */
29
 
public class TestCharTokenizers extends BaseTokenStreamTestCase {
30
 
 
31
 
  /*
32
 
   * test to read surrogate pairs without loosing the pairing 
33
 
   * if the surrogate pair is at the border of the internal IO buffer
34
 
   */
35
 
  public void testReadSupplementaryChars() throws IOException {
36
 
    StringBuilder builder = new StringBuilder();
37
 
    // create random input
38
 
    int num = 1024 + random.nextInt(1024);
39
 
    num *= RANDOM_MULTIPLIER;
40
 
    for (int i = 1; i < num; i++) {
41
 
      builder.append("\ud801\udc1cabc");
42
 
      if((i % 10) == 0)
43
 
        builder.append(" ");
44
 
    }
45
 
    // internal buffer size is 1024 make sure we have a surrogate pair right at the border
46
 
    builder.insert(1023, "\ud801\udc1c");
47
 
    LowerCaseTokenizer tokenizer = new LowerCaseTokenizer(
48
 
        TEST_VERSION_CURRENT, new StringReader(builder.toString()));
49
 
    assertTokenStreamContents(tokenizer, builder.toString().toLowerCase().split(" "));
50
 
  }
51
 
  
52
 
  /*
53
 
   * test to extend the buffer TermAttribute buffer internally. If the internal
54
 
   * alg that extends the size of the char array only extends by 1 char and the
55
 
   * next char to be filled in is a supplementary codepoint (using 2 chars) an
56
 
   * index out of bound exception is triggered.
57
 
   */
58
 
  public void testExtendCharBuffer() throws IOException {
59
 
    for (int i = 0; i < 40; i++) {
60
 
      StringBuilder builder = new StringBuilder();
61
 
      for (int j = 0; j < 1+i; j++) {
62
 
        builder.append("a");
63
 
      }
64
 
      builder.append("\ud801\udc1cabc");
65
 
      LowerCaseTokenizer tokenizer = new LowerCaseTokenizer(
66
 
          TEST_VERSION_CURRENT, new StringReader(builder.toString()));
67
 
      assertTokenStreamContents(tokenizer, new String[] {builder.toString().toLowerCase()});
68
 
    }
69
 
  }
70
 
  
71
 
  /*
72
 
   * tests the max word length of 255 - tokenizer will split at the 255 char no matter what happens
73
 
   */
74
 
  public void testMaxWordLength() throws IOException {
75
 
    StringBuilder builder = new StringBuilder();
76
 
 
77
 
    for (int i = 0; i < 255; i++) {
78
 
      builder.append("A");
79
 
    }
80
 
    LowerCaseTokenizer tokenizer = new LowerCaseTokenizer(
81
 
        TEST_VERSION_CURRENT, new StringReader(builder.toString() + builder.toString()));
82
 
    assertTokenStreamContents(tokenizer, new String[] {builder.toString().toLowerCase(), builder.toString().toLowerCase()});
83
 
  }
84
 
  
85
 
  /*
86
 
   * tests the max word length of 255 with a surrogate pair at position 255
87
 
   */
88
 
  public void testMaxWordLengthWithSupplementary() throws IOException {
89
 
    StringBuilder builder = new StringBuilder();
90
 
 
91
 
    for (int i = 0; i < 254; i++) {
92
 
      builder.append("A");
93
 
    }
94
 
    builder.append("\ud801\udc1c");
95
 
    LowerCaseTokenizer tokenizer = new LowerCaseTokenizer(
96
 
        TEST_VERSION_CURRENT, new StringReader(builder.toString() + builder.toString()));
97
 
    assertTokenStreamContents(tokenizer, new String[] {builder.toString().toLowerCase(), builder.toString().toLowerCase()});
98
 
  }
99
 
 
100
 
  public void testLowerCaseTokenizer() throws IOException {
101
 
    StringReader reader = new StringReader("Tokenizer \ud801\udc1ctest");
102
 
    LowerCaseTokenizer tokenizer = new LowerCaseTokenizer(TEST_VERSION_CURRENT,
103
 
        reader);
104
 
    assertTokenStreamContents(tokenizer, new String[] { "tokenizer",
105
 
        "\ud801\udc44test" });
106
 
  }
107
 
 
108
 
  public void testLowerCaseTokenizerBWCompat() throws IOException {
109
 
    StringReader reader = new StringReader("Tokenizer \ud801\udc1ctest");
110
 
    LowerCaseTokenizer tokenizer = new LowerCaseTokenizer(Version.LUCENE_30,
111
 
        reader);
112
 
    assertTokenStreamContents(tokenizer, new String[] { "tokenizer", "test" });
113
 
  }
114
 
 
115
 
  public void testWhitespaceTokenizer() throws IOException {
116
 
    StringReader reader = new StringReader("Tokenizer \ud801\udc1ctest");
117
 
    WhitespaceTokenizer tokenizer = new WhitespaceTokenizer(TEST_VERSION_CURRENT,
118
 
        reader);
119
 
    assertTokenStreamContents(tokenizer, new String[] { "Tokenizer",
120
 
        "\ud801\udc1ctest" });
121
 
  }
122
 
 
123
 
  public void testWhitespaceTokenizerBWCompat() throws IOException {
124
 
    StringReader reader = new StringReader("Tokenizer \ud801\udc1ctest");
125
 
    WhitespaceTokenizer tokenizer = new WhitespaceTokenizer(Version.LUCENE_30,
126
 
        reader);
127
 
    assertTokenStreamContents(tokenizer, new String[] { "Tokenizer",
128
 
        "\ud801\udc1ctest" });
129
 
  }
130
 
 
131
 
  public void testIsTokenCharCharInSubclass() {
132
 
    new TestingCharTokenizer(Version.LUCENE_30, new StringReader(""));
133
 
    try {
134
 
      new TestingCharTokenizer(TEST_VERSION_CURRENT, new StringReader(""));
135
 
      fail("version 3.1 is not permitted if char based method is implemented");
136
 
    } catch (IllegalArgumentException e) {
137
 
      // expected
138
 
    }
139
 
  }
140
 
 
141
 
  public void testNormalizeCharInSubclass() {
142
 
    new TestingCharTokenizerNormalize(Version.LUCENE_30, new StringReader(""));
143
 
    try {
144
 
      new TestingCharTokenizerNormalize(TEST_VERSION_CURRENT,
145
 
          new StringReader(""));
146
 
      fail("version 3.1 is not permitted if char based method is implemented");
147
 
    } catch (IllegalArgumentException e) {
148
 
      // expected
149
 
    }
150
 
  }
151
 
 
152
 
  public void testNormalizeAndIsTokenCharCharInSubclass() {
153
 
    new TestingCharTokenizerNormalizeIsTokenChar(Version.LUCENE_30,
154
 
        new StringReader(""));
155
 
    try {
156
 
      new TestingCharTokenizerNormalizeIsTokenChar(TEST_VERSION_CURRENT,
157
 
          new StringReader(""));
158
 
      fail("version 3.1 is not permitted if char based method is implemented");
159
 
    } catch (IllegalArgumentException e) {
160
 
      // expected
161
 
    }
162
 
  }
163
 
 
164
 
  static final class TestingCharTokenizer extends CharTokenizer {
165
 
    public TestingCharTokenizer(Version matchVersion, Reader input) {
166
 
      super(matchVersion, input);
167
 
    }
168
 
 
169
 
    @Override
170
 
    protected boolean isTokenChar(int c) {
171
 
      return Character.isLetter(c);
172
 
    }
173
 
 
174
 
    @Deprecated @Override
175
 
    protected boolean isTokenChar(char c) {
176
 
      return Character.isLetter(c);
177
 
    }
178
 
  }
179
 
 
180
 
  static final class TestingCharTokenizerNormalize extends CharTokenizer {
181
 
    public TestingCharTokenizerNormalize(Version matchVersion, Reader input) {
182
 
      super(matchVersion, input);
183
 
    }
184
 
 
185
 
    @Deprecated @Override
186
 
    protected char normalize(char c) {
187
 
      return c;
188
 
    }
189
 
 
190
 
    @Override
191
 
    protected int normalize(int c) {
192
 
      return c;
193
 
    }
194
 
  }
195
 
 
196
 
  static final class TestingCharTokenizerNormalizeIsTokenChar extends CharTokenizer {
197
 
    public TestingCharTokenizerNormalizeIsTokenChar(Version matchVersion,
198
 
        Reader input) {
199
 
      super(matchVersion, input);
200
 
    }
201
 
 
202
 
    @Deprecated @Override
203
 
    protected char normalize(char c) {
204
 
      return c;
205
 
    }
206
 
 
207
 
    @Override
208
 
    protected int normalize(int c) {
209
 
      return c;
210
 
    }
211
 
 
212
 
    @Override
213
 
    protected boolean isTokenChar(int c) {
214
 
      return Character.isLetter(c);
215
 
    }
216
 
 
217
 
    @Deprecated @Override
218
 
    protected boolean isTokenChar(char c) {
219
 
      return Character.isLetter(c);
220
 
    }
221
 
  }
222
 
}