← Back to branch summary

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

« back to all changes in this revision

Viewing changes to search/highlight/term_locations_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/highlight/term_locations_test.go
 
1
//  Copyright (c) 2015 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 highlight
 
16
 
 
17
import (
 
18
        "reflect"
 
19
        "testing"
 
20
 
 
21
        "github.com/blevesearch/bleve/search"
 
22
)
 
23
 
 
24
func TestTermLocationOverlaps(t *testing.T) {
 
25
 
 
26
        tests := []struct {
 
27
                left     *TermLocation
 
28
                right    *TermLocation
 
29
                expected bool
 
30
        }{
 
31
                {
 
32
                        left: &TermLocation{
 
33
                                Start: 0,
 
34
                                End:   5,
 
35
                        },
 
36
                        right: &TermLocation{
 
37
                                Start: 3,
 
38
                                End:   7,
 
39
                        },
 
40
                        expected: true,
 
41
                },
 
42
                {
 
43
                        left: &TermLocation{
 
44
                                Start: 0,
 
45
                                End:   5,
 
46
                        },
 
47
                        right: &TermLocation{
 
48
                                Start: 5,
 
49
                                End:   7,
 
50
                        },
 
51
                        expected: false,
 
52
                },
 
53
                {
 
54
                        left: &TermLocation{
 
55
                                Start: 0,
 
56
                                End:   5,
 
57
                        },
 
58
                        right: &TermLocation{
 
59
                                Start: 7,
 
60
                                End:   11,
 
61
                        },
 
62
                        expected: false,
 
63
                },
 
64
                // with array positions
 
65
                {
 
66
                        left: &TermLocation{
 
67
                                ArrayPositions: search.ArrayPositions{0},
 
68
                                Start:          0,
 
69
                                End:            5,
 
70
                        },
 
71
                        right: &TermLocation{
 
72
                                ArrayPositions: search.ArrayPositions{1},
 
73
                                Start:          7,
 
74
                                End:            11,
 
75
                        },
 
76
                        expected: false,
 
77
                },
 
78
                {
 
79
                        left: &TermLocation{
 
80
                                ArrayPositions: search.ArrayPositions{0},
 
81
                                Start:          0,
 
82
                                End:            5,
 
83
                        },
 
84
                        right: &TermLocation{
 
85
                                ArrayPositions: search.ArrayPositions{1},
 
86
                                Start:          3,
 
87
                                End:            11,
 
88
                        },
 
89
                        expected: false,
 
90
                },
 
91
                {
 
92
                        left: &TermLocation{
 
93
                                ArrayPositions: search.ArrayPositions{0},
 
94
                                Start:          0,
 
95
                                End:            5,
 
96
                        },
 
97
                        right: &TermLocation{
 
98
                                ArrayPositions: search.ArrayPositions{0},
 
99
                                Start:          3,
 
100
                                End:            11,
 
101
                        },
 
102
                        expected: true,
 
103
                },
 
104
                {
 
105
                        left: &TermLocation{
 
106
                                ArrayPositions: search.ArrayPositions{0},
 
107
                                Start:          0,
 
108
                                End:            5,
 
109
                        },
 
110
                        right: &TermLocation{
 
111
                                ArrayPositions: search.ArrayPositions{0},
 
112
                                Start:          7,
 
113
                                End:            11,
 
114
                        },
 
115
                        expected: false,
 
116
                },
 
117
        }
 
118
 
 
119
        for _, test := range tests {
 
120
                actual := test.left.Overlaps(test.right)
 
121
                if actual != test.expected {
 
122
                        t.Errorf("expected %t got %t for %#v", test.expected, actual, test)
 
123
                }
 
124
        }
 
125
}
 
