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

RandomIndexWriter writer= new RandomIndexWriter(random, directory, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMergePolicy(newLogMergePolicy()));

long theLong = Long.MAX_VALUE;

double theDouble = Double.MAX_VALUE;

byte theByte = Byte.MAX_VALUE;

short theShort = Short.MAX_VALUE;

int theInt = Integer.MAX_VALUE;

float theFloat = Float.MAX_VALUE;

for (int i = 0; i < NUM_DOCS; i++){

Document doc = new Document();

doc.add(newField("theLong", String.valueOf(theLong--), Field.Store.NO, Field.Index.NOT_ANALYZED));

doc.add(newField("theDouble", String.valueOf(theDouble--), Field.Store.NO, Field.Index.NOT_ANALYZED));

doc.add(newField("theByte", String.valueOf(theByte--), Field.Store.NO, Field.Index.NOT_ANALYZED));

doc.add(newField("theShort", String.valueOf(theShort--), Field.Store.NO, Field.Index.NOT_ANALYZED));

doc.add(newField("theInt", String.valueOf(theInt--), Field.Store.NO, Field.Index.NOT_ANALYZED));

doc.add(newField("theFloat", String.valueOf(theFloat--), Field.Store.NO, Field.Index.NOT_ANALYZED));

if (i%2 == 0) {

doc.add(newField("sparse", String.valueOf(i), Field.Store.NO, Field.Index.NOT_ANALYZED));

}

if (i%2 == 0) {

doc.add(new NumericField("numInt").setIntValue(i));

}

writer.addDocument(doc);

}

writer.close();

reader = IndexReader.open(directory, true);

}

@Override

public void tearDown() throws Exception {

reader.close();

directory.close();

super.tearDown();

}

public void testInfoStream() throws Exception {

try {

FieldCache cache = FieldCache.DEFAULT;

ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);

cache.setInfoStream(new PrintStream(bos));

cache.getDoubles(reader, "theDouble");

cache.getFloats(reader, "theDouble");

assertTrue(bos.toString().indexOf("WARNING") != -1);

} finally {

FieldCache.DEFAULT.purgeAllCaches();

}

