← Back to branch summary

~ubuntu-branches/debian/sid/golang-github-blevesearch-bleve/sid

« back to all changes in this revision

Viewing changes to search/searcher/search_boolean_test.go

  • Committer: Package Import Robot
  • Author(s): Michael Lustfield
  • Date: 2017-03-30 16:06:03 UTC
  • Revision ID: package-import@ubuntu.com-20170330160603-0oogmb960l7918jx
Tags: upstream-0.5.0+git20170324.202.4702785f
Import upstream version 0.5.0+git20170324.202.4702785f

Show diffs side-by-side

added added

removed removed

Lines of Context:
search/searcher/search_boolean_test.go
 
1
//  Copyright (c) 2014 Couchbase, Inc.
 
2
//
 
3
// Licensed under the Apache License, Version 2.0 (the "License");
 
4
// you may not use this file except in compliance with the License.
 
5
// You may obtain a copy of the License at
 
6
//
 
7
//              http://www.apache.org/licenses/LICENSE-2.0
 
8
//
 
9
// Unless required by applicable law or agreed to in writing, software
 
10
// distributed under the License is distributed on an "AS IS" BASIS,
 
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
12
// See the License for the specific language governing permissions and
 
13
// limitations under the License.
 
14
 
 
15
package searcher
 
16
 
 
17
import (
 
18
        "testing"
 
19
 
 
20
        "github.com/blevesearch/bleve/index"
 
21
        "github.com/blevesearch/bleve/search"
 
22
)
 
23
 
 
24
func TestBooleanSearch(t *testing.T) {
 
25
 
 
26
        if twoDocIndex == nil {
 
27
                t.Fatal("its null")
 
28
        }
 
29
        twoDocIndexReader, err := twoDocIndex.Reader()
 
30
        if err != nil {
 
31
                t.Error(err)
 
32
        }
 
33
        defer func() {
 
34
                err := twoDocIndexReader.Close()
 
35
                if err != nil {
 
36
                        t.Fatal(err)
 
37
                }
 
38
        }()
 
39
 
 
40
        explainTrue := search.SearcherOptions{Explain: true}
 
41
 
 
42
        // test 0
 
43
        beerTermSearcher, err := NewTermSearcher(twoDocIndexReader, "beer", "desc", 1.0, explainTrue)
 
44
        if err != nil {
 
45
                t.Fatal(err)
 
46
        }
 
47
        mustSearcher, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{beerTermSearcher}, explainTrue)
 
48
        if err != nil {
 
49
                t.Fatal(err)
 
50
        }
 
51
        martyTermSearcher, err := NewTermSearcher(twoDocIndexReader, "marty", "name", 1.0, explainTrue)
 
52
        if err != nil {
 
53
                t.Fatal(err)
 
54
        }
 
55
        dustinTermSearcher, err := NewTermSearcher(twoDocIndexReader, "dustin", "name", 1.0, explainTrue)
 
56
        if err != nil {
 
57
                t.Fatal(err)
 
58
        }
 
59
        shouldSearcher, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{martyTermSearcher, dustinTermSearcher}, 0, explainTrue)
 
60
        if err != nil {
 
61
                t.Fatal(err)
 
62
        }
 
63
        steveTermSearcher, err := NewTermSearcher(twoDocIndexReader, "steve", "name", 1.0, explainTrue)
 
64
        if err != nil {
 
65
                t.Fatal(err)
 
66
        }
 
67
        mustNotSearcher, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{steveTermSearcher}, 0, explainTrue)
 
68
        if err != nil {
 
69
                t.Fatal(err)
 
70
        }
 
71
        booleanSearcher, err := NewBooleanSearcher(twoDocIndexReader, mustSearcher, shouldSearcher, mustNotSearcher, explainTrue)
 
72
        if err != nil {
 
73
                t.Fatal(err)
 
74
        }
 
75
 
 
76
        // test 1
 
77
        martyTermSearcher2, err := NewTermSearcher(twoDocIndexReader, "marty", "name", 1.0, explainTrue)
 
78
        if err != nil {
 
79
                t.Fatal(err)
 
80
        }
 
81
        dustinTermSearcher2, err := NewTermSearcher(twoDocIndexReader, "dustin", "name", 1.0, explainTrue)
 
82
        if err != nil {
 
83
                t.Fatal(err)
 
84
        }
 
85
        shouldSearcher2, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{martyTermSearcher2, dustinTermSearcher2}, 0, explainTrue)
 
86
        if err != nil {
 
87
                t.Fatal(err)
 
88
        }
 
