FCL/sf/mw/searchsrv: comparison searchengine/cpix/tsrc/cpixunittest/src/whiteboxtests.cpp

equal deleted inserted replaced

-:6c1a2771f4b7
+:ae3f1779f6da
 #include "iqrytype.h"
 #include "cpixexc.h"
 #include "cpixhits.h"
 #include "idxdbdelta.h"
+#include "std_log_result.h"
 void TestBaseAppClassCollision(Itk::TestMgr * testMgr)
 {
 cpix_Result
 result;
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 cpix_IdxDb_defineVolume(&result,
 SMS_QBASEAPPCLASS,
 NULL);
+if(!cpix_Succeeded(&result))
+assert_failed = 1;
 ITK_ASSERT(testMgr,
 cpix_Succeeded(&result),
 "Definition of volume (%s, %s) failed.",
 SMS_QBASEAPPCLASS,
 "<default>");
 cpix_IdxDb_defineVolume(&result,
 SMS_QBASEAPPCLASS,
 NULL);
+if(!cpix_Succeeded(&result))
+assert_failed = 1;
 ITK_ASSERT(testMgr,
 cpix_Succeeded(&result),
 "Re-definition of identical volume (%s, %s) failed.",
 SMS_QBASEAPPCLASS,
 "<default>");
 * dummyPath = "\\dummy\\path";
 cpix_IdxDb_defineVolume(&result,
 SMS_QBASEAPPCLASS,
 dummyPath);
+if(!cpix_Succeeded(&result))
+assert_failed = 1;
 ITK_ASSERT(testMgr,
 cpix_Failed(&result),
 "Volume (%s, %s) definition should have failed.",
 SMS_QBASEAPPCLASS,
 dummyPath);
 cpix_IdxDb_undefineVolume("@0:root foo bar");
+testResultXml(xml_file);
 }
 #define DUMMY_QBASEAPPCLASS "@0:root dummy"
 #define DUMMY2_QBASEAPPCLASS "@0:root dummy2"
 void TestIdxDbPathCollision(Itk::TestMgr * testMgr)
 {
 cpix_Result
 result;
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 cpix_IdxDb_defineVolume(&result,
 DUMMY_QBASEAPPCLASS,
 DUMMY_IDXDBPATH);
+if(!cpix_Succeeded(&result))
+assert_failed = 1;
 ITK_ASSERT(testMgr,
 cpix_Succeeded(&result),
 "Defining volume %s, %s failed.",
 DUMMY_QBASEAPPCLASS,
 DUMMY_IDXDBPATH);
 cpix_IdxDb_defineVolume(&result,
 DUMMY2_QBASEAPPCLASS,
 DUMMY_IDXDBPATH);
+if(!cpix_Succeeded(&result))
+assert_failed = 1;
 ITK_ASSERT(testMgr,
 cpix_Failed(&result),
 "Defining volume %s, %s should have failed.",
 DUMMY2_QBASEAPPCLASS,
 DUMMY_IDXDBPATH);
+testResultXml(xml_file);
 }
 void TestScrapAll(Itk::TestMgr * testMgr)
 {
 cpix_Result
 result;
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 cpix_IdxDb_defineVolume(&result,
 SMS_QBASEAPPCLASS,
 NULL);
 if (cpix_Succeeded(&result))
 SMS_QBASEAPPCLASS,
 cpix_IDX_CREATE);
 if (cpix_Succeeded(&result))
 {
+assert_failed = 1;
 cpix_IdxDb_releaseDb(idxDb);
 }
 }
 ITK_ASSERT(testMgr,
 if (cpix_Succeeded(&result))
 {
 cpix_IdxDb_releaseDb(idxDb);
 }
+else
+{
+assert_failed = 1;
+}
 ITK_ASSERT(testMgr,
 cpix_Failed(&result),
 "Opening IdxDb(%s) should have failed now.",
 SMS_QBASEAPPCLASS);
+testResultXml(xml_file);
 }
 const wchar_t * QryStrings[] = {
 // should pass:
 void TestUnifiedSearchParse(Itk::TestMgr * )
 {
 using namespace std;
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 printf("Whitebox testing parsing of unified search syntax\n\n");
 const wchar_t
 ** p = QryStrings;
 printf("\to inner qry: '%S'\n",
 qc.innerQryStr_.c_str());
 } catch (CpixExc & cpixExc) {
+assert_failed = 1;
 printf("Failed to parse: %S\n",
 cpixExc.wWhat());
 } catch (...) {
+assert_failed = 1;
 printf("Failed t parse: for unknown reasons\n");
 }
 }
+testResultXml(xml_file);
 }
 class PageContext : public Itk::ITestContext
 {
 }
 void testAddSome(Itk::TestMgr  * mgr)
 {
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 std::wstring
 firstBody,
 secondBody;
 for (int i = 0; i < expectedHitCount_; ++i)
 ITK_DBGMSG(mgr,
 ".");
 }
 }
 util_->flush();
