← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lucene/backwards/src/test/org/apache/lucene/analysis/tokenattributes/TestCharTermAttributeImpl.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/backwards/src/test/org/apache/lucene/analysis/tokenattributes/TestCharTermAttributeImpl.java
1
 
package org.apache.lucene.analysis.tokenattributes;
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 org.apache.lucene.util.LuceneTestCase;
21
 
import org.apache.lucene.util._TestUtil;
22
 
import java.nio.CharBuffer;
23
 
import java.util.Collections;
24
 
import java.util.Formatter;
25
 
import java.util.Locale;
26
 
import java.util.regex.Pattern;
27
 
 
28
 
public class TestCharTermAttributeImpl extends LuceneTestCase {
29
 
 
30
 
  public void testResize() {
31
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
32
 
    char[] content = "hello".toCharArray();
33
 
    t.copyBuffer(content, 0, content.length);
34
 
    for (int i = 0; i < 2000; i++)
35
 
    {
36
 
      t.resizeBuffer(i);
37
 
      assertTrue(i <= t.buffer().length);
38
 
      assertEquals("hello", t.toString());
39
 
    }
40
 
  }
41
 
 
42
 
  public void testGrow() {
43
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
44
 
    StringBuilder buf = new StringBuilder("ab");
45
 
    for (int i = 0; i < 20; i++)
46
 
    {
47
 
      char[] content = buf.toString().toCharArray();
48
 
      t.copyBuffer(content, 0, content.length);
49
 
      assertEquals(buf.length(), t.length());
50
 
      assertEquals(buf.toString(), t.toString());
51
 
      buf.append(buf.toString());
52
 
    }
53
 
    assertEquals(1048576, t.length());
54
 
 
55
 
    // now as a StringBuilder, first variant
56
 
    t = new CharTermAttributeImpl();
57
 
    buf = new StringBuilder("ab");
58
 
    for (int i = 0; i < 20; i++)
59
 
    {
60
 
      t.setEmpty().append(buf);
61
 
      assertEquals(buf.length(), t.length());
62
 
      assertEquals(buf.toString(), t.toString());
63
 
      buf.append(t);
64
 
    }
65
 
    assertEquals(1048576, t.length());
66
 
 
67
 
    // Test for slow growth to a long term
68
 
    t = new CharTermAttributeImpl();
69
 
    buf = new StringBuilder("a");
70
 
    for (int i = 0; i < 20000; i++)
71
 
    {
72
 
      t.setEmpty().append(buf);
73
 
      assertEquals(buf.length(), t.length());
74
 
      assertEquals(buf.toString(), t.toString());
75
 
      buf.append("a");
76
 
    }
77
 
    assertEquals(20000, t.length());
78
 
  }
79
 
 
80
 
  public void testToString() throws Exception {
81
 
    char[] b = {'a', 'l', 'o', 'h', 'a'};
82
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
83
 
    t.copyBuffer(b, 0, 5);
84
 
    assertEquals("aloha", t.toString());
85
 
 
86
 
    t.setEmpty().append("hi there");
87
 
    assertEquals("hi there", t.toString());
88
 
  }
89
 
 
90
 
  public void testClone() throws Exception {
91
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
92
 
    char[] content = "hello".toCharArray();
93
 
    t.copyBuffer(content, 0, 5);
94
 
    char[] buf = t.buffer();
95
 
    CharTermAttributeImpl copy = (CharTermAttributeImpl) TestSimpleAttributeImpls.assertCloneIsEqual(t);
96
 
    assertEquals(t.toString(), copy.toString());
97
 
    assertNotSame(buf, copy.buffer());
98
 
  }
99
 
  
100
 
  public void testEquals() throws Exception {
101
 
    CharTermAttributeImpl t1a = new CharTermAttributeImpl();
102
 
    char[] content1a = "hello".toCharArray();
103
 
    t1a.copyBuffer(content1a, 0, 5);
104
 
    CharTermAttributeImpl t1b = new CharTermAttributeImpl();
105
 
    char[] content1b = "hello".toCharArray();
106
 
    t1b.copyBuffer(content1b, 0, 5);
107
 
    CharTermAttributeImpl t2 = new CharTermAttributeImpl();
108
 
    char[] content2 = "hello2".toCharArray();
109
 
    t2.copyBuffer(content2, 0, 6);
110
 
    assertTrue(t1a.equals(t1b));
111
 
    assertFalse(t1a.equals(t2));
112
 
    assertFalse(t2.equals(t1b));
113
 
  }
114
 
  
115
 
