| changeset 1 | 6f2c1c46032b |
| parent 0 | 671dee74050a |
| child 14 | 8bd192d47aaa |
| 0:671dee74050a | 1:6f2c1c46032b |
|---|---|
19 #include <e32svr.h> |
19 #include <e32svr.h> |
20 #include <StifParser.h> |
20 #include <StifParser.h> |
21 #include <StifTestInterface.h> |
21 #include <StifTestInterface.h> |
22 #include "cpixsearchertest.h" |
22 #include "cpixsearchertest.h" |
23 |
23 |
24 #include "ccpixsearcher.h" |
24 #include <ccpixsearcher.h> |
25 #include "CSearchDocument.h" |
25 #include <CSearchDocument.h> |
26 #include "CCPixIndexer.h" |
26 #include <CCPixIndexer.h> |
27 #include "common.h" |
27 #include <common.h> |
28 #include "cpixsearchertester.h" |
28 #include "cpixsearchertester.h" |
29 #include "multithreadtester.h" |
29 #include "multithreadtester.h" |
30 #include "cpixboostertester.h" |
30 #include "cpixboostertester.h" |
31 #include "cpixanalyzertester.h" |
31 #include "cpixanalyzertester.h" |
32 #include "cpixindexerterster.h" |
32 #include "cpixindexerterster.h" |
160 ENTRY( "TestSearchAsynchronous", Ccpixsearchertest::TestSearchAsynchronousL), |
160 ENTRY( "TestSearchAsynchronous", Ccpixsearchertest::TestSearchAsynchronousL), |
161 ENTRY( "TestSearchLeavesIfNotCancelled", Ccpixsearchertest::TestSearchLeavesIfNotCancelledL), |
161 ENTRY( "TestSearchLeavesIfNotCancelled", Ccpixsearchertest::TestSearchLeavesIfNotCancelledL), |
162 ENTRY( "TestOpenIndexDb", Ccpixsearchertest::TestOpenIndexDbL), |
162 ENTRY( "TestOpenIndexDb", Ccpixsearchertest::TestOpenIndexDbL), |
163 ENTRY( "TestDeleteIndexDbWhileSearching", Ccpixsearchertest::TestDeleteIndexDbWhileSearchingL), |
163 ENTRY( "TestDeleteIndexDbWhileSearching", Ccpixsearchertest::TestDeleteIndexDbWhileSearchingL), |
164 ENTRY( "TestGetDocumentAsync", Ccpixsearchertest::TestGetDocumentAsyncL), |
164 ENTRY( "TestGetDocumentAsync", Ccpixsearchertest::TestGetDocumentAsyncL), |
165 ENTRY( "TestGetInvalidDocumentAsync", Ccpixsearchertest::TestGetInvalidDocumentAsyncL), |
165 ENTRY( "TestGetInvalidDocumentAsync", Ccpixsearchertest::TestGetInvalidDocumentAsyncL), |
166 ENTRY( "TestExerptLength", Ccpixsearchertest::TestExerptLengthL), |
|
166 |
167 |
167 //ADD NEW ENTRY HERE |
168 //ADD NEW ENTRY HERE |
168 // [test cases entries] - Do not remove |
169 // [test cases entries] - Do not remove |
169 |
170 |
170 }; |
171 }; |
198 } |
199 } |
199 CleanupStack::PopAndDestroy(indexer); |
200 CleanupStack::PopAndDestroy(indexer); |
200 indexer = NULL; |
201 indexer = NULL; |
201 iSession.UnDefineVolume( KFileBaseAppClassC ); |
202 iSession.UnDefineVolume( KFileBaseAppClassC ); |
202 iSession.Close(); |
203 iSession.Close(); |
203 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
204 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
204 /*CTestSearcher* testsearcher = new CTestSearcher(); |
|
205 TInt error = KErrNone; |
|
206 testsearcher->setUp(); |
|
207 testsearcher->tearDown();*/ |
|
208 return error; |
205 return error; |
209 } |
206 } |
210 |
207 |
211 // ----------------------------------------------------------------------------- |
208 // ----------------------------------------------------------------------------- |
212 // Ccpixsearchertest::TestOpenValidIndexdbL |
209 // Ccpixsearchertest::TestOpenValidIndexdbL |
235 // ----------------------------------------------------------------------------- |
232 // ----------------------------------------------------------------------------- |
236 // Ccpixsearchertest::TestOpenValidIndexdbL |
233 // Ccpixsearchertest::TestOpenValidIndexdbL |
237 // ----------------------------------------------------------------------------- |
234 // ----------------------------------------------------------------------------- |
238 // |
235 // |
239 TInt Ccpixsearchertest::TestAddDocumentL( CStifItemParser& aItem ) |
236 TInt Ccpixsearchertest::TestAddDocumentL( CStifItemParser& aItem ) |
240 { |
237 { |
241 RSearchServerSession iSession; |
238 RSearchServerSession iSession; |
242 TInt error = KErrNotFound; |
239 TInt error = KErrNotFound; |
243 TPtrC fileName; |
240 TPtrC fileName; |
244 TPtrC searchstring; |
241 TPtrC searchstring; |
245 aItem.GetNextString ( searchstring ); |
242 aItem.GetNextString ( searchstring ); |
246 User::LeaveIfError(iSession.Connect()); |
243 User::LeaveIfError(iSession.Connect()); |
247 iSession.DefineVolume(KFileBaseAppClassC, KNullDesC); |
244 iSession.DefineVolume(KFileBaseAppClassC, KNullDesC); |
248 _LIT( KTestFormBaseAppClassNoError, "TestAddDocumentL: No Error" ); |
245 _LIT( KTestFormBaseAppClassNoError, "TestAddDocumentL: No Error" ); |
249 TInt result = doSearch( KQueryString , KFileBaseAppClassC ); |
|
250 if ( result > 0 ) |
|
251 { |
|
252 doLog( iLog, KErrUnknown, KTestFormBaseAppClassNoError ); |
|
253 iSession.UnDefineVolume( KFileBaseAppClassC ); |
|
254 iSession.Close(); |
|
255 return KErrUnknown; |
|
256 } |
|
257 CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession); |
246 CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession); |
258 TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) ); |
247 TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) ); |
259 // creating CSearchDocument object with unique ID for this application |
248 // creating CSearchDocument object with unique ID for this application |
260 |
249 |
261 if( aItem.GetNextString ( fileName ) == KErrNone ) |
250 if( aItem.GetNextString ( fileName ) == KErrNone ) |
262 { |
251 { |
263 CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
252 CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
266 if (indexer) |
255 if (indexer) |
267 { |
256 { |
268 indexer->AddL(*index_item); |
257 indexer->AddL(*index_item); |
269 } |
258 } |
270 CleanupStack::PopAndDestroy(index_item); |
259 CleanupStack::PopAndDestroy(index_item); |
271 } |
260 } |
272 //@TODO add wait here to harvest |
261 User::After((TTimeIntervalMicroSeconds32)30000000); |
273 User::After((TTimeIntervalMicroSeconds32)16000000); |
262 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
274 result = doSearch( KQueryString , KFileBaseAppClassC ); |
|
275 if ( result > 0 ) |
263 if ( result > 0 ) |
276 error = KErrNone; |
264 error = KErrNone; |
277 indexer->ResetL(); |
265 indexer->ResetL(); |
278 CleanupStack::PopAndDestroy(indexer); |
266 CleanupStack::PopAndDestroy(indexer); |
279 indexer = NULL; |
267 indexer = NULL; |
293 TPtrC fileName; |
281 TPtrC fileName; |
294 TPtrC searchstring; |
282 TPtrC searchstring; |
295 aItem.GetNextString ( searchstring ); |
283 aItem.GetNextString ( searchstring ); |
296 User::LeaveIfError(iSession.Connect()); |
284 User::LeaveIfError(iSession.Connect()); |
297 iSession.DefineVolume(KFileBaseAppClassC, KNullDesC); |
285 iSession.DefineVolume(KFileBaseAppClassC, KNullDesC); |
298 _LIT( KTestFormBaseAppClassNoError, "TestAddCancelL: No Error" ); |
286 _LIT( KTestFormBaseAppClassNoError, "TestAddCancelL: No Error" ); |
299 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
|
300 if ( result > 0 ) |
|
301 { |
|
302 doLog( iLog, KErrUnknown, KTestFormBaseAppClassNoError ); |
|
303 return KErrUnknown; |
|
304 } |
|
305 CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession); |
287 CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession); |
306 TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) ); |
288 TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) ); |
307 // creating CSearchDocument object with unique ID for this application |
289 // creating CSearchDocument object with unique ID for this application |
308 |
290 indexer->ResetL(); |
309 if( aItem.GetNextString ( fileName ) == KErrNone ) |
291 if( aItem.GetNextString ( fileName ) == KErrNone ) |
310 { |
292 { |
311 CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
293 CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
312 |
294 |
313 // Send for indexing |
295 // Send for indexing |
319 CleanupStack::PopAndDestroy(index_item); |
301 CleanupStack::PopAndDestroy(index_item); |
320 } |
302 } |
321 CleanupStack::PopAndDestroy(indexer); |
303 CleanupStack::PopAndDestroy(indexer); |
322 indexer = NULL; |
304 indexer = NULL; |
323 // Cancelled, but the document will still have been added to the IndexDB |
305 // Cancelled, but the document will still have been added to the IndexDB |
324 result = doSearch( searchstring , KFileBaseAppClassC ); |
306 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
325 if ( result > 0 ) |
307 if ( result > 0 ) |
326 error = KErrNone; |
308 error = KErrNone; |
327 iSession.UnDefineVolume( KFileBaseAppClassC ); |
309 iSession.UnDefineVolume( KFileBaseAppClassC ); |
328 iSession.Close(); |
310 iSession.Close(); |
329 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
311 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
337 { |
319 { |
338 _LIT( KTestFormBaseAppClassNoError, "TestAsyncAddDocumentL: No Error" ); |
320 _LIT( KTestFormBaseAppClassNoError, "TestAsyncAddDocumentL: No Error" ); |
339 |
321 |
340 CTestIndexer* testindexer = new CTestIndexer(); |
322 CTestIndexer* testindexer = new CTestIndexer(); |
341 testindexer->setUp(); |
323 testindexer->setUp(); |
342 TRAPD ( error , testindexer->testAsyncAddL() ); |
324 testindexer->InitSearcher(); |
325 testindexer->InitAsyncModules(); |
|
326 TRAPD ( error , testindexer->testAsyncAddL() ); |
|
327 testindexer->ReleaseSearcher(); |
|
328 testindexer->ReleaseAsyncModules(); |
|
343 testindexer->tearDown(); |
329 testindexer->tearDown(); |
344 delete testindexer; |
330 delete testindexer; |
345 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
331 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
346 return error; |
332 return error; |
347 } |
333 } |
360 iSession.DefineVolume(KFileBaseAppClassC, KNullDesC); |
346 iSession.DefineVolume(KFileBaseAppClassC, KNullDesC); |
361 _LIT( KTestFormBaseAppClassNoError, "TestUpdateDocumentL: No Error" ); |
347 _LIT( KTestFormBaseAppClassNoError, "TestUpdateDocumentL: No Error" ); |
362 CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession); |
348 CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession); |
363 TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) ); |
349 TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) ); |
364 // creating CSearchDocument object with unique ID for this application |
350 // creating CSearchDocument object with unique ID for this application |
365 |
351 indexer->ResetL(); |
366 if( aItem.GetNextString ( fileName ) == KErrNone ) |
352 if( aItem.GetNextString ( fileName ) == KErrNone ) |
367 { |
353 { |
368 CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
354 CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
369 |
355 |
370 // Send for indexing |
356 // Send for indexing |
371 if (indexer) |
357 if (indexer) |
372 { |
358 { |
373 indexer->AddL(*index_item); |
359 indexer->AddL(*index_item); |
374 } |
360 } |
375 CleanupStack::PopAndDestroy(index_item); |
361 CleanupStack::PopAndDestroy(index_item); |
376 |
362 User::After((TTimeIntervalMicroSeconds32)30000000); |
377 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
363 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
378 index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
364 index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser); |
379 // Send for indexing |
365 // Send for indexing |
380 if (indexer) |
366 if (indexer) |
381 { |
367 { |
382 indexer->UpdateL(*index_item); |
368 indexer->UpdateL(*index_item); |
383 } |
369 } |
384 CleanupStack::PopAndDestroy(index_item); |
370 CleanupStack::PopAndDestroy(index_item); |
385 User::After((TTimeIntervalMicroSeconds32)16000000); |
371 User::After((TTimeIntervalMicroSeconds32)30000000); |
386 TInt result1 = doSearch( searchstring , KFileBaseAppClassC ); |
372 TInt result1 = doSearch( searchstring , KFileBaseAppClassC ); |
387 |
373 |
388 if ( result != result1) |
374 if ( result != result1) |
389 error = KErrUnknown; |
375 error = KErrUnknown; |
390 } |
376 } |
402 TInt Ccpixsearchertest::TestAsyncUpdateL( CStifItemParser& /*aItem*/ ) |
388 TInt Ccpixsearchertest::TestAsyncUpdateL( CStifItemParser& /*aItem*/ ) |
403 { |
389 { |
404 _LIT( KTestFormBaseAppClassNoError, "TestAsyncUpdateL: No Error" ); |
390 _LIT( KTestFormBaseAppClassNoError, "TestAsyncUpdateL: No Error" ); |
405 CTestIndexer* testindexer = new CTestIndexer(); |
391 CTestIndexer* testindexer = new CTestIndexer(); |
406 testindexer->setUp(); |
392 testindexer->setUp(); |
407 TRAPD ( error , testindexer->testAsyncUpdateL() ); |
393 testindexer->InitSearcher(); |
394 testindexer->InitAsyncModules(); |
|
395 TRAPD ( error , testindexer->testAsyncUpdateL() ); |
|
396 testindexer->ReleaseSearcher(); |
|
397 testindexer->ReleaseAsyncModules(); |
|
408 testindexer->tearDown(); |
398 testindexer->tearDown(); |
409 delete testindexer; |
399 delete testindexer; |
410 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
400 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
411 return error; |
401 return error; |
412 } |
402 } |
436 if (indexer) |
426 if (indexer) |
437 { |
427 { |
438 indexer->AddL(*index_item); |
428 indexer->AddL(*index_item); |
439 } |
429 } |
440 CleanupStack::PopAndDestroy(index_item); |
430 CleanupStack::PopAndDestroy(index_item); |
441 User::After((TTimeIntervalMicroSeconds32)16000000); |
431 User::After((TTimeIntervalMicroSeconds32)30000000); |
442 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
432 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
443 |
433 |
444 // Send for indexing |
434 // Send for indexing |
445 if (indexer) |
435 if (indexer) |
446 { |
436 { |
447 indexer->DeleteL(fileName); |
437 indexer->DeleteL(fileName); |
448 } |
438 } |
449 User::After((TTimeIntervalMicroSeconds32)16000000); |
439 User::After((TTimeIntervalMicroSeconds32)30000000); |
450 TInt result1 = doSearch( searchstring , KFileBaseAppClassC ); |
440 TInt result1 = doSearch( searchstring , KFileBaseAppClassC ); |
451 |
441 |
452 if ( (result-1) != result1) |
442 if ( (result-1) != result1) |
453 error = KErrUnknown; |
443 error = KErrUnknown; |
454 } |
444 } |
445 indexer->ResetL(); |
|
455 CleanupStack::PopAndDestroy(indexer); |
446 CleanupStack::PopAndDestroy(indexer); |
456 indexer = NULL; |
447 indexer = NULL; |
457 iSession.UnDefineVolume( KFileBaseAppClassC ); |
448 iSession.UnDefineVolume( KFileBaseAppClassC ); |
458 iSession.Close(); |
449 iSession.Close(); |
459 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
450 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
467 TInt Ccpixsearchertest::TestAsyncDeleteL( CStifItemParser& /*aItem*/ ) |
458 TInt Ccpixsearchertest::TestAsyncDeleteL( CStifItemParser& /*aItem*/ ) |
468 { |
459 { |
469 _LIT( KTestFormBaseAppClassNoError, "TestAsyncDeleteL: No Error" ); |
460 _LIT( KTestFormBaseAppClassNoError, "TestAsyncDeleteL: No Error" ); |
470 CTestIndexer* testindexer = new CTestIndexer(); |
461 CTestIndexer* testindexer = new CTestIndexer(); |
471 testindexer->setUp(); |
462 testindexer->setUp(); |
472 TRAPD ( error , testindexer->testAsyncDeleteL() ); |
463 testindexer->InitSearcher(); |
464 testindexer->InitAsyncModules(); |
|
465 TRAPD ( error , testindexer->testAsyncDeleteL() ); |
|
466 testindexer->ReleaseSearcher(); |
|
467 testindexer->ReleaseAsyncModules(); |
|
473 testindexer->tearDown(); |
468 testindexer->tearDown(); |
474 delete testindexer; |
469 delete testindexer; |
475 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
470 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
476 return error; |
471 return error; |
477 } |
472 } |
501 if (indexer) |
496 if (indexer) |
502 { |
497 { |
503 indexer->AddL(*index_item); |
498 indexer->AddL(*index_item); |
504 } |
499 } |
505 CleanupStack::PopAndDestroy(index_item); |
500 CleanupStack::PopAndDestroy(index_item); |
506 User::After((TTimeIntervalMicroSeconds32)16000000); |
501 User::After((TTimeIntervalMicroSeconds32)30000000); |
507 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
502 TInt result = doSearch( searchstring , KFileBaseAppClassC ); |
508 |
503 |
509 if ( result ) |
504 if ( result ) |
510 { |
505 { |
511 // Send for indexing |
506 // Send for indexing |
533 TInt Ccpixsearchertest::TestFlushL( CStifItemParser& /*aItem*/ ) |
528 TInt Ccpixsearchertest::TestFlushL( CStifItemParser& /*aItem*/ ) |
534 { |
529 { |
535 _LIT( KTestFormBaseAppClassNoError, "TestFlushL: No Error" ); |
530 _LIT( KTestFormBaseAppClassNoError, "TestFlushL: No Error" ); |
536 CTestIndexer* testindexer = new CTestIndexer(); |
531 CTestIndexer* testindexer = new CTestIndexer(); |
537 testindexer->setUp(); |
532 testindexer->setUp(); |
538 TRAPD ( error , testindexer->testFlushL() ); |
533 testindexer->InitSearcher(); |
534 TRAPD ( error , testindexer->testFlushL() ); |
|
535 testindexer->ReleaseSearcher(); |
|
539 testindexer->tearDown(); |
536 testindexer->tearDown(); |
540 delete testindexer; |
537 delete testindexer; |
541 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
538 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
542 return error; |
539 return error; |
543 } |
540 } |
548 TInt Ccpixsearchertest::TestAsyncFlushL( CStifItemParser& /*aItem*/ ) |
545 TInt Ccpixsearchertest::TestAsyncFlushL( CStifItemParser& /*aItem*/ ) |
549 { |
546 { |
550 _LIT( KTestFormBaseAppClassNoError, "TestAsyncFlushL: No Error" ); |
547 _LIT( KTestFormBaseAppClassNoError, "TestAsyncFlushL: No Error" ); |
551 CTestIndexer* testindexer = new CTestIndexer(); |
548 CTestIndexer* testindexer = new CTestIndexer(); |
552 testindexer->setUp(); |
549 testindexer->setUp(); |
553 TRAPD ( error , testindexer->testAsyncFlushL() ); |
550 testindexer->InitSearcher(); |
551 testindexer->InitAsyncModules(); |
|
552 TRAPD ( error , testindexer->testAsyncFlushL() ); |
|
553 testindexer->ReleaseSearcher(); |
|
554 testindexer->ReleaseAsyncModules(); |
|
554 testindexer->tearDown(); |
555 testindexer->tearDown(); |
555 delete testindexer; |
556 delete testindexer; |
556 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
557 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
557 return error; |
558 return error; |
558 } |
559 } |
563 TInt Ccpixsearchertest::TestAsyncResetL( CStifItemParser& /*aItem*/ ) |
564 TInt Ccpixsearchertest::TestAsyncResetL( CStifItemParser& /*aItem*/ ) |
564 { |
565 { |
565 _LIT( KTestFormBaseAppClassNoError, "TestAsyncResetL: No Error" ); |
566 _LIT( KTestFormBaseAppClassNoError, "TestAsyncResetL: No Error" ); |
566 CTestIndexer* testindexer = new CTestIndexer(); |
567 CTestIndexer* testindexer = new CTestIndexer(); |
567 testindexer->setUp(); |
568 testindexer->setUp(); |
568 TRAPD ( error , testindexer->testAsyncResetL() ); |
569 testindexer->InitSearcher(); |
570 testindexer->InitAsyncModules(); |
|
571 TRAPD ( error , testindexer->testAsyncResetL() ); |
|
572 testindexer->ReleaseSearcher(); |
|
573 testindexer->ReleaseAsyncModules(); |
|
569 testindexer->tearDown(); |
574 testindexer->tearDown(); |
570 delete testindexer; |
575 delete testindexer; |
571 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
576 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
572 return error; |
577 return error; |
573 } |
578 } |
579 TInt Ccpixsearchertest::TestHandleIndexingResultL( CStifItemParser& /*aItem*/ ) |
584 TInt Ccpixsearchertest::TestHandleIndexingResultL( CStifItemParser& /*aItem*/ ) |
580 { |
585 { |
581 _LIT( KTestFormBaseAppClassNoError, "TestHandleIndexingResultL: No Error" ); |
586 _LIT( KTestFormBaseAppClassNoError, "TestHandleIndexingResultL: No Error" ); |
582 CTestIndexer* testindexer = new CTestIndexer(); |
587 CTestIndexer* testindexer = new CTestIndexer(); |
583 testindexer->setUp(); |
588 testindexer->setUp(); |
584 TRAPD ( error , testindexer->testHandleIndexingResultL_Leaves() ); |
589 testindexer->InitSearcher(); |
590 testindexer->InitAsyncModules(); |
|
591 TRAPD ( error , testindexer->testHandleIndexingResultL_Leaves() ); |
|
592 testindexer->ReleaseSearcher(); |
|
593 testindexer->ReleaseAsyncModules(); |
|
585 testindexer->tearDown(); |
594 testindexer->tearDown(); |
586 delete testindexer; |
595 delete testindexer; |
587 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
596 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
588 return error; |
597 return error; |
589 } |
598 } |
594 TInt Ccpixsearchertest::TestSetAnalyzerAsyncL( CStifItemParser& /*aItem*/ ) |
603 TInt Ccpixsearchertest::TestSetAnalyzerAsyncL( CStifItemParser& /*aItem*/ ) |
595 { |
604 { |
596 _LIT( KTestFormBaseAppClassNoError, "TestSetAnalyzerAsyncL: No Error" ); |
605 _LIT( KTestFormBaseAppClassNoError, "TestSetAnalyzerAsyncL: No Error" ); |
597 CTestIndexer* testindexer = new CTestIndexer(); |
606 CTestIndexer* testindexer = new CTestIndexer(); |
598 testindexer->setUp(); |
607 testindexer->setUp(); |
599 TRAPD ( error , testindexer->testSetAnalyzerAsync() ); |
608 testindexer->InitAsyncModules(); |
609 TRAPD ( error , testindexer->testSetAnalyzerAsync() ); |
|
610 testindexer->ReleaseAsyncModules(); |
|
600 testindexer->tearDown(); |
611 testindexer->tearDown(); |
601 delete testindexer; |
612 delete testindexer; |
602 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
613 doLog( iLog, error, KTestFormBaseAppClassNoError ); |
603 return error; |
614 return error; |
604 } |
615 } |
724 // Ccpixsearchertest::TestKnownTermL |
735 // Ccpixsearchertest::TestKnownTermL |
725 // ----------------------------------------------------------------------------- |
736 // ----------------------------------------------------------------------------- |
726 // |
737 // |
727 TInt Ccpixsearchertest::TestKnownTermL( CStifItemParser& /*aItem*/ ) |
738 TInt Ccpixsearchertest::TestKnownTermL( CStifItemParser& /*aItem*/ ) |
728 { |
739 { |
740 _LIT( KTestFormBaseAppClassNoError, "TestKnownTermL: No Error" ); |
|
741 CTestSearcher* testsearcher = new CTestSearcher(); |
|
742 testsearcher->initialsetUp(); |
|
743 testsearcher->createandinitindexer(); |
|
744 testsearcher->createsearcher(); |
|
745 testsearcher->harvesttestcontent( 8 ); |
|
746 TRAPD ( err , testsearcher->testKnownTermTestsL() ); |
|
747 testsearcher->ReleaseIndexer(); |
|
748 testsearcher->ReleaseSearcher(); |
|
749 testsearcher->tearDown(); |
|
750 delete testsearcher; |
|
751 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
752 return err; |
|
753 } |
|
754 // ----------------------------------------------------------------------------- |
|
755 // Ccpixsearchertest::TestWildcardTermL |
|
756 // ----------------------------------------------------------------------------- |
|
757 // |
|
758 TInt Ccpixsearchertest::TestWildcardTermL( CStifItemParser& /*aItem*/ ) |
|
759 { |
|
760 _LIT( KTestFormBaseAppClassNoError, "TestWildcardTermL: No Error" ); |
|
761 CTestSearcher* testsearcher = new CTestSearcher(); |
|
762 testsearcher->initialsetUp(); |
|
763 testsearcher->createandinitindexer(); |
|
764 testsearcher->createsearcher(); |
|
765 testsearcher->harvesttestcontent( 8 ); |
|
766 TRAPD ( err , testsearcher->testWildcardTermTests() ); |
|
767 testsearcher->ReleaseIndexer(); |
|
768 testsearcher->ReleaseSearcher(); |
|
769 testsearcher->tearDown(); |
|
770 delete testsearcher; |
|
771 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
772 return err; |
|
773 } |
|
774 // ----------------------------------------------------------------------------- |
|
775 // Ccpixsearchertest::TestDefineVolumeWorksNonEmptyPathL |
|
776 // ----------------------------------------------------------------------------- |
|
777 // |
|
778 TInt Ccpixsearchertest::TestDefineVolumeWorksNonEmptyPathL( CStifItemParser& /*aItem*/ ) |
|
779 { |
|
780 _LIT( KTestFormBaseAppClassNoError, "TestDefineVolumeWorksNonEmptyPathL: No Error" ); |
|
781 CTestSearcher* testsearcher = new CTestSearcher(); |
|
782 testsearcher->initialsetUp(); |
|
783 TRAPD ( err , testsearcher->testDefineVolumeWorksNonEmptyPath() ); |
|
784 testsearcher->tearDown(); |
|
785 delete testsearcher; |
|
786 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
787 return err; |
|
788 } |
|
789 // ----------------------------------------------------------------------------- |
|
790 // Ccpixsearchertest::TestDefineVolumeWorksWithEmptyPathL |
|
791 // ----------------------------------------------------------------------------- |
|
792 // |
|
793 TInt Ccpixsearchertest::TestDefineVolumeWorksWithEmptyPathL( CStifItemParser& /*aItem*/ ) |
|
794 { |
|
795 _LIT( KTestFormBaseAppClassNoError, "TestDefineVolumeWorksWithEmptyPathL: No Error" ); |
|
796 CTestSearcher* testsearcher = new CTestSearcher(); |
|
797 testsearcher->initialsetUp(); |
|
798 TRAPD ( err , testsearcher->testDefineVolumeWorksWithEmptyPath() ); |
|
799 testsearcher->tearDown(); |
|
800 delete testsearcher; |
|
801 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
802 return err; |
|
803 } |
|
804 // ----------------------------------------------------------------------------- |
|
805 // Ccpixsearchertest::TestDefineVolumeErrorScenariosL |
|
806 // ----------------------------------------------------------------------------- |
|
807 // |
|
808 TInt Ccpixsearchertest::TestDefineVolumeErrorScenariosL( CStifItemParser& /*aItem*/ ) |
|
809 { |
|
810 _LIT( KTestFormBaseAppClassNoError, "TestDefineVolumeErrorScenariosL: No Error" ); |
|
811 CTestSearcher* testsearcher = new CTestSearcher(); |
|
812 testsearcher->initialsetUp(); |
|
813 TRAPD ( err , testsearcher->testDefineVolumeErrorScenarios() ); |
|
814 testsearcher->tearDown(); |
|
815 delete testsearcher; |
|
816 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
817 return err; |
|
818 } |
|
819 // ----------------------------------------------------------------------------- |
|
820 // Ccpixsearchertest::TestSearchCancellationL |
|
821 // ----------------------------------------------------------------------------- |
|
822 // |
|
823 TInt Ccpixsearchertest::TestSearchCancellationL( CStifItemParser& /*aItem*/ ) |
|
824 { |
|
825 _LIT( KTestFormBaseAppClassNoError, "TestSearchCancellationL: No Error" ); |
|
826 CTestSearcher* testsearcher = new CTestSearcher(); |
|
827 testsearcher->initialsetUp(); |
|
828 testsearcher->createandinitindexer(); |
|
829 testsearcher->createsearcher(); |
|
830 testsearcher->harvesttestcontent( 8 ); |
|
831 testsearcher->InitAsyncComponents(); |
|
832 TRAPD ( err , testsearcher->testSearchCancellation() ); |
|
833 testsearcher->ReleaseIndexer(); |
|
834 testsearcher->ReleaseSearcher(); |
|
835 testsearcher->ReleaseAsyncComponents(); |
|
836 testsearcher->tearDown(); |
|
837 delete testsearcher; |
|
838 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
839 return err; |
|
840 } |
|
841 // ----------------------------------------------------------------------------- |
|
842 // Ccpixsearchertest::TestSearchAsynchronousL |
|
843 // ----------------------------------------------------------------------------- |
|
844 // |
|
845 TInt Ccpixsearchertest::TestSearchAsynchronousL( CStifItemParser& /*aItem*/ ) |
|
846 { |
|
847 _LIT( KTestFormBaseAppClassNoError, "TestSearchAsynchronousL: No Error" ); |
|
848 CTestSearcher* testsearcher = new CTestSearcher(); |
|
849 testsearcher->initialsetUp(); |
|
850 testsearcher->createandinitindexer(); |
|
851 testsearcher->createsearcher(); |
|
852 testsearcher->harvesttestcontent( 4 ); |
|
853 testsearcher->InitAsyncComponents(); |
|
854 TRAPD ( err , testsearcher->testSearchAsynchronous() ); |
|
855 testsearcher->ReleaseIndexer(); |
|
856 testsearcher->ReleaseSearcher(); |
|
857 testsearcher->ReleaseAsyncComponents(); |
|
858 testsearcher->tearDown(); |
|
859 delete testsearcher; |
|
860 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
861 return err; |
|
862 } |
|
863 // ----------------------------------------------------------------------------- |
|
864 // Ccpixsearchertest::TestSearchLeavesIfNotCancelledL |
|
865 // ----------------------------------------------------------------------------- |
|
866 // |
|
867 TInt Ccpixsearchertest::TestSearchLeavesIfNotCancelledL( CStifItemParser& /*aItem*/ ) |
|
868 { |
|
869 _LIT( KTestFormBaseAppClassNoError, "TestSearchLeavesIfNotCancelledL: No Error" ); |
|
870 CTestSearcher* testsearcher = new CTestSearcher(); |
|
871 testsearcher->initialsetUp(); |
|
872 testsearcher->createandinitindexer(); |
|
873 testsearcher->createsearcher(); |
|
874 testsearcher->harvesttestcontent( 4 ); |
|
875 testsearcher->InitAsyncComponents(); |
|
876 TRAPD ( err , testsearcher->testSearchLeavesIfNotCancelled() ); |
|
877 testsearcher->ReleaseIndexer(); |
|
878 testsearcher->ReleaseSearcher(); |
|
879 testsearcher->ReleaseAsyncComponents(); |
|
880 testsearcher->tearDown(); |
|
881 delete testsearcher; |
|
882 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
883 return err; |
|
884 } |
|
885 // ----------------------------------------------------------------------------- |
|
886 // Ccpixsearchertest::TestOpenIndexDbL |
|
887 // ----------------------------------------------------------------------------- |
|
888 // |
|
889 TInt Ccpixsearchertest::TestOpenIndexDbL( CStifItemParser& /*aItem*/ ) |
|
890 { |
|
891 _LIT( KTestFormBaseAppClassNoError, "TestOpenIndexDbL: No Error" ); |
|
892 CTestSearcher* testsearcher = new CTestSearcher(); |
|
893 testsearcher->initialsetUp(); |
|
894 testsearcher->createandinitindexer(); |
|
895 testsearcher->harvesttestcontent( 4 ); |
|
896 testsearcher->InitAsyncComponents(); |
|
897 TRAPD ( err , testsearcher->testOpenIndexDb() ); |
|
898 testsearcher->ReleaseIndexer(); |
|
899 testsearcher->ReleaseAsyncComponents(); |
|
900 testsearcher->tearDown(); |
|
901 delete testsearcher; |
|
902 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
903 return err; |
|
904 } |
|
905 // ----------------------------------------------------------------------------- |
|
906 // Ccpixsearchertest::TestDeleteIndexDbWhileSearchingL |
|
907 // ----------------------------------------------------------------------------- |
|
908 // |
|
909 TInt Ccpixsearchertest::TestDeleteIndexDbWhileSearchingL( CStifItemParser& /*aItem*/ ) |
|
910 { |
|
911 _LIT( KTestFormBaseAppClassNoError, "TestDeleteIndexDbWhileSearchingL: No Error" ); |
|
912 CTestSearcher* testsearcher = new CTestSearcher(); |
|
913 testsearcher->initialsetUp(); |
|
914 testsearcher->InitAsyncComponents(); |
|
915 TRAPD ( err , testsearcher->testDeleteIndexDbWhileSearching() ); |
|
916 testsearcher->ReleaseAsyncComponents(); |
|
917 testsearcher->tearDown(); |
|
918 delete testsearcher; |
|
919 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
920 return err; |
|
921 } |
|
922 // ----------------------------------------------------------------------------- |
|
923 // Ccpixsearchertest::TestGetDocumentAsyncL |
|
924 // ----------------------------------------------------------------------------- |
|
925 // |
|
926 TInt Ccpixsearchertest::TestGetDocumentAsyncL( CStifItemParser& /*aItem*/ ) |
|
927 { |
|
928 _LIT( KTestFormBaseAppClassNoError, "TestGetDocumentAsyncL: No Error" ); |
|
929 CTestSearcher* testsearcher = new CTestSearcher(); |
|
930 testsearcher->initialsetUp(); |
|
931 testsearcher->createandinitindexer(); |
|
932 testsearcher->createsearcher(); |
|
933 testsearcher->harvesttestcontent( 4 ); |
|
934 testsearcher->InitAsyncComponents(); |
|
935 TRAPD ( err , testsearcher->testGetDocumentAsync() ); |
|
936 testsearcher->ReleaseIndexer(); |
|
937 testsearcher->ReleaseSearcher(); |
|
938 testsearcher->ReleaseAsyncComponents(); |
|
939 testsearcher->tearDown(); |
|
940 delete testsearcher; |
|
941 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
942 return err; |
|
943 } |
|
944 // ----------------------------------------------------------------------------- |
|
945 // Ccpixsearchertest::TestGetInvalidDocumentAsyncL |
|
946 // ----------------------------------------------------------------------------- |
|
947 // |
|
948 TInt Ccpixsearchertest::TestGetInvalidDocumentAsyncL( CStifItemParser& /*aItem*/ ) |
|
949 { |
|
950 _LIT( KTestFormBaseAppClassNoError, "TestGetInvalidDocumentAsyncL: No Error" ); |
|
951 CTestSearcher* testsearcher = new CTestSearcher(); |
|
952 testsearcher->initialsetUp(); |
|
953 testsearcher->createandinitindexer(); |
|
954 testsearcher->createsearcher(); |
|
955 testsearcher->harvesttestcontent( 4 ); |
|
956 testsearcher->InitAsyncComponents(); |
|
957 TRAPD ( err , testsearcher->testGetInvalidDocumentAsync() ); |
|
958 testsearcher->ReleaseIndexer(); |
|
959 testsearcher->ReleaseSearcher(); |
|
960 testsearcher->ReleaseAsyncComponents(); |
|
961 testsearcher->tearDown(); |
|
962 delete testsearcher; |
|
963 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
964 return err; |
|
965 } |
|
966 // ----------------------------------------------------------------------------- |
|
967 // Ccpixsearchertest::TestExerptLengthL |
|
968 // ----------------------------------------------------------------------------- |
|
969 // |
|
970 TInt Ccpixsearchertest::TestExerptLengthL( CStifItemParser& /*aItem*/ ) |
|
971 { |
|
972 _LIT( KTestFormBaseAppClassNoError, "TestExerptLengthL: No Error" ); |
|
729 TInt err = KErrNone; |
973 TInt err = KErrNone; |
730 _LIT( KTestFormBaseAppClassNoError, "TestKnownTermL: No Error" ); |
974 CTestSearcher* testsearcher = new CTestSearcher(); |
731 CTestSearcher* testsearcher = new CTestSearcher(); |
975 testsearcher->initialsetUp(); |
732 testsearcher->setUp(); |
976 testsearcher->createandinitindexer(); |
733 err = testsearcher->testKnownTermTestsL(); |
977 testsearcher->createsearcher(); |
734 testsearcher->tearDown(); |
978 err = testsearcher->testEcerptLenth(); |
735 delete testsearcher; |
979 testsearcher->ReleaseSearcher(); |
736 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
980 testsearcher->ReleaseIndexer(); |
737 return err; |
981 testsearcher->tearDown(); |
738 } |
982 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
739 // ----------------------------------------------------------------------------- |
983 return err; |
740 // Ccpixsearchertest::TestWildcardTermL |
|
741 // ----------------------------------------------------------------------------- |
|
742 // |
|
743 TInt Ccpixsearchertest::TestWildcardTermL( CStifItemParser& /*aItem*/ ) |
|
744 { |
|
745 _LIT( KTestFormBaseAppClassNoError, "TestWildcardTermL: No Error" ); |
|
746 CTestSearcher* testsearcher = new CTestSearcher(); |
|
747 testsearcher->setUp(); |
|
748 TRAPD ( err , testsearcher->testWildcardTermTests() ); |
|
749 testsearcher->tearDown(); |
|
750 delete testsearcher; |
|
751 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
752 return err; |
|
753 } |
|
754 // ----------------------------------------------------------------------------- |
|
755 // Ccpixsearchertest::TestDefineVolumeWorksNonEmptyPathL |
|
756 // ----------------------------------------------------------------------------- |
|
757 // |
|
758 TInt Ccpixsearchertest::TestDefineVolumeWorksNonEmptyPathL( CStifItemParser& /*aItem*/ ) |
|
759 { |
|
760 _LIT( KTestFormBaseAppClassNoError, "TestDefineVolumeWorksNonEmptyPathL: No Error" ); |
|
761 CTestSearcher* testsearcher = new CTestSearcher(); |
|
762 testsearcher->setUp(); |
|
763 TRAPD ( err , testsearcher->testDefineVolumeWorksNonEmptyPath() ); |
|
764 testsearcher->tearDown(); |
|
765 delete testsearcher; |
|
766 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
767 return err; |
|
768 } |
|
769 // ----------------------------------------------------------------------------- |
|
770 // Ccpixsearchertest::TestDefineVolumeWorksWithEmptyPathL |
|
771 // ----------------------------------------------------------------------------- |
|
772 // |
|
773 TInt Ccpixsearchertest::TestDefineVolumeWorksWithEmptyPathL( CStifItemParser& /*aItem*/ ) |
|
774 { |
|
775 _LIT( KTestFormBaseAppClassNoError, "TestDefineVolumeWorksWithEmptyPathL: No Error" ); |
|
776 CTestSearcher* testsearcher = new CTestSearcher(); |
|
777 testsearcher->setUp(); |
|
778 TRAPD ( err , testsearcher->testDefineVolumeWorksWithEmptyPath() ); |
|
779 testsearcher->tearDown(); |
|
780 delete testsearcher; |
|
781 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
782 return err; |
|
783 } |
|
784 // ----------------------------------------------------------------------------- |
|
785 // Ccpixsearchertest::TestDefineVolumeErrorScenariosL |
|
786 // ----------------------------------------------------------------------------- |
|
787 // |
|
788 TInt Ccpixsearchertest::TestDefineVolumeErrorScenariosL( CStifItemParser& /*aItem*/ ) |
|
789 { |
|
790 _LIT( KTestFormBaseAppClassNoError, "TestDefineVolumeErrorScenariosL: No Error" ); |
|
791 CTestSearcher* testsearcher = new CTestSearcher(); |
|
792 testsearcher->setUp(); |
|
793 TRAPD ( err , testsearcher->testDefineVolumeErrorScenarios() ); |
|
794 testsearcher->tearDown(); |
|
795 delete testsearcher; |
|
796 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
797 return err; |
|
798 } |
|
799 // ----------------------------------------------------------------------------- |
|
800 // Ccpixsearchertest::TestSearchCancellationL |
|
801 // ----------------------------------------------------------------------------- |
|
802 // |
|
803 TInt Ccpixsearchertest::TestSearchCancellationL( CStifItemParser& /*aItem*/ ) |
|
804 { |
|
805 _LIT( KTestFormBaseAppClassNoError, "TestSearchCancellationL: No Error" ); |
|
806 CTestSearcher* testsearcher = new CTestSearcher(); |
|
807 testsearcher->setUp(); |
|
808 TRAPD ( err , testsearcher->testSearchCancellation() ); |
|
809 testsearcher->tearDown(); |
|
810 delete testsearcher; |
|
811 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
812 return err; |
|
813 } |
|
814 // ----------------------------------------------------------------------------- |
|
815 // Ccpixsearchertest::TestSearchAsynchronousL |
|
816 // ----------------------------------------------------------------------------- |
|
817 // |
|
818 TInt Ccpixsearchertest::TestSearchAsynchronousL( CStifItemParser& /*aItem*/ ) |
|
819 { |
|
820 _LIT( KTestFormBaseAppClassNoError, "TestSearchAsynchronousL: No Error" ); |
|
821 CTestSearcher* testsearcher = new CTestSearcher(); |
|
822 testsearcher->setUp(); |
|
823 TRAPD ( err , testsearcher->testSearchAsynchronous() ); |
|
824 testsearcher->tearDown(); |
|
825 delete testsearcher; |
|
826 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
827 return err; |
|
828 } |
|
829 // ----------------------------------------------------------------------------- |
|
830 // Ccpixsearchertest::TestSearchLeavesIfNotCancelledL |
|
831 // ----------------------------------------------------------------------------- |
|
832 // |
|
833 TInt Ccpixsearchertest::TestSearchLeavesIfNotCancelledL( CStifItemParser& /*aItem*/ ) |
|
834 { |
|
835 _LIT( KTestFormBaseAppClassNoError, "TestSearchLeavesIfNotCancelledL: No Error" ); |
|
836 CTestSearcher* testsearcher = new CTestSearcher(); |
|
837 testsearcher->setUp(); |
|
838 TRAPD ( err , testsearcher->testSearchLeavesIfNotCancelled() ); |
|
839 testsearcher->tearDown(); |
|
840 delete testsearcher; |
|
841 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
842 return err; |
|
843 } |
|
844 // ----------------------------------------------------------------------------- |
|
845 // Ccpixsearchertest::TestOpenIndexDbL |
|
846 // ----------------------------------------------------------------------------- |
|
847 // |
|
848 TInt Ccpixsearchertest::TestOpenIndexDbL( CStifItemParser& /*aItem*/ ) |
|
849 { |
|
850 _LIT( KTestFormBaseAppClassNoError, "TestOpenIndexDbL: No Error" ); |
|
851 CTestSearcher* testsearcher = new CTestSearcher(); |
|
852 testsearcher->setUp(); |
|
853 TRAPD ( err , testsearcher->testOpenIndexDb() ); |
|
854 testsearcher->tearDown(); |
|
855 delete testsearcher; |
|
856 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
857 return err; |
|
858 } |
|
859 // ----------------------------------------------------------------------------- |
|
860 // Ccpixsearchertest::TestDeleteIndexDbWhileSearchingL |
|
861 // ----------------------------------------------------------------------------- |
|
862 // |
|
863 TInt Ccpixsearchertest::TestDeleteIndexDbWhileSearchingL( CStifItemParser& /*aItem*/ ) |
|
864 { |
|
865 _LIT( KTestFormBaseAppClassNoError, "TestDeleteIndexDbWhileSearchingL: No Error" ); |
|
866 CTestSearcher* testsearcher = new CTestSearcher(); |
|
867 testsearcher->setUp(); |
|
868 TRAPD ( err , testsearcher->testDeleteIndexDbWhileSearching() ); |
|
869 testsearcher->tearDown(); |
|
870 delete testsearcher; |
|
871 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
872 return err; |
|
873 } |
|
874 // ----------------------------------------------------------------------------- |
|
875 // Ccpixsearchertest::TestGetDocumentAsyncL |
|
876 // ----------------------------------------------------------------------------- |
|
877 // |
|
878 TInt Ccpixsearchertest::TestGetDocumentAsyncL( CStifItemParser& /*aItem*/ ) |
|
879 { |
|
880 _LIT( KTestFormBaseAppClassNoError, "TestGetDocumentAsyncL: No Error" ); |
|
881 CTestSearcher* testsearcher = new CTestSearcher(); |
|
882 testsearcher->setUp(); |
|
883 TRAPD ( err , testsearcher->testGetDocumentAsync() ); |
|
884 testsearcher->tearDown(); |
|
885 delete testsearcher; |
|
886 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
887 return err; |
|
888 } |
|
889 // ----------------------------------------------------------------------------- |
|
890 // Ccpixsearchertest::TestGetInvalidDocumentAsyncL |
|
891 // ----------------------------------------------------------------------------- |
|
892 // |
|
893 TInt Ccpixsearchertest::TestGetInvalidDocumentAsyncL( CStifItemParser& /*aItem*/ ) |
|
894 { |
|
895 _LIT( KTestFormBaseAppClassNoError, "TestGetInvalidDocumentAsyncL: No Error" ); |
|
896 CTestSearcher* testsearcher = new CTestSearcher(); |
|
897 testsearcher->setUp(); |
|
898 TRAPD ( err , testsearcher->testGetInvalidDocumentAsync() ); |
|
899 testsearcher->tearDown(); |
|
900 delete testsearcher; |
|
901 doLog( iLog, err, KTestFormBaseAppClassNoError ); |
|
902 return err; |
|
903 } |
984 } |
904 // ----------------------------------------------------------------------------- |
985 // ----------------------------------------------------------------------------- |
905 // Ccpixsearchertest::?member_function |
986 // Ccpixsearchertest::?member_function |
906 // ?implementation_description |
987 // ?implementation_description |
907 // (other items were commented in a header). |
988 // (other items were commented in a header). |