126
 
 
127
func TestTermLocationsMergeOverlapping(t *testing.T) {
 
128
 
 
129
        tests := []struct {
 
130
                input  TermLocations
 
131
                output TermLocations
 
132
        }{
 
133
                {
 
134
                        input:  TermLocations{},
 
135
                        output: TermLocations{},
 
136
                },
 
137
                {
 
138
                        input: TermLocations{
 
139
                                &TermLocation{
 
140
                                        Start: 0,
 
141
                                        End:   5,
 
142
                                },
 
143
                                &TermLocation{
 
144
                                        Start: 7,
 
145
                                        End:   11,
 
146
                                },
 
147
                        },
 
148
                        output: TermLocations{
 
149
                                &TermLocation{
 
150
                                        Start: 0,
 
151
                                        End:   5,
 
152
                                },
 
153
                                &TermLocation{
 
154
                                        Start: 7,
 
155
                                        End:   11,
 
156
                                },
 
157
                        },
 
158
                },
 
159
                {
 
160
                        input: TermLocations{
 
161
                                &TermLocation{
 
162
                                        Start: 0,
 
163
                                        End:   5,
 
164
                                },
 
165
                                &TermLocation{
 
166
                                        Start: 4,
 
167
                                        End:   11,
 
168
                                },
 
169
                        },
 
170
                        output: TermLocations{
 
171
                                &TermLocation{
 
172
                                        Start: 0,
 
173
                                        End:   11,
 
174
                                },
 
175
                                nil,
 
176
                        },
 
177
                },
 
178
                {
 
179
                        input: TermLocations{
 
180
                                &TermLocation{
 
181
                                        Start: 0,
 
182
                                        End:   5,
 
183
                                },
 
184
                                &TermLocation{
 
185
                                        Start: 4,
 
186
                                        End:   11,
 
187
                                },
 
188
                                &TermLocation{
 
189
                                        Start: 9,
 
190
                                        End:   13,
 
191
                                },
 
192
                        },
 
193
                        output: TermLocations{
 
194
                                &TermLocation{
 
195
                                        Start: 0,
 
196
                                        End:   13,
 
197
                                },
 
198
                                nil,
 
199
                                nil,
 
200
                        },
 
201
                },
 
202
                {
 
203
                        input: TermLocations{
 
204
                                &TermLocation{
 
205
                                        Start: 0,
 
206
                                        End:   5,
 
207
                                },
 
208
                                &TermLocation{
 
209
                                        Start: 4,
 
210
                                        End:   11,
 
211
                                },
 
212
                                &TermLocation{
 
213
                                        Start: 9,
 
214
                                        End:   13,
 
215
                                },
 
216
                                &TermLocation{
 
217
                                        Start: 15,
 
218
                                        End:   21,
 
219
                                },
 
220
                        },
 
221
                        output: TermLocations{
 
222
                                &TermLocation{
 
223
                                        Start: 0,
 
224
                                        End:   13,
 
225
                                },
 
226
                                nil,
 
227
                                nil,
 
228
                                &TermLocation{
 
229
                                        Start: 15,
 
230
                                        End:   21,
 
231
                                },
 
232
                        },
 
233
                },
 
234
                // with array positions
 
235
                {
 
236
                        input: TermLocations{
 
237
                                &TermLocation{
 
238
                                        ArrayPositions: search.ArrayPositions{0},
 
239
                                        Start:          0,
 
240
                                        End:            5,
 
241
                                },
 
242
                                &TermLocation{
 
243
                                        ArrayPositions: search.ArrayPositions{1},
 
244
                                        Start:          7,
 
245
                                        End:            11,
 
246
                                },
 
247
                        },
 
248
                        output: TermLocations{
 
249
                                &TermLocation{
 
250
                                        ArrayPositions: search.ArrayPositions{0},
 
251
                                        Start:          0,
 
252
                                        End:            5,
 
253
                                },
 
254
                                &TermLocation{
 
255
                                        ArrayPositions: search.ArrayPositions{1},
 
256
                                        Start:          7,
 
257
                                        End:            11,
 
258
                                },
 
259
                        },
 
260
                },
 
261
                {
 
262
                        input: TermLocations{
 
263
                                &TermLocation{
 
264
                                        ArrayPositions: search.ArrayPositions{0},
 
265
                                        Start:          0,
 
266
                                        End:            5,
 
267
                                },
 
268
                                &TermLocation{
 
269
                                        ArrayPositions: search.ArrayPositions{0},
 
270
                                        Start:          7,
 
271
                                        End:            11,
 
272
                                },
 
273
                        },
 
274
                        output: TermLocations{
 
275
                                &TermLocation{
 
276
                                        ArrayPositions: search.ArrayPositions{0},
 
277
                                        Start:          0,
 
278
                                        End:            5,
 
279
                                },
 
280
                                &TermLocation{
 
281
                                        ArrayPositions: search.ArrayPositions{0},
 
282
                                        Start:          7,
 
283
                                        End:            11,
 
284
                                },
 
285
                        },
 
286
                },
 
287
                {
 
288
                        input: TermLocations{
 
289
                                &TermLocation{
 
290
                                        ArrayPositions: search.ArrayPositions{0},
 
291
                                        Start:          0,
 
292
                                        End:            5,
 
293
                                },
 
294
                                &TermLocation{
 
295
                                        ArrayPositions: search.ArrayPositions{0},
 
296
                                        Start:          3,
 
297
                                        End:            11,
 
298
                                },
 
299
                        },
 
300
                        output: TermLocations{
 
301
                                &TermLocation{
 
302
                                        ArrayPositions: search.ArrayPositions{0},
 
303
                                        Start:          0,
 
304
                                        End:            11,
 
305
                                },
 
306
                                nil,
 
307
                        },
 
308
                },
 
309
                {
 
310
                        input: TermLocations{
 
311
                                &TermLocation{
 
312
                                        ArrayPositions: search.ArrayPositions{0},
 
313
                                        Start:          0,
 
314
                                        End:            5,
 
315
                                },
 
316
                                &TermLocation{
 
317
                                        ArrayPositions: search.ArrayPositions{1},
 
318
                                        Start:          3,
 
319
                                        End:            11,
 
320
                                },
 
321
                        },
 
322
                        output: TermLocations{
 
323
                                &TermLocation{
 
324
                                        ArrayPositions: search.ArrayPositions{0},
 
325
                                        Start:          0,
 
326
                                        End:            5,
 
327
                                },
 
328
                                &TermLocation{
 
329
                                        ArrayPositions: search.ArrayPositions{1},
 
330
                                        Start:          3,
 
331
                                        End:            11,
 
332
                                },
 
333
                        },
 
334
                },
 
335
        }
 
336
 
 
337
        for _, test := range tests {
 
338
                test.input.MergeOverlapping()
 
339
                if !reflect.DeepEqual(test.input, test.output) {
 
340
                        t.Errorf("expected: %#v got %#v", test.output, test.input)
 
341
                }
 
342
        }
 
343
}
 
