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

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

Document doc = new Document();

doc.add (newField("field", "one two three four five", Field.Store.YES, Field.Index.ANALYZED));

doc.add (newField("sorter", "b", Field.Store.YES, Field.Index.ANALYZED));

writer.addDocument (doc);

doc = new Document();

doc.add (newField("field", "one two three four", Field.Store.YES, Field.Index.ANALYZED));

doc.add (newField("sorter", "d", Field.Store.YES, Field.Index.ANALYZED));

writer.addDocument (doc);

doc = new Document();

doc.add (newField("field", "one two three y", Field.Store.YES, Field.Index.ANALYZED));

doc.add (newField("sorter", "a", Field.Store.YES, Field.Index.ANALYZED));

writer.addDocument (doc);

doc = new Document();

doc.add (newField("field", "one two x", Field.Store.YES, Field.Index.ANALYZED));

doc.add (newField("sorter", "c", Field.Store.YES, Field.Index.ANALYZED));

writer.addDocument (doc);

// tests here require single segment (eg try seed

// 8239472272678419952L), because SingleDocTestFilter(x)

// blindly accepts that docID in any sub-segment

writer.optimize();

reader = writer.getReader();

writer.close ();

searcher = newSearcher(reader);

query = new TermQuery (new Term ("field", "three"));

filter = newStaticFilterB();

}

// must be static for serialization tests

private static Filter newStaticFilterB() {

return new Filter() {

@Override

public DocIdSet getDocIdSet (IndexReader reader) {

BitSet bitset = new BitSet(5);

bitset.set (1);

bitset.set (3);

return new DocIdBitSet(bitset);

}

};

}

100

101

@Override

102

public void tearDown() throws Exception {

103

searcher.close();

104

reader.close();

105

directory.close();

106

super.tearDown();

107

}

108

109

public void testFilteredQuery()

110

throws Exception {

111

Query filteredquery = new FilteredQuery (query, filter);

112

ScoreDoc[] hits = searcher.search (filteredquery, null, 1000).scoreDocs;

113

assertEquals (1, hits.length);

114

assertEquals (1, hits[0].doc);

115

QueryUtils.check(random, filteredquery,searcher);

116

117

hits = searcher.search (filteredquery, null, 1000, new Sort(new SortField("sorter", SortField.STRING))).scoreDocs;

118

assertEquals (1, hits.length);

119

assertEquals (1, hits[0].doc);

120

121

filteredquery = new FilteredQuery (new TermQuery (new Term ("field", "one")), filter);

122

hits = searcher.search (filteredquery, null, 1000).scoreDocs;

123

assertEquals (2, hits.length);

124

QueryUtils.check(random, filteredquery,searcher);

125

126

filteredquery = new FilteredQuery (new TermQuery (new Term ("field", "x")), filter);

127

hits = searcher.search (filteredquery, null, 1000).scoreDocs;

128

assertEquals (1, hits.length);

129

assertEquals (3, hits[0].doc);

130

QueryUtils.check(random, filteredquery,searcher);

131

132

filteredquery = new FilteredQuery (new TermQuery (new Term ("field", "y")), filter);

133

hits = searcher.search (filteredquery, null, 1000).scoreDocs;

134

assertEquals (0, hits.length);

135

QueryUtils.check(random, filteredquery,searcher);

136

137

// test boost

138

Filter f = newStaticFilterA();

139

140

float boost = 2.5f;

141

BooleanQuery bq1 = new BooleanQuery();

142

TermQuery tq = new TermQuery (new Term ("field", "one"));

143

tq.setBoost(boost);

144

bq1.add(tq, Occur.MUST);

145

bq1.add(new TermQuery (new Term ("field", "five")), Occur.MUST);

146

147

BooleanQuery bq2 = new BooleanQuery();

148

tq = new TermQuery (new Term ("field", "one"));

149

filteredquery = new FilteredQuery(tq, f);

150

filteredquery.setBoost(boost);

151

bq2.add(filteredquery, Occur.MUST);

152

bq2.add(new TermQuery (new Term ("field", "five")), Occur.MUST);

153

assertScoreEquals(bq1, bq2);

154

155

assertEquals(boost, filteredquery.getBoost(), 0);

156

assertEquals(1.0f, tq.getBoost(), 0); // the boost value of the underlying query shouldn't have changed

157

}

158

159

// must be static for serialization tests

160

private static Filter newStaticFilterA() {

161

return new Filter() {

162

@Override

163

public DocIdSet getDocIdSet (IndexReader reader) {

164

BitSet bitset = new BitSet(5);

165

bitset.set(0, 5);

166

return new DocIdBitSet(bitset);

167

}

168

};

169

}

170

171

/**

172

* Tests whether the scores of the two queries are the same.

173

174

public void assertScoreEquals(Query q1, Query q2) throws Exception {

175

ScoreDoc[] hits1 = searcher.search (q1, null, 1000).scoreDocs;

176

ScoreDoc[] hits2 = searcher.search (q2, null, 1000).scoreDocs;

177

178

assertEquals(hits1.length, hits2.length);

179

180

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

181

assertEquals(hits1[i].score, hits2[i].score, 0.0000001f);

182

}

183

}

184

185

/**

186

* This tests FilteredQuery's rewrite correctness

187

188

public void testRangeQuery() throws Exception {

189

TermRangeQuery rq = new TermRangeQuery(

190

"sorter", "b", "d", true, true);

191

192

Query filteredquery = new FilteredQuery(rq, filter);

193

ScoreDoc[] hits = searcher.search(filteredquery, null, 1000).scoreDocs;

194

assertEquals(2, hits.length);

195

QueryUtils.check(random, filteredquery,searcher);

196

}

197

198

public void testBoolean() throws Exception {

199

BooleanQuery bq = new BooleanQuery();

200

Query query = new FilteredQuery(new MatchAllDocsQuery(),

201

new SingleDocTestFilter(0));

202

bq.add(query, BooleanClause.Occur.MUST);

203

query = new FilteredQuery(new MatchAllDocsQuery(),

204

new SingleDocTestFilter(1));

205

bq.add(query, BooleanClause.Occur.MUST);

206

ScoreDoc[] hits = searcher.search(bq, null, 1000).scoreDocs;

207

assertEquals(0, hits.length);

208

QueryUtils.check(random, query,searcher);

209

}

210

211

// Make sure BooleanQuery, which does out-of-order

212

// scoring, inside FilteredQuery, works

213

public void testBoolean2() throws Exception {

214

BooleanQuery bq = new BooleanQuery();

215

Query query = new FilteredQuery(bq,

216

new SingleDocTestFilter(0));

217

bq.add(new TermQuery(new Term("field", "one")), BooleanClause.Occur.SHOULD);

218

bq.add(new TermQuery(new Term("field", "two")), BooleanClause.Occur.SHOULD);

219

ScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;

220

assertEquals(1, hits.length);

221

QueryUtils.check(random, query,searcher);

222

}

223

}

224

225

226

227

Older »