public void test() throws IOException {

FieldCache cache = FieldCache.DEFAULT;

double [] doubles = cache.getDoubles(reader, "theDouble", null, random.nextBoolean());

assertSame("Second request to cache return same array", doubles, cache.getDoubles(reader, "theDouble"));

assertSame("Second request with explicit parser return same array", doubles, cache.getDoubles(reader, "theDouble", FieldCache.DEFAULT_DOUBLE_PARSER));

assertTrue("doubles Size: " + doubles.length + " is not: " + NUM_DOCS, doubles.length == NUM_DOCS);

for (int i = 0; i < doubles.length; i++) {

100

assertTrue(doubles[i] + " does not equal: " + (Double.MAX_VALUE - i), doubles[i] == (Double.MAX_VALUE - i));

101

102

}

103

104

long [] longs = cache.getLongs(reader, "theLong", null, random.nextBoolean());

105

assertSame("Second request to cache return same array", longs, cache.getLongs(reader, "theLong"));

106

assertSame("Second request with explicit parser return same array", longs, cache.getLongs(reader, "theLong", FieldCache.DEFAULT_LONG_PARSER));

107

assertTrue("longs Size: " + longs.length + " is not: " + NUM_DOCS, longs.length == NUM_DOCS);

108

for (int i = 0; i < longs.length; i++) {

109

assertTrue(longs[i] + " does not equal: " + (Long.MAX_VALUE - i), longs[i] == (Long.MAX_VALUE - i));

110

111

}

112

113

byte [] bytes = cache.getBytes(reader, "theByte", null, random.nextBoolean());

114

assertSame("Second request to cache return same array", bytes, cache.getBytes(reader, "theByte"));

115

assertSame("Second request with explicit parser return same array", bytes, cache.getBytes(reader, "theByte", FieldCache.DEFAULT_BYTE_PARSER));

116

assertTrue("bytes Size: " + bytes.length + " is not: " + NUM_DOCS, bytes.length == NUM_DOCS);

117

for (int i = 0; i < bytes.length; i++) {

118

assertTrue(bytes[i] + " does not equal: " + (Byte.MAX_VALUE - i), bytes[i] == (byte) (Byte.MAX_VALUE - i));

119

120

}

121

122

short [] shorts = cache.getShorts(reader, "theShort", null, random.nextBoolean());

123

assertSame("Second request to cache return same array", shorts, cache.getShorts(reader, "theShort"));

124

assertSame("Second request with explicit parser return same array", shorts, cache.getShorts(reader, "theShort", FieldCache.DEFAULT_SHORT_PARSER));

125

assertTrue("shorts Size: " + shorts.length + " is not: " + NUM_DOCS, shorts.length == NUM_DOCS);

126

for (int i = 0; i < shorts.length; i++) {

127

assertTrue(shorts[i] + " does not equal: " + (Short.MAX_VALUE - i), shorts[i] == (short) (Short.MAX_VALUE - i));

128

129

}

130

131

int [] ints = cache.getInts(reader, "theInt", null, random.nextBoolean());

132

assertSame("Second request to cache return same array", ints, cache.getInts(reader, "theInt"));

133

assertSame("Second request with explicit parser return same array", ints, cache.getInts(reader, "theInt", FieldCache.DEFAULT_INT_PARSER));

134

assertTrue("ints Size: " + ints.length + " is not: " + NUM_DOCS, ints.length == NUM_DOCS);

135

for (int i = 0; i < ints.length; i++) {

136

assertTrue(ints[i] + " does not equal: " + (Integer.MAX_VALUE - i), ints[i] == (Integer.MAX_VALUE - i));

137

138

}

139

140

float [] floats = cache.getFloats(reader, "theFloat", null, random.nextBoolean());

141

assertSame("Second request to cache return same array", floats, cache.getFloats(reader, "theFloat"));

142

assertSame("Second request with explicit parser return same array", floats, cache.getFloats(reader, "theFloat", FieldCache.DEFAULT_FLOAT_PARSER));

143

assertTrue("floats Size: " + floats.length + " is not: " + NUM_DOCS, floats.length == NUM_DOCS);

144

for (int i = 0; i < floats.length; i++) {

145

assertTrue(floats[i] + " does not equal: " + (Float.MAX_VALUE - i), floats[i] == (Float.MAX_VALUE - i));

146

147

}

148

149

Bits docsWithField = cache.getDocsWithField(reader, "theLong");

150

assertSame("Second request to cache return same array", docsWithField, cache.getDocsWithField(reader, "theLong"));

151

assertTrue("docsWithField(theLong) must be class Bits.MatchAllBits", docsWithField instanceof Bits.MatchAllBits);

152

assertTrue("docsWithField(theLong) Size: " + docsWithField.length() + " is not: " + NUM_DOCS, docsWithField.length() == NUM_DOCS);

153

for (int i = 0; i < docsWithField.length(); i++) {

154

assertTrue(docsWithField.get(i));

155

}

156

157

docsWithField = cache.getDocsWithField(reader, "sparse");

158

assertSame("Second request to cache return same array", docsWithField, cache.getDocsWithField(reader, "sparse"));

159

assertFalse("docsWithField(sparse) must not be class Bits.MatchAllBits", docsWithField instanceof Bits.MatchAllBits);

160

assertTrue("docsWithField(sparse) Size: " + docsWithField.length() + " is not: " + NUM_DOCS, docsWithField.length() == NUM_DOCS);

161

for (int i = 0; i < docsWithField.length(); i++) {

162

assertEquals(i%2 == 0, docsWithField.get(i));

163

}

164

}

165