89
        steveTermSearcher2, err := NewTermSearcher(twoDocIndexReader, "steve", "name", 1.0, explainTrue)
 
90
        if err != nil {
 
91
                t.Fatal(err)
 
92
        }
 
93
        mustNotSearcher2, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{steveTermSearcher2}, 0, explainTrue)
 
94
        if err != nil {
 
95
                t.Fatal(err)
 
96
        }
 
97
        booleanSearcher2, err := NewBooleanSearcher(twoDocIndexReader, nil, shouldSearcher2, mustNotSearcher2, explainTrue)
 
98
        if err != nil {
 
99
                t.Fatal(err)
 
100
        }
 
101
 
 
102
        // test 2
 
103
        steveTermSearcher3, err := NewTermSearcher(twoDocIndexReader, "steve", "name", 1.0, explainTrue)
 
104
        if err != nil {
 
105
                t.Fatal(err)
 
106
        }
 
107
        mustNotSearcher3, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{steveTermSearcher3}, 0, explainTrue)
 
108
        if err != nil {
 
109
                t.Fatal(err)
 
110
        }
 
111
        booleanSearcher3, err := NewBooleanSearcher(twoDocIndexReader, nil, nil, mustNotSearcher3, explainTrue)
 
112
        if err != nil {
 
113
                t.Fatal(err)
 
114
        }
 
115
 
 
116
        // test 3
 
117
        beerTermSearcher4, err := NewTermSearcher(twoDocIndexReader, "beer", "desc", 1.0, explainTrue)
 
118
        if err != nil {
 
119
                t.Fatal(err)
 
120
        }
 
121
        mustSearcher4, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{beerTermSearcher4}, explainTrue)
 
122
        if err != nil {
 
123
                t.Fatal(err)
 
124
        }
 
125
        steveTermSearcher4, err := NewTermSearcher(twoDocIndexReader, "steve", "name", 1.0, explainTrue)
 
126
        if err != nil {
 
127
                t.Fatal(err)
 
128
        }
 
129
        mustNotSearcher4, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{steveTermSearcher4}, 0, explainTrue)
 
130
        if err != nil {
 
131
                t.Fatal(err)
 
132
        }
 
133
        booleanSearcher4, err := NewBooleanSearcher(twoDocIndexReader, mustSearcher4, nil, mustNotSearcher4, explainTrue)
 
134
        if err != nil {
 
135
                t.Fatal(err)
 
136
        }
 
137
 
 
138
        // test 4
 
139
        beerTermSearcher5, err := NewTermSearcher(twoDocIndexReader, "beer", "desc", 1.0, explainTrue)
 
140
        if err != nil {
 
141
                t.Fatal(err)
 
142
        }
 
143
        mustSearcher5, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{beerTermSearcher5}, explainTrue)
 
144
        if err != nil {
 
145
                t.Fatal(err)
 
146
        }
 
147
        steveTermSearcher5, err := NewTermSearcher(twoDocIndexReader, "steve", "name", 1.0, explainTrue)
 
148
        if err != nil {
 
149
                t.Fatal(err)
 
150
        }
 
151
        martyTermSearcher5, err := NewTermSearcher(twoDocIndexReader, "marty", "name", 1.0, explainTrue)
 
152
        if err != nil {
 
153
                t.Fatal(err)
 
154
        }
 
155
        mustNotSearcher5, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{steveTermSearcher5, martyTermSearcher5}, 0, explainTrue)
 
156
        if err != nil {
 
157
                t.Fatal(err)
 
158
        }
 
159
        booleanSearcher5, err := NewBooleanSearcher(twoDocIndexReader, mustSearcher5, nil, mustNotSearcher5, explainTrue)
 
160
        if err != nil {
 
161
                t.Fatal(err)
 
162
        }
 
163
 
 
164
        // test 5
 
165
        beerTermSearcher6, err := NewTermSearcher(twoDocIndexReader, "beer", "desc", 1.0, explainTrue)
 
166
        if err != nil {
 
167
                t.Fatal(err)
 
168
        }
 
169
        mustSearcher6, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{beerTermSearcher6}, explainTrue)
 
170
        if err != nil {
 
171
                t.Fatal(err)
 
172
        }
 
173
        martyTermSearcher6, err := NewTermSearcher(twoDocIndexReader, "marty", "name", 1.0, explainTrue)
 
174
        if err != nil {
 
175
                t.Fatal(err)
 
176
        }
 
177
        dustinTermSearcher6, err := NewTermSearcher(twoDocIndexReader, "dustin", "name", 1.0, explainTrue)
 