344
 
 
345
func TestTermLocationsOrder(t *testing.T) {
 
346
 
 
347
        tests := []struct {
 
348
                input  search.TermLocationMap
 
349
                output TermLocations
 
350
        }{
 
351
                {
 
352
                        input:  search.TermLocationMap{},
 
353
                        output: TermLocations{},
 
354
                },
 
355
                {
 
356
                        input: search.TermLocationMap{
 
357
                                "term": []*search.Location{
 
358
                                        {
 
359
                                                Start: 0,
 
360
                                        },
 
361
                                        {
 
362
                                                Start: 5,
 
363
                                        },
 
364
                                },
 
365
                        },
 
366
                        output: TermLocations{
 
367
                                &TermLocation{
 
368
                                        Term:  "term",
 
369
                                        Start: 0,
 
370
                                },
 
371
                                &TermLocation{
 
372
                                        Term:  "term",
 
373
                                        Start: 5,
 
374
                                },
 
375
                        },
 
376
                },
 
377
                {
 
378
                        input: search.TermLocationMap{
 
379
                                "term": []*search.Location{
 
380
                                        {
 
381
                                                Start: 5,
 
382
                                        },
 
383
                                        {
 
384
                                                Start: 0,
 
385
                                        },
 
386
                                },
 
387
                        },
 
388
                        output: TermLocations{
 
389
                                &TermLocation{
 
390
                                        Term:  "term",
 
391
                                        Start: 0,
 
392
                                },
 
393
                                &TermLocation{
 
394
                                        Term:  "term",
 
395
                                        Start: 5,
 
396
                                },
 
397
                        },
 
398
                },
 
399
                // with array positions
 
400
                {
 
401
                        input: search.TermLocationMap{
 
402
                                "term": []*search.Location{
 
403
                                        {
 
404
                                                ArrayPositions: search.ArrayPositions{0},
 
405
                                                Start:          0,
 
406
                                        },
 
407
                                        {
 
408
                                                ArrayPositions: search.ArrayPositions{0},
 
409
                                                Start:          5,
 
410
                                        },
 
411
                                },
 
412
                        },
 
413
                        output: TermLocations{
 
414
                                &TermLocation{
 
415
                                        ArrayPositions: search.ArrayPositions{0},
 
416
                                        Term:           "term",
 
417
                                        Start:          0,
 
418
                                },
 
419
                                &TermLocation{
 
420
                                        ArrayPositions: search.ArrayPositions{0},
 
421
                                        Term:           "term",
 
422
                                        Start:          5,
 
423
                                },
 
424
                        },
 
425
                },
 
426
                {
 
427
                        input: search.TermLocationMap{
 
428
                                "term": []*search.Location{
 
429
                                        {
 
430
                                                ArrayPositions: search.ArrayPositions{0},
 
431
                                                Start:          5,
 
432
                                        },
 
433
                                        {
 
434
                                                ArrayPositions: search.ArrayPositions{0},
 
435
                                                Start:          0,
 
436
                                        },
 
437
                                },
 
438
                        },
 
439
                        output: TermLocations{
 
440
                                &TermLocation{
 
441
                                        ArrayPositions: search.ArrayPositions{0},
 
442
                                        Term:           "term",
 
443
                                        Start:          0,
 
444
                                },
 
445
                                &TermLocation{
 
446
                                        ArrayPositions: search.ArrayPositions{0},
 
447
                                        Term:           "term",
 
448
                                        Start:          5,
 
449
                                },
 
450
                        },
 
451
                },
 
452
                {
 
453
                        input: search.TermLocationMap{
 
454
                                "term": []*search.Location{
 
455
                                        {
 
456
                                                ArrayPositions: search.ArrayPositions{0},
 
457
                                                Start:          5,
 
458
                                        },
 
459
                                        {
 
460
                                                ArrayPositions: search.ArrayPositions{1},
 
461
                                                Start:          0,
 
462
                                        },
 
463
                                },
 
464
                        },
 
465
                        output: TermLocations{
 
466
                                &TermLocation{
 
467
                                        ArrayPositions: search.ArrayPositions{0},
 
468
                                        Term:           "term",
 
469
                                        Start:          5,
 
470
                                },
 
471
                                &TermLocation{
 
472
                                        ArrayPositions: search.ArrayPositions{1},
 
473
                                        Term:           "term",
 
474
                                        Start:          0,
 
475
                                },
 
476
                        },
 
477
                },
 
478
                {
 
479
                        input: search.TermLocationMap{
 
480
                                "term": []*search.Location{
 
481
                                        {
 
482
                                                ArrayPositions: search.ArrayPositions{0},
 
483
                                                Start:          5,
 
484
                                        },
 
485
                                        {
 
486
                                                ArrayPositions: search.ArrayPositions{0, 1},
 
487
                                                Start:          0,
 
488
                                        },
 
489
                                },
 
490
                        },
 
491
                        output: TermLocations{
 
492
                                &TermLocation{
 
493
                                        ArrayPositions: search.ArrayPositions{0},
 
494
                                        Term:           "term",
 
495
                                        Start:          5,
 
496
                                },
 
497
                                &TermLocation{
 
498
                                        ArrayPositions: search.ArrayPositions{0, 1},
 
499
                                        Term:           "term",
 
500
                                        Start:          0,
 
501
                                },
 
502
                        },
 
503
                },
 
504
        }
 
505
 
 
506
        for _, test := range tests {
 
507
                actual := OrderTermLocations(test.input)
 
508
                if !reflect.DeepEqual(actual, test.output) {
 
509
                        t.Errorf("expected: %#v got %#v", test.output, actual)
 
510
                }
 
511
        }
 
512
}