public void testDocsWithField() throws Exception {

166

FieldCache cache = FieldCache.DEFAULT;

167

cache.purgeAllCaches();

168

assertEquals(0, cache.getCacheEntries().length);

169

double[] doubles = cache.getDoubles(reader, "theDouble", null, true);

170

171

// The double[] takes two slots (one w/ null parser, one

172

// w/ real parser), and docsWithField should also

173

// have been populated:

174

assertEquals(3, cache.getCacheEntries().length);

175

Bits bits = cache.getDocsWithField(reader, "theDouble");

176

177

// No new entries should appear:

178

assertEquals(3, cache.getCacheEntries().length);

179

assertTrue(bits instanceof Bits.MatchAllBits);

180

181

int[] ints = cache.getInts(reader, "sparse", null, true);

182

assertEquals(6, cache.getCacheEntries().length);

183

Bits docsWithField = cache.getDocsWithField(reader, "sparse");

184

assertEquals(6, cache.getCacheEntries().length);

185

for (int i = 0; i < docsWithField.length(); i++) {

186

if (i%2 == 0) {

187

assertTrue(docsWithField.get(i));

188

assertEquals(i, ints[i]);

189

} else {

190

assertFalse(docsWithField.get(i));

191

}

192

}

193

194

int[] numInts = cache.getInts(reader, "numInt", null, random.nextBoolean());

195

docsWithField = cache.getDocsWithField(reader, "numInt");

196

for (int i = 0; i < docsWithField.length(); i++) {

197

if (i%2 == 0) {

198

assertTrue(docsWithField.get(i));

199

assertEquals(i, numInts[i]);

200

} else {

201

assertFalse(docsWithField.get(i));

202

}

203

}

204

}

205

206

public void testGetDocsWithFieldThreadSafety() throws Exception {

207

final FieldCache cache = FieldCache.DEFAULT;

208

cache.purgeAllCaches();

209

210

int NUM_THREADS = 3;

211

Thread[] threads = new Thread[NUM_THREADS];

212

final AtomicBoolean failed = new AtomicBoolean();

213

final AtomicInteger iters = new AtomicInteger();

214

final int NUM_ITER = 200 * RANDOM_MULTIPLIER;

215

final CyclicBarrier restart = new CyclicBarrier(NUM_THREADS,

216

new Runnable() {

217

// @Override not until java 1.6

218

public void run() {

219

cache.purgeAllCaches();

220

iters.incrementAndGet();

221

}

222

});

223

for(int threadIDX=0;threadIDX<NUM_THREADS;threadIDX++) {

224

threads[threadIDX] = new Thread() {

225

@Override

226

public void run() {

227

228

try {

229

while(!failed.get()) {

230

final int op = random.nextInt(3);

231

if (op == 0) {

232

// Purge all caches & resume, once all

233

// threads get here:

234

restart.await();

235

if (iters.get() >= NUM_ITER) {

236

break;

237

}

238

} else if (op == 1) {

239

Bits docsWithField = cache.getDocsWithField(reader, "sparse");

240

for (int i = 0; i < docsWithField.length(); i++) {

241

assertEquals(i%2 == 0, docsWithField.get(i));

242

}

243

} else {

244

int[] ints = cache.getInts(reader, "sparse", null, true);

245

Bits docsWithField = cache.getDocsWithField(reader, "sparse");

246

for (int i = 0; i < docsWithField.length(); i++) {

247

if (i%2 == 0) {

248

assertTrue(docsWithField.get(i));

249

assertEquals(i, ints[i]);

250

} else {

251

assertFalse(docsWithField.get(i));

252

}

253

}

254

}

255

}

256

} catch (Throwable t) {

257

failed.set(true);

258

restart.reset();

259

throw new RuntimeException(t);

260

}

261

}

262

};

263

threads[threadIDX].start();

264

}

265

266

for(int threadIDX=0;threadIDX<NUM_THREADS;threadIDX++) {

267

threads[threadIDX].join();

268

}

269

assertFalse(failed.get());

270

}

271

}

Older »