178
        if err != nil {
 
179
                t.Fatal(err)
 
180
        }
 
181
        shouldSearcher6, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{martyTermSearcher6, dustinTermSearcher6}, 2, explainTrue)
 
182
        if err != nil {
 
183
                t.Fatal(err)
 
184
        }
 
185
        booleanSearcher6, err := NewBooleanSearcher(twoDocIndexReader, mustSearcher6, shouldSearcher6, nil, explainTrue)
 
186
        if err != nil {
 
187
                t.Fatal(err)
 
188
        }
 
189
 
 
190
        // test 6
 
191
        beerTermSearcher7, err := NewTermSearcher(twoDocIndexReader, "beer", "desc", 1.0, explainTrue)
 
192
        if err != nil {
 
193
                t.Fatal(err)
 
194
        }
 
195
        mustSearcher7, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{beerTermSearcher7}, explainTrue)
 
196
        if err != nil {
 
197
                t.Fatal(err)
 
198
        }
 
199
        booleanSearcher7, err := NewBooleanSearcher(twoDocIndexReader, mustSearcher7, nil, nil, explainTrue)
 
200
        if err != nil {
 
201
                t.Fatal(err)
 
202
        }
 
203
        martyTermSearcher7, err := NewTermSearcher(twoDocIndexReader, "marty", "name", 5.0, explainTrue)
 
204
        if err != nil {
 
205
                t.Fatal(err)
 
206
        }
 
207
        conjunctionSearcher7, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{martyTermSearcher7, booleanSearcher7}, explainTrue)
 
208
 
 
209
        // test 7
 
210
        beerTermSearcher8, err := NewTermSearcher(twoDocIndexReader, "beer", "desc", 1.0, explainTrue)
 
211
        if err != nil {
 
212
                t.Fatal(err)
 
213
        }
 
214
        mustSearcher8, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{beerTermSearcher8}, explainTrue)
 
215
        if err != nil {
 
216
                t.Fatal(err)
 
217
        }
 
218
        martyTermSearcher8, err := NewTermSearcher(twoDocIndexReader, "marty", "name", 1.0, explainTrue)
 
219
        if err != nil {
 
220
                t.Fatal(err)
 
221
        }
 
222
        dustinTermSearcher8, err := NewTermSearcher(twoDocIndexReader, "dustin", "name", 1.0, explainTrue)
 
223
        if err != nil {
 
224
                t.Fatal(err)
 
225
        }
 
226
        shouldSearcher8, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{martyTermSearcher8, dustinTermSearcher8}, 0, explainTrue)
 
227
        if err != nil {
 
228
                t.Fatal(err)
 
229
        }
 
230
        steveTermSearcher8, err := NewTermSearcher(twoDocIndexReader, "steve", "name", 1.0, explainTrue)
 
231
        if err != nil {
 
232
                t.Fatal(err)
 
233
        }
 
234
        mustNotSearcher8, err := NewDisjunctionSearcher(twoDocIndexReader, []search.Searcher{steveTermSearcher8}, 0, explainTrue)
 
235
        if err != nil {
 
236
                t.Fatal(err)
 
237
        }
 
238
        booleanSearcher8, err := NewBooleanSearcher(twoDocIndexReader, mustSearcher8, shouldSearcher8, mustNotSearcher8, explainTrue)
 
239
        if err != nil {
 
240
                t.Fatal(err)
 
241
        }
 
242
        dustinTermSearcher8a, err := NewTermSearcher(twoDocIndexReader, "dustin", "name", 5.0, explainTrue)
 
243
        if err != nil {
 
244
                t.Fatal(err)
 
245
        }
 
246
        conjunctionSearcher8, err := NewConjunctionSearcher(twoDocIndexReader, []search.Searcher{booleanSearcher8, dustinTermSearcher8a}, explainTrue)
 
247
        if err != nil {
 
248
                t.Fatal(err)
 
249
        }
 
