← Back to branch summary

~ubuntu-branches/ubuntu/raring/clucene-core/raring-proposed

« back to all changes in this revision

Viewing changes to src/test/search/spans/TestSpans.cpp

  • Committer: Package Import Robot
  • Author(s): Fathi Boudra
  • Date: 2012-08-11 09:33:38 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120811093338-fgrx41ftqew3qt6a
Tags: 2.3.3.4-1
http://bugs.debian.org/661703
* New upstream release (Closes: #661703).
* Convert package to multiarch.
* Drop obsolete patches:
  - 01_add_missing_include_bug505667.diff
  - 02_posixness_fix_bug530308.diff
* Add patches:
  - Fixing_ZLIB_configuration_in_shared_CMakeLists.patch
  - Fix-pkgconfig-file-by-adding-clucene-shared-library.patch
  - Install-contribs-lib.patch
  - multiarch.patch
* Update debian/compat: bump to 8.
* Update debian/control:
  - update build dependencies (add cmake, libboost-dev and libz-dev).
  - bump Standards-Version to 3.9.3.
  - rename packages due to ABI bump: libclucene0ldbl -> libclucene-core1.
  - add libclucene-contribs1 package.
* Update debian/rules:
  - rewrite to use CMake.
  - add multiarch support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/search/spans/TestSpans.cpp
 
1
/*------------------------------------------------------------------------------
 
2
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
 
3
*
 
4
* Distributable under the terms of either the Apache License (Version 2.0) or
 
5
* the GNU Lesser General Public License, as specified in the COPYING file.
 
6
------------------------------------------------------------------------------*/
 
7
#include "../CheckHits.h"
 
8
#include "TestSpans.h"
 
9
#include "CLucene/search/spans/Spans.h"
 
10
#include "CLucene/search/spans/SpanNearQuery.h"
 
11
#include "CLucene/search/spans/SpanOrQuery.h"
 
12
 
 
13
const TCHAR * TestSpans::field = _T( "field" );
 
14
const TCHAR * TestSpans::docFields[] =
 
15
{
 
16
    _T( "w1 w2 w3 w4 w5" ),
 
17
    _T( "w1 w3 w2 w3" ),
 
18
    _T( "w1 xx w2 yy w3" ),
 
19
    _T( "w1 w3 xx w2 yy w3" ),
 
20
    _T( "u2 u2 u1" ),
 
21
    _T( "u2 xx u2 u1" ),
 
22
    _T( "u2 u2 xx u1" ),
 
23
    _T( "u2 xx u2 yy u1" ),
 
24
    _T( "u2 xx u1 u2" ),
 
25
    _T( "u2 u1 xx u2" ),
 
26
    _T( "u1 u2 xx u2" ),
 
27
    _T( "t1 t2 t1 t3 t2 t3" )
 
28
};
 
29
 
 
30
TestSpans::TestSpans( CuTest* tc )
 
31
{
 
32
    this->tc = tc;
 
33
    this->searcher = NULL;
 
34
    this->directory = NULL;
 
35
}
 
36
 
 
37
TestSpans::~TestSpans()
 
38
{
 
39
    if( searcher )
 
40
    {
 
41
        searcher->close();
 
42
        _CLDELETE( searcher );
 
43
    }
 
44
 
 
45
    if( directory )
 
46
    {
 
47
        directory->close();
 
48
        _CLDELETE( directory );
 
49
    }
 
50
}
 
51
 
 
52
void TestSpans::setUp()
 
53
{
 
54
    directory = _CLNEW RAMDirectory();
 
55
    Analyzer * analyzer = _CLNEW WhitespaceAnalyzer();
 
56
    IndexWriter * writer = _CLNEW IndexWriter( directory, analyzer, true );
 
57
    
 
58
    for( size_t i = 0; i < sizeof( docFields ) / sizeof( docFields[0] ); i++ )
 
59
    {
 
60
        Document doc;
 
61
        doc.add( * _CLNEW Field( field, docFields[ i ], Field::STORE_YES | Field::INDEX_TOKENIZED ));
 
62
        writer->addDocument( &doc );
 
63
    }
 
64
    
 
65
    writer->close();
 
66
    _CLDELETE( writer );
 
67
    _CLDELETE( analyzer );
 
68
 
 
69
    searcher = _CLNEW IndexSearcher( directory );
 
70
}
 
71
 
 
72
SpanTermQuery * TestSpans::makeSpanTermQuery( const TCHAR * text )
 
73
{
 
74
    Term * term = _CLNEW Term( field, text );
 
75
    SpanTermQuery * query = _CLNEW SpanTermQuery( term );
 
76
    _CLDECDELETE( term );
 
77
    return query;
 
78
}
 
79
  
 
80
void TestSpans::checkHits( Query * query, int32_t * results, size_t resultsCount )
 
81
{
 
82
    CheckHits::checkHits( tc, query, field, searcher, results, resultsCount );
 
83
}
 
84
  
 
85
void TestSpans::orderedSlopTest3SQ( SpanQuery * q1, SpanQuery * q2, SpanQuery * q3, int32_t slop, int32_t * expectedDocs, size_t expectedDocsCount )
 
86
{
 
87
    bool ordered = true;
 
88
    SpanQuery ** clauses = _CL_NEWARRAY( SpanQuery *, 3 );
 
89
    clauses[ 0 ] = q1;
 
90
    clauses[ 1 ] = q2;
 
91
    clauses[ 2 ] = q3;
 
92
 
 
93
    SpanNearQuery * snq = _CLNEW SpanNearQuery( clauses, clauses+3, slop, ordered, true );
 
94
    checkHits( snq, expectedDocs, expectedDocsCount );
 
95
 
 
96
    _CLLDELETE( snq );
 
97
    _CLDELETE_LARRAY( clauses );
 
98
}
 
99
  
 
100
void TestSpans::orderedSlopTest3( int32_t slop, int32_t * expectedDocs, size_t expectedDocsCount )
 
101
{
 
102
    orderedSlopTest3SQ( 
 
103
        makeSpanTermQuery( _T( "w1" )), 
 
104
        makeSpanTermQuery( _T( "w2" )), 
 
105
        makeSpanTermQuery( _T( "w3" )),
 
106
        slop,
 
107
        expectedDocs, 
 
108
        expectedDocsCount );
 
109
}
 
110
  
 
111
void TestSpans::orderedSlopTest3Equal( int32_t slop, int32_t * expectedDocs, size_t expectedDocsCount )
 
112
{
 
113
    orderedSlopTest3SQ(
 
114
        makeSpanTermQuery( _T( "w1" )),
 
115
        makeSpanTermQuery( _T( "w3" )),
 
116
        makeSpanTermQuery( _T( "w3" )),
 
117
        slop,
 
118
        expectedDocs,
 
119
        expectedDocsCount );
 
120
}
 
121
  
 
122
void TestSpans::orderedSlopTest1Equal( int32_t slop, int32_t * expectedDocs, size_t expectedDocsCount )
 
123
{
 
124
    orderedSlopTest3SQ(
 
125
        makeSpanTermQuery( _T( "u2" )),
 
126
        makeSpanTermQuery( _T( "u2" )),
 
127
        makeSpanTermQuery( _T( "u1" )),
 
128
        slop,
 
129
        expectedDocs,
 
130
        expectedDocsCount );
 
131
}
 
132
 
 
133
void TestSpans::testSpanNearOrdered()
 
134
{
 
135
    int32_t expectedDocs[] = { 0, 1, 2, 3 };
 
136
 
 
137
    orderedSlopTest3( 0, expectedDocs, 1 );
 
138
    orderedSlopTest3( 1, expectedDocs, 2 );
 
139
    orderedSlopTest3( 2, expectedDocs, 3 );
 
140
    orderedSlopTest3( 3, expectedDocs, 4 );
 
141
    orderedSlopTest3( 4, expectedDocs, 4 );
 
142
}
 
143
  
 
144
void TestSpans::testSpanNearOrderedEqual()
 
145
{
 
146
    int32_t expectedDocs[] = { 1, 3 };
 
147
 
 
148
    orderedSlopTest3Equal( 0, expectedDocs, 0 );
 
149
    orderedSlopTest3Equal( 1, expectedDocs, 1 );
 
150
    orderedSlopTest3Equal( 2, expectedDocs, 1 );
 
151
    orderedSlopTest3Equal( 3, expectedDocs, 2 );
 
152
}
 
153
  
 
154
void TestSpans::testSpanNearOrderedEqual1()
 
155
{
 
156
    int32_t expectedDocs[] = { 4, 5, 6, 7 };
 
157
 
 
158
    orderedSlopTest1Equal( 0, expectedDocs, 1 );
 
159
    orderedSlopTest1Equal( 0, expectedDocs, 1 );
 
160
    orderedSlopTest1Equal( 1, expectedDocs, 3 );
 
161
    orderedSlopTest1Equal( 2, expectedDocs, 4 );
 
162
    orderedSlopTest1Equal( 3, expectedDocs, 4 );
 
163
}
 
164
 
 
165
void TestSpans::testSpanNearOrderedOverlap()
 
166
{
 
167
    bool ordered = true;
 
168
    int32_t slop = 1;
 
169
    
 
170
    SpanQuery ** clauses = _CL_NEWARRAY( SpanQuery *, 3 );
 
171
    clauses[ 0 ] = makeSpanTermQuery( _T( "t1" ));
 
172
    clauses[ 1 ] = makeSpanTermQuery( _T( "t2" ));
 
173
    clauses[ 2 ] = makeSpanTermQuery( _T( "t3" ));
 
174
 
 
175
    SpanNearQuery * snq = _CLNEW SpanNearQuery( clauses, clauses+3, slop, ordered, true );
 
176
    Spans * spans = snq->getSpans( searcher->getReader() );
 
177
 
 
178
    assertTrueMsg( _T( "first range" ), spans->next() );
 
179
    assertEqualsMsg( _T( "first doc" ), 11, spans->doc());
 
180
    assertEqualsMsg( _T( "first start" ), 0, spans->start());
 
181
    assertEqualsMsg( _T( "first end" ), 4, spans->end());
 
182
 
 
183
    assertTrueMsg( _T( "second range" ), spans->next());
 
184
    assertEqualsMsg( _T( "second doc" ), 11, spans->doc());
 
185
    assertEqualsMsg( _T( "second start" ), 2, spans->start());
 
186
    assertEqualsMsg( _T( "second end" ), 6, spans->end());
 
187
 
 
188
    assertTrueMsg( _T( "third range" ), ! spans->next());
 
189
 
 
190
    _CLLDELETE( spans );
 
191
    _CLLDELETE( snq );
 
192
    _CLDELETE_LARRAY( clauses );
 
193
}
 
194
 
 
195
void TestSpans::orSpans( const TCHAR ** terms, size_t termsCount, Spans *& spans, Query *& query )
 
196
{
 
197
    SpanQuery ** clauses = _CL_NEWARRAY( SpanQuery *, termsCount );
 
198
    
 
199
    for( size_t i = 0; i < termsCount; i++ ) 
 
200
        clauses[ i ] = makeSpanTermQuery( terms[ i ]);
 
201
 
 
202
    SpanOrQuery * soq = _CLNEW SpanOrQuery( clauses, clauses + termsCount, true );
 
203
    _CLDELETE_LARRAY( clauses );
 
204
 
 
205
    spans = soq->getSpans( searcher->getReader() );
 
206
    query = soq;
 
207
}
 
208
 
 
209
void TestSpans::tstNextSpans( Spans * spans, int32_t doc, int32_t start, int32_t end )
 
210
{
 
211
    assertTrueMsg( _T( "next" ), spans->next());
 
212
    assertEqualsMsg( _T( "doc" ), doc, spans->doc());
 
213
    assertEqualsMsg( _T( "start" ), start, spans->start());
 
214
    assertEqualsMsg( _T( "end" ), end, spans->end());
 
215
}
 
216
 
 
217
void TestSpans::testSpanOrEmpty()
 
218
{
 
219
    Spans * spans;
 
220
    Query * query;
 
221
    orSpans( NULL, 0, spans, query );
 
222
    assertTrueMsg( _T( "empty next" ), ! spans->next());
 
223
    _CLLDELETE( spans );
 
224
    _CLLDELETE( query );
 
225
}
 
226
 
 
227
void TestSpans::testSpanOrSingle()
 
228
{
 
229
    Spans * spans;
 
230
    Query * query;
 
231
    const TCHAR* terms[] = { _T( "w5" ) };
 
232
    orSpans( terms, 1, spans, query );
 
233
    tstNextSpans( spans, 0, 4, 5 );
 
234
    assertTrueMsg( _T( "final next" ), ! spans->next());
 
235
    _CLLDELETE( spans );
 
236
    _CLLDELETE( query );
 
237
}
 
238
  
 
239
void TestSpans::testSpanOrDouble()
 
240
{
 
241
    Spans * spans;
 
242
    Query * query;
 
243
    const TCHAR* terms[] = { _T( "w5" ), _T( "yy" ) };
 
244
    orSpans( terms, 2, spans, query );
 
245
    tstNextSpans( spans, 0, 4, 5 );
 
246
    tstNextSpans( spans, 2, 3, 4 );
 
247
    tstNextSpans( spans, 3, 4, 5 );
 
248
    tstNextSpans( spans, 7, 3, 4 );
 
249
    assertTrueMsg( _T( "final next" ), ! spans->next());
 
250
    _CLLDELETE( spans );
 
251
    _CLLDELETE( query );
 
252
}
 
253
 
 
254
void TestSpans::testSpanOrDoubleSkip()
 
255
{
 
256
    Spans * spans;
 
257
    Query * query;
 
258
    const TCHAR* terms[] = { _T( "w5" ), _T( "yy" ) };
 
259
    orSpans( terms, 2, spans, query );
 
260
    assertTrueMsg( _T( "initial skipTo" ), spans->skipTo( 3 ));
 
261
    assertEqualsMsg( _T( "doc" ), 3, spans->doc() );
 
262
    assertEqualsMsg( _T( "start" ), 4, spans->start() );
 
263
    assertEqualsMsg( _T( "end" ), 5, spans->end() );
 
264
    tstNextSpans( spans, 7, 3, 4 );
 
265
    assertTrueMsg( _T( "final next" ), ! spans->next() );
 
266
    _CLLDELETE( spans );
 
267
    _CLLDELETE( query );
 
268
}
 
269
 
 
270
void TestSpans::testSpanOrUnused()
 
271
{
 
272
    Spans * spans;
 
273
    Query * query;
 
274
    const TCHAR* terms[] = { _T( "w5" ), _T( "unusedTerm" ), _T( "yy" ) };
 
275
    orSpans( terms, 3, spans, query );
 
276
    tstNextSpans( spans, 0, 4, 5 );
 
277
    tstNextSpans( spans, 2, 3, 4 );
 
278
    tstNextSpans( spans, 3, 4, 5 );
 
279
    tstNextSpans( spans, 7, 3, 4 );
 
280
    assertTrueMsg( _T( "final next" ), ! spans->next());
 
281
    _CLLDELETE( spans );
 
282
    _CLLDELETE( query );
 
283
}
 
284
 
 
285
void TestSpans::testSpanOrTripleSameDoc()
 
286
{
 
287
    Spans * spans;
 
288
    Query * query;
 
289
    const TCHAR* terms[] = { _T( "t1" ), _T( "t2" ), _T( "t3" ) };
 
290
    orSpans( terms, 3, spans, query );
 
291
    tstNextSpans( spans, 11, 0, 1 );
 
292
    tstNextSpans( spans, 11, 1, 2 );
 
293
    tstNextSpans( spans, 11, 2, 3 );
 
294
    tstNextSpans( spans, 11, 3, 4 );
 
295
    tstNextSpans( spans, 11, 4, 5 );
 
296
    tstNextSpans( spans, 11, 5, 6 );
 
297
    assertTrueMsg( _T( "final next" ), ! spans->next());
 
298
    _CLLDELETE( spans );
 
299
    _CLLDELETE( query );
 
300
}