/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include <wchar.h>
#include <stddef.h>
#include <iostream>
#include "cpixfstools.h"
#include "itk.h"
#include "cpixidxdb.h"
#include "config.h"
#include "testutils.h"
#include "testcorpus.h"
#include "setupsentry.h"
#include "std_log_result.h"
class PlainMVContext : public Itk::ITestContext
{
cpix_Analyzer * analyzer_;
cpix_QueryParser * queryParser_;
const MVFTest * mvfTests_;
public:
PlainMVContext(const MVFTest * mvfTests)
: analyzer_(NULL),
queryParser_(NULL),
mvfTests_(mvfTests)
{
;
}
virtual void setup() throw (Itk::PanicExc)
{
SetupSentry
ss(*this);
cpix_Result
result;
cpix_IdxDb_dbgScrapAll(&result);
analyzer_ = cpix_CreateSimpleAnalyzer(&result);
if (analyzer_ == NULL)
{
ITK_PANIC("Could not create analyzer");
}
queryParser_ = cpix_QueryParser_create(&result,
CONTENTS_FIELD,
analyzer_);
if (queryParser_ == NULL)
{
ITK_PANIC("Could not create query parser");
}
ss.setupComplete();
}
virtual void tearDown() throw ()
{
cleanup();
}
virtual ~PlainMVContext()
{
cleanup();
}
void testAddFiles(Itk::TestMgr * testMgr)
{
const MVFTest
* mvfTest = mvfTests_;
for (; mvfTest->qualifiedBaseAppClass_ != NULL; ++mvfTest)
{
using namespace std;
printf("Creating volume %s ...\n",
mvfTest->qualifiedBaseAppClass_);
{
auto_ptr<VolumeFileIdxUtil>
util(new VolumeFileIdxUtil(mvfTest));
util->init();
util->indexFile(mvfTest->textFilePath_,
analyzer_,
testMgr);
}
printf("... created volume %s\n",
mvfTest->qualifiedBaseAppClass_);
}
}
void testSearchAllFiles(Itk::TestMgr * testMgr)
{
cpix_Result
result;
cpix_IdxSearcher
* searcher = cpix_IdxSearcher_openDb(&result,
FILEAPPCLASS);
ITK_ASSERT(testMgr,
cpix_Succeeded(&result),
"Failed to search multi volume");
cpix_Query
* query = cpix_QueryParser_parse(queryParser_,
L"happ*");
if (cpix_Failed(queryParser_))
{
cpix_IdxSearcher_releaseDb(searcher);
}
ITK_ASSERT(testMgr,
cpix_Succeeded(queryParser_),
"Could not parse 'happ*'");
cpix_Hits
* hits = cpix_IdxSearcher_search(searcher,
query);
if (cpix_Failed(searcher))
{
cpix_IdxSearcher_releaseDb(searcher);
cpix_Query_destroy(query);
}
ITK_ASSERT(testMgr,
cpix_Succeeded(searcher),
"Could not perform (multi)search");
PrintHits(hits,
testMgr);
cpix_Hits_destroy(hits);
cpix_IdxSearcher_releaseDb(searcher);
cpix_Query_destroy(query);
}
private:
void cleanup()
{
cpix_Analyzer_destroy(analyzer_);
analyzer_ = NULL;
cpix_QueryParser_destroy(queryParser_);
queryParser_ = NULL;
}
};
Itk::TesterBase * CreateMVPlainTests(const MVFTest * mvfTests)
{
using namespace Itk;
PlainMVContext
* context = new PlainMVContext(mvfTests);
ContextTester
* contextTester = new ContextTester("plain",
context);
#define TEST "adding"
contextTester->add(TEST,
context,
&PlainMVContext::testAddFiles,
TEST);
#undef TEST
#define TEST "searchingAll"
contextTester->add(TEST,
context,
&PlainMVContext::testSearchAllFiles,
TEST);
#undef TEST
// ... add more
return contextTester;
}
class DynMVContext : public Itk::ITestContext
{
cpix_Analyzer * analyzer_;
cpix_Query * query_;
cpix_IdxSearcher * searcher_;
cpix_QueryParser * queryParser_;
const MVFTest * mvfTests_;
public:
DynMVContext(const MVFTest * mvfTests)
: analyzer_(NULL),
query_(NULL),
searcher_(NULL),
queryParser_(NULL),
mvfTests_(mvfTests)
{
;
}
virtual void setup() throw (Itk::PanicExc)
{
SetupSentry
ss(*this);
cpix_Result
result;
cpix_IdxDb_dbgScrapAll(&result);
analyzer_ = cpix_CreateSimpleAnalyzer(&result);
if (analyzer_ == NULL)
{
ITK_PANIC("Could not create analyzer");
}
queryParser_ = cpix_QueryParser_create(&result,
CONTENTS_FIELD,
analyzer_);
if (queryParser_ == NULL)
{
ITK_PANIC("Could not create query parser");
}
query_ = cpix_QueryParser_parse(queryParser_,
L"happ*");
if (cpix_Failed(queryParser_))
{
ITK_PANIC("Could not create query parser");
}
ss.setupComplete();
}
virtual void tearDown() throw()
{
cleanup();
}
virtual ~DynMVContext()
{
cleanup();
}
void testCreatingVolumes(Itk::TestMgr * testMgr)
{
const MVFTest
* mvfTest = mvfTests_;
for (; mvfTest->qualifiedBaseAppClass_ != NULL; ++mvfTest)
{
using namespace std;
printf("Creating volume %s ...\n",
mvfTest->qualifiedBaseAppClass_);
{
auto_ptr<VolumeFileIdxUtil>
util(new VolumeFileIdxUtil(mvfTest));
util->init();
util->indexFile(mvfTest->textFilePath_,
analyzer_,
testMgr);
util->flush();
}
printf("... created volume %s\n",
mvfTest->qualifiedBaseAppClass_);
// after the first volume has been defined, there is
// something to search on
createSearcherIfNecessary(testMgr);
searchAll(testMgr);
}
}
void testUnmountingVolumes(Itk::TestMgr * testMgr)
{
const MVFTest
* mvfTest = mvfTests_;
for (; mvfTest->qualifiedBaseAppClass_ != NULL; ++mvfTest)
{
using namespace std;
searchAll(testMgr);
printf("Undefining (unmounting) volume %s ...\n",
mvfTest->qualifiedBaseAppClass_);
cpix_IdxDb_undefineVolume(mvfTest->qualifiedBaseAppClass_);
printf("... undefined (unmounted) volume %s.\n",
mvfTest->qualifiedBaseAppClass_);
}
searchAll(testMgr);
}
void testMountingVolumes(Itk::TestMgr * testMgr)
{
const MVFTest
* mvfTest = mvfTests_;
for (; mvfTest->qualifiedBaseAppClass_ != NULL; ++mvfTest)
{
using namespace std;
searchAll(testMgr);
printf("Defining (mounting) volume %s ...\n",
mvfTest->qualifiedBaseAppClass_);
cpix_Result
result;
cpix_IdxDb_defineVolume(&result,
mvfTest->qualifiedBaseAppClass_,
mvfTest->idxDbPath_);
ITK_ASSERT(testMgr,
cpix_Succeeded(&result),
"Could not define (mount) volume %s",
mvfTest->qualifiedBaseAppClass_);
printf("... defined (mounted) volume %s.\n",
mvfTest->qualifiedBaseAppClass_);
}
searchAll(testMgr);
}
private:
void createSearcherIfNecessary(Itk::TestMgr * testMgr)
{
if (searcher_ == NULL)
{
cpix_Result
result;
searcher_ = cpix_IdxSearcher_openDb(&result,
FILEAPPCLASS);
ITK_ASSERT(testMgr,
cpix_Succeeded(&result),
"Could not create idx searcher");
}
}
void searchAll(Itk::TestMgr * testMgr)
{
printf("\nAnd now searching all 'root file'!\n");
cpix_Hits
* hits = cpix_IdxSearcher_search(searcher_,
query_);
if (cpix_Failed(searcher_))
{
cpix_IdxSearcher_releaseDb(searcher_);
}
ITK_ASSERT(testMgr,
cpix_Succeeded(searcher_),
"Could not perform (multi)search");
PrintHits(hits,
testMgr);
cpix_Hits_destroy(hits);
}
void cleanup()
{
cpix_Analyzer_destroy(analyzer_);
analyzer_ = NULL;
cpix_Query_destroy(query_);
query_ = NULL;
cpix_IdxSearcher_releaseDb(searcher_);
searcher_ = NULL;
cpix_QueryParser_destroy(queryParser_);
queryParser_ = NULL;
}
};
Itk::TesterBase * CreateMVDynTests(const MVFTest * mvfTests)
{
using namespace Itk;
DynMVContext
* context = new DynMVContext(mvfTests);
ContextTester
* contextTester = new ContextTester("dyn",
context);
#define TEST "creatingVols"
contextTester->add(TEST,
context,
&DynMVContext::testCreatingVolumes,
TEST);
#undef TEST
#define TEST "unmountingVols"
contextTester->add(TEST,
context,
&DynMVContext::testUnmountingVolumes,
TEST);
#undef TEST
#define TEST "mountingVols"
contextTester->add(TEST,
context,
&DynMVContext::testMountingVolumes,
TEST);
#undef TEST
// ... add more
return contextTester;
}
struct MVFTest MVFTests[] = {
{
FILE_TEST_CORPUS_PATH "\\en\\1.txt",
"@c:root file",
CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\c",
},
{
FILE_TEST_CORPUS_PATH "\\en\\2.txt",
"@d:root file",
CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\d",
},
{
FILE_TEST_CORPUS_PATH "\\en\\3.txt",
"@e:root file",
CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\e",
},
{
FILE_TEST_CORPUS_PATH "\\en\\4.txt",
"@f:root file",
CPIX_TEST_INDEVICE_INDEXDB_PHMEM CPIX_FILE_IDXDB "_\\f",
},
{
NULL,
NULL,
NULL
},
};
Itk::TesterBase * CreateMultiVolumeTests()
{
using namespace Itk;
SuiteTester
* multiVolume = new SuiteTester("multivolume");
multiVolume->add(CreateMVPlainTests(MVFTests));
multiVolume->add(CreateMVDynTests(MVFTests));
// TODO add more tests to suite
return multiVolume;
}