+testResultXml(xml_file);
 }
 void testSearchPages(Itk::TestMgr * mgr)
 {
 cpix_Hits
 * hits = cpix_IdxDb_search(util_->idxDb(),
 query_);
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 if (cpix_Failed(util_->idxDb()))
 {
 ITK_EXPECT(mgr,
 false,
 "Failed to search index");
 cpix_ClearError(util_->idxDb());
+assert_failed = 1;
 }
 else
 {
 int32_t
 hitsLength = cpix_Hits_length(hits);
 ITK_EXPECT(mgr,
 expectedHitCount_ == hitsLength,
 "Did not get expected hitcounts (%d), but %d",
 expectedHitCount_,
 hitsLength);
+if(expectedHitCount_ != hitsLength)
+{
+assert_failed = 1;
+}
 printf("Got %d hits\n",
 hitsLength);
 search(hits,
 mgr);
 }
 cpix_Hits_destroy( hits );
+testResultXml(xml_file);
 }
 private:
 //
 void testStartStage(Itk::TestMgr * mgr)
 {
 using namespace lucene::index;
 using namespace std;
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 printf("Start state of index:\n");
 {
 auto_ptr<IndexReader>
 reader(IndexReader::open(deltaIdxDbPath_.c_str()));
 if (haveDels_)
 {
 if (!reader_.isOpen())
 {
+assert_failed = 1;
 ITK_PANIC("Reader should be open");
 }
 for (size_t i = 0;
 i < sizeof(DeltaSmsesToDelete) / sizeof(wchar_t*);
 result = reader_.getReader()->deleteDocuments(term.get());
 ITK_EXPECT(mgr,
 result == 1,
 "Should have deleted exactly one doc");
+if(result != 0)
+assert_failed = 1;
 printf("... deleted doc %S\n",
 DeltaSmsesToDelete[i]);
 }
 }
+testResultXml(xml_file);
 }
 struct TestCommitStageExc
 void testCommitToDisk(Itk::TestMgr * mgr)
 {
 using namespace lucene::search;
 using namespace Cpix::Impl;
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 // The TestCommitStageAction instance we give is to emulate
 // interrupting the committing-to-disk process at different
 // stages, and see if we can recover whatever information can
 // be from whatever has been committed to disk up to that
 // point. The interrupt is done by throwing a test exception
 ITK_EXPECT(mgr,
 Cpt::directoryexists(deltaIdxDbPath.c_str()),
 "Complete, committed, updated idx dir should exist (%s): %s",
 test_.c_str(),
 deltaIdxDbPath.c_str());
+if(!Cpt::directoryexists(deltaIdxDbPath.c_str()))
+{
+assert_failed = 1;
+}
 }
 }
 else
 {
+assert_failed = 1;
 ITK_EXPECT(mgr,
 false,
 "Should have been interrupted at stage %d",
 targetCommitStage_);
 }
 }
 catch (TestCommitStageExc & exc)
 {
+assert_failed = 1;
 if (exc.commitStage_ == targetCommitStage_)
 {
 properlyInterrupted = true;
 }
 }
 ITK_EXPECT(mgr,
 (insertBuf_ == NULL
 || insertBuf_->isEmpty()
 || targetCommitStage_ < CS_IBUF_COMMITTING),
 "Expected the (test) insert buffer to be closed");
+if(!properlyInterrupted || (haveReader_ || reader_.isOpen() ) ||  !((insertBuf_ == NULL
+|| insertBuf_->isEmpty() || targetCommitStage_ < CS_IBUF_COMMITTING)))
+{
+assert_failed = 1;
+}
+testResultXml(xml_file);
 }
 void testRecoveredStage(Itk::TestMgr * )
 {
+char *xml_file = (char*)__FUNCTION__;
+assert_failed = 0;
 if (reader_.isOpen())
 {
 printf("Reader (either the original or the re-created):\n");
 searchAndPrint(reader_.getReader());
 reader_.close(NULL);
 &reader_);
 printf("The recovered state of index:\n");
 searchAndPrint(reader_.getReader());
+testResultXml(xml_file);
 }
 private:
 void cleanup()
 SuiteTester
 * whiteBox = new SuiteTester("whitebox");
 whiteBox->add("baccoll",
-&TestBaseAppClassCollision);
+&TestBaseAppClassCollision,
+"baccoll");
 whiteBox->add("idpcoll",
-&TestIdxDbPathCollision);
+&TestIdxDbPathCollision,
+"idpcoll");
 whiteBox->add("scrapall",
-&TestScrapAll);
+&TestScrapAll,
+"scrapall");
 whiteBox->add("unifiedSearchParse",
 &TestUnifiedSearchParse,
 "unifiedSearchParse");

changeset 3	ae3f1779f6da
parent 0	671dee74050a
child 14	8bd192d47aaa