  public void testCopyTo() throws Exception {
116
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
117
 
    CharTermAttributeImpl copy = (CharTermAttributeImpl) TestSimpleAttributeImpls.assertCopyIsEqual(t);
118
 
    assertEquals("", t.toString());
119
 
    assertEquals("", copy.toString());
120
 
 
121
 
    t = new CharTermAttributeImpl();
122
 
    char[] content = "hello".toCharArray();
123
 
    t.copyBuffer(content, 0, 5);
124
 
    char[] buf = t.buffer();
125
 
    copy = (CharTermAttributeImpl) TestSimpleAttributeImpls.assertCopyIsEqual(t);
126
 
    assertEquals(t.toString(), copy.toString());
127
 
    assertNotSame(buf, copy.buffer());
128
 
  }
129
 
  
130
 
  public void testAttributeReflection() throws Exception {
131
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
132
 
    t.append("foobar");
133
 
    _TestUtil.assertAttributeReflection(t,
134
 
      Collections.singletonMap(CharTermAttribute.class.getName() + "#term", "foobar"));
135
 
  }
136
 
  
137
 
  public void testCharSequenceInterface() {
138
 
    final String s = "0123456789"; 
139
 
    final CharTermAttributeImpl t = new CharTermAttributeImpl();
140
 
    t.append(s);
141
 
    
142
 
    assertEquals(s.length(), t.length());
143
 
    assertEquals("12", t.subSequence(1,3).toString());
144
 
    assertEquals(s, t.subSequence(0,s.length()).toString());
145
 
    
146
 
    assertTrue(Pattern.matches("01\\d+", t));
147
 
    assertTrue(Pattern.matches("34", t.subSequence(3,5)));
148
 
    
149
 
    assertEquals(s.subSequence(3,7).toString(), t.subSequence(3,7).toString());
150
 
    
151
 
    for (int i = 0; i < s.length(); i++) {
152
 
      assertTrue(t.charAt(i) == s.charAt(i));
153
 
    }
154
 
  }
155
 
 
156
 
  public void testAppendableInterface() {
157
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
158
 
    Formatter formatter = new Formatter(t, Locale.US);
159
 
    formatter.format("%d", 1234);
160
 
    assertEquals("1234", t.toString());
161
 
    formatter.format("%d", 5678);
162
 
    assertEquals("12345678", t.toString());
163
 
    t.append('9');
164
 
    assertEquals("123456789", t.toString());
165
 
    t.append((CharSequence) "0");
166
 
    assertEquals("1234567890", t.toString());
167
 
    t.append((CharSequence) "0123456789", 1, 3);
168
 
    assertEquals("123456789012", t.toString());
169
 
    t.append((CharSequence) CharBuffer.wrap("0123456789".toCharArray()), 3, 5);
170
 
    assertEquals("12345678901234", t.toString());
171
 
    t.append((CharSequence) t);
172
 
    assertEquals("1234567890123412345678901234", t.toString());
173
 
    t.append((CharSequence) new StringBuilder("0123456789"), 5, 7);
174
 
    assertEquals("123456789012341234567890123456", t.toString());
175
 
    t.append((CharSequence) new StringBuffer(t));
176
 
    assertEquals("123456789012341234567890123456123456789012341234567890123456", t.toString());
177
 
    // very wierd, to test if a subSlice is wrapped correct :)
178
 
    CharBuffer buf = CharBuffer.wrap("0123456789".toCharArray(), 3, 5);
179
 
    assertEquals("34567", buf.toString());
180
 
    t.setEmpty().append((CharSequence) buf, 1, 2);
181
 
    assertEquals("4", t.toString());
182
 
    CharTermAttribute t2 = new CharTermAttributeImpl();
183
 
    t2.append("test");
184
 
    t.append((CharSequence) t2);
185
 
    assertEquals("4test", t.toString());
186
 
    t.append((CharSequence) t2, 1, 2);
187
 
    assertEquals("4teste", t.toString());
188
 
    
189
 
    try {
190
 
      t.append((CharSequence) t2, 1, 5);
191
 
      fail("Should throw IndexOutOfBoundsException");
192
 
    } catch(IndexOutOfBoundsException iobe) {
193
 
    }
194
 
    
195
 
    try {
196
 
      t.append((CharSequence) t2, 1, 0);
197
 
      fail("Should throw IndexOutOfBoundsException");
198
 
    } catch(IndexOutOfBoundsException iobe) {
199
 
    }
200
 
    
201
 
    t.append((CharSequence) null);
202
 
    assertEquals("4testenull", t.toString());
203
 
  }
204
 
  
205
 
  public void testAppendableInterfaceWithLongSequences() {
206
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
207
 
    t.append((CharSequence) "01234567890123456789012345678901234567890123456789");
208
 
    t.append((CharSequence) CharBuffer.wrap("01234567890123456789012345678901234567890123456789".toCharArray()), 3, 50);
209
 
    assertEquals("0123456789012345678901234567890123456789012345678934567890123456789012345678901234567890123456789", t.toString());
210
 
    t.setEmpty().append((CharSequence) new StringBuilder("01234567890123456789"), 5, 17);
211
 
    assertEquals((CharSequence) "567890123456", t.toString());
212
 
    t.append(new StringBuffer(t));
213
 
    assertEquals((CharSequence) "567890123456567890123456", t.toString());
214
 
    // very wierd, to test if a subSlice is wrapped correct :)
215
 
    CharBuffer buf = CharBuffer.wrap("012345678901234567890123456789".toCharArray(), 3, 15);
216
 
    assertEquals("345678901234567", buf.toString());
217
 
    t.setEmpty().append(buf, 1, 14);
218
 
    assertEquals("4567890123456", t.toString());
219
 
    
220
 
    // finally use a completely custom CharSequence that is not catched by instanceof checks
221
 
    final String longTestString = "012345678901234567890123456789";
222
 
    t.append(new CharSequence() {
223
 
      public char charAt(int i) { return longTestString.charAt(i); }
224
 
      public int length() { return longTestString.length(); }
225
 
      public CharSequence subSequence(int start, int end) { return longTestString.subSequence(start, end); }
226
 
      @Override
227
 
      public String toString() { return longTestString; }
228
 
    });
229
 
    assertEquals("4567890123456"+longTestString, t.toString());
230
 
  }
231
 
  
232
 
  public void testNonCharSequenceAppend() {
233
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
234
 
    t.append("0123456789");
235
 
    t.append("0123456789");
236
 
    assertEquals("01234567890123456789", t.toString());
237
 
    t.append(new StringBuilder("0123456789"));
238
 
    assertEquals("012345678901234567890123456789", t.toString());
239
 
    CharTermAttribute t2 = new CharTermAttributeImpl();
240
 
    t2.append("test");
241
 
    t.append(t2);
242
 
    assertEquals("012345678901234567890123456789test", t.toString());
243
 
    t.append((String) null);
244
 
    t.append((StringBuilder) null);
245
 
    t.append((CharTermAttribute) null);
246
 
    assertEquals("012345678901234567890123456789testnullnullnull", t.toString());
247
 
  }
248
 
  
249
 
  public void testExceptions() {
250
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
251
 
    t.append("test");
252
 
    assertEquals("test", t.toString());
253
 
 
254
 
    try {
255
 
      t.charAt(-1);
256
 
      fail("Should throw IndexOutOfBoundsException");
257
 
    } catch(IndexOutOfBoundsException iobe) {
258
 
    }
259
 
 
260
 
    try {
261
 
      t.charAt(4);
262
 
      fail("Should throw IndexOutOfBoundsException");
263
 
    } catch(IndexOutOfBoundsException iobe) {
264
 
    }
265
 
 
266
 
    try {
267
 
      t.subSequence(0, 5);
268
 
      fail("Should throw IndexOutOfBoundsException");
269
 
    } catch(IndexOutOfBoundsException iobe) {
270
 
    }
271
 
 
272
 
    try {
273
 
      t.subSequence(5, 0);
274
 
      fail("Should throw IndexOutOfBoundsException");
275
 
    } catch(IndexOutOfBoundsException iobe) {
276
 
    }
277
 
  }
278
 
 
279
 
  /*
280
 
  
281
 
  // test speed of the dynamic instanceof checks in append(CharSequence),
282
 
  // to find the best max length for the generic while (start<end) loop:
283
 
  public void testAppendPerf() {
284
 
    CharTermAttributeImpl t = new CharTermAttributeImpl();
285
 
    final int count = 32;
286
 
    CharSequence[] csq = new CharSequence[count * 6];
287
 
    final StringBuilder sb = new StringBuilder();
288
 
    for (int i=0,j=0; i<count; i++) {
289
 
      sb.append(i%10);
290
 
      final String testString = sb.toString();
291
 
      CharTermAttribute cta = new CharTermAttributeImpl();
292
 
      cta.append(testString);
293
 
      csq[j++] = cta;
294
 
      csq[j++] = testString;
295
 
      csq[j++] = new StringBuilder(sb);
296
 
      csq[j++] = new StringBuffer(sb);
297
 
      csq[j++] = CharBuffer.wrap(testString.toCharArray());
298
 
      csq[j++] = new CharSequence() {
299
 
        public char charAt(int i) { return testString.charAt(i); }
300
 
        public int length() { return testString.length(); }
301
 
        public CharSequence subSequence(int start, int end) { return testString.subSequence(start, end); }
302
 
        public String toString() { return testString; }
303
 
      };
304
 
    }
305
 
 
306
 
    Random rnd = newRandom();
307
 
    long startTime = System.currentTimeMillis();
308
 
    for (int i=0; i<100000000; i++) {
309
 
      t.setEmpty().append(csq[rnd.nextInt(csq.length)]);
310
 
    }
311
 
    long endTime = System.currentTimeMillis();
312
 
    System.out.println("Time: " + (endTime-startTime)/1000.0 + " s");
313
 
  }
314
 
  
315
 
  */
316
 
 
317
 
}