250
 
 
251
        tests := []struct {
 
252
                searcher search.Searcher
 
253
                results  []*search.DocumentMatch
 
254
        }{
 
255
                {
 
256
                        searcher: booleanSearcher,
 
257
                        results: []*search.DocumentMatch{
 
258
                                {
 
259
                                        IndexInternalID: index.IndexInternalID("1"),
 
260
                                        Score:           0.9818005051949021,
 
261
                                },
 
262
                                {
 
263
                                        IndexInternalID: index.IndexInternalID("3"),
 
264
                                        Score:           0.808709699395535,
 
265
                                },
 
266
                                {
 
267
                                        IndexInternalID: index.IndexInternalID("4"),
 
268
                                        Score:           0.34618161159873423,
 
269
                                },
 
270
                        },
 
271
                },
 
272
                {
 
273
                        searcher: booleanSearcher2,
 
274
                        results: []*search.DocumentMatch{
 
275
                                {
 
276
                                        IndexInternalID: index.IndexInternalID("1"),
 
277
                                        Score:           0.6775110856165737,
 
278
                                },
 
279
                                {
 
280
                                        IndexInternalID: index.IndexInternalID("3"),
 
281
                                        Score:           0.6775110856165737,
 
282
                                },
 
283
                        },
 
284
                },
 
285
                // no MUST or SHOULD clauses yields no results
 
286
                {
 
287
                        searcher: booleanSearcher3,
 
288
                        results:  []*search.DocumentMatch{},
 
289
                },
 
290
                {
 
291
                        searcher: booleanSearcher4,
 
292
                        results: []*search.DocumentMatch{
 
293
                                {
 
294
                                        IndexInternalID: index.IndexInternalID("1"),
 
295
                                        Score:           1.0,
 
296
                                },
 
297
                                {
 
298
                                        IndexInternalID: index.IndexInternalID("3"),
 
299
                                        Score:           0.5,
 
300
                                },
 
301
                                {
 
302
                                        IndexInternalID: index.IndexInternalID("4"),
 
303
                                        Score:           1.0,
 
304
                                },
 
305
                        },
 
306
                },
 
307
                {
 
308
                        searcher: booleanSearcher5,
 
309
                        results: []*search.DocumentMatch{
 
310
                                {
 
311
                                        IndexInternalID: index.IndexInternalID("3"),
 
312
                                        Score:           0.5,
 
313
                                },
 
314
                                {
 
315
                                        IndexInternalID: index.IndexInternalID("4"),
 
316
                                        Score:           1.0,
 
317
                                },
 
318
                        },
 
319
                },
 
320
                {
 
321
                        searcher: booleanSearcher6,
 
322
                        results:  []*search.DocumentMatch{},
 
323
                },
 
324
                // test a conjunction query with a nested boolean
 
325
                {
 
326
                        searcher: conjunctionSearcher7,
 
327
                        results: []*search.DocumentMatch{
 
328
                                {
 
329
                                        IndexInternalID: index.IndexInternalID("1"),
 
330
                                        Score:           2.0097428702814377,
 
331
                                },
 
332
                        },
 
333
                },
 
334
                {
 
335
                        searcher: conjunctionSearcher8,
 
336
                        results: []*search.DocumentMatch{
 
337
                                {
 
338
                                        IndexInternalID: index.IndexInternalID("3"),
 
339
                                        Score:           2.0681575785068107,
 
340
                                },
 
341
                        },
 
342
                },
 
343
        }
 
344
 
 
345
        for testIndex, test := range tests {
 
346
                defer func() {
 
347
                        err := test.searcher.Close()
 
348
                        if err != nil {
 
349
                                t.Fatal(err)
 
350
                        }
 
351
                }()
 
352
 
 
353
                ctx := &search.SearchContext{
 
354
                        DocumentMatchPool: search.NewDocumentMatchPool(test.searcher.DocumentMatchPoolSize(), 0),
 
355
                }
 
356
                next, err := test.searcher.Next(ctx)
 
357
                i := 0
 
358
                for err == nil && next != nil {
 
359
                        if i < len(test.results) {
 
360
                                if !next.IndexInternalID.Equals(test.results[i].IndexInternalID) {
 
361
                                        t.Errorf("expected result %d to have id %s got %s for test %d", i, test.results[i].IndexInternalID, next.IndexInternalID, testIndex)
 
362
                                }
 
363
                                if !scoresCloseEnough(next.Score, test.results[i].Score) {
 
364
                                        t.Errorf("expected result %d to have score %v got  %v for test %d", i, test.results[i].Score, next.Score, testIndex)
 
365
                                        t.Logf("scoring explanation: %s", next.Expl)
 
366
                                }
 
367
                        }
 
368
                        ctx.DocumentMatchPool.Put(next)
 
369
                        next, err = test.searcher.Next(ctx)
 
370
                        i++
 
371
                }
 
372
                if err != nil {
 
373
                        t.Fatalf("error iterating searcher: %v for test %d", err, testIndex)
 
374
                }
 
375
                if len(test.results) != i {
 
376
                        t.Errorf("expected %d results got %d for test %d", len(test.results), i, testIndex)
 
377
                }
 
378
        }
 
379
}