void TestACLsInfer::testACLs(ISession *pSession)
{
TVERIFY(pSession != NULL);
CmvautoPtr<IStmt> lQ(pSession->createStmt());
SourceSpec lCS; lCS.objectID = mCLSID; lCS.nParams = 0; lCS.params = NULL;
lQ->addVariable(&lCS, 1);
uint64_t lCount = 0;
TVERIFYRC(lQ->count(lCount));
TVERIFY(lCount == uint64_t(mExpectedCount));
unsigned long lResultCount = 0;
ICursor* lC = NULL;
TVERIFYRC(lQ->execute(&lC));
CmvautoPtr<ICursor> lR(lC);
if(lR.IsValid())
{
for(IPIN *lPIN = lR->next(); lPIN != NULL; lPIN = lR->next(), lResultCount++)
{
PID lPID = lPIN->getPID();
lPIN->destroy(); lPIN = NULL;
lPIN = pSession->getPIN(lPID); TVERIFY(lPIN != NULL);
lPIN->destroy();
}
}
TVERIFY(lResultCount == (unsigned long)mExpectedCount);
}
void TestLeftJoin::createData()
{
MVTRand::getString(mLHSStr, 10, 10, false, true);
mNumRHSPINs = 0;
mNumFamily2PINs = 0;
int i = 0;
std::vector<PID> lPINs;
// Create PINs for Family2
for(i = 0; i < (int)sNumPINs/2; i++)
{
Value lV[5];
Tstring lRHSStr;
SETVALUE(lV[0], mPropIDs[2], MVTRand::getRange(10, 100), OP_SET);
SETVALUE(lV[1], mPropIDs[3], MVTRand::getBool(), OP_SET);
Tstring lStr; MVTRand::getString(lStr, 10, 10, false, true);
SETVALUE(lV[2], mPropIDs[4], lStr.c_str(), OP_SET);
bool lJoinFamily = MVTRand::getRange(0, 100) > 50?true:false;
if(lJoinFamily)
{
int lRand = MVTRand::getRange(0, 2);
lRHSStr = sRHSStr[lRand];
SETVALUE(lV[3], mRHSPropID, lRHSStr.c_str(), OP_SET);
}
PID lPID = {STORE_INVALID_PID, STORE_OWNER};
CREATEPIN(mSession, &lPID, lV, lJoinFamily?4:3);
IPIN *lPIN = mSession->getPIN(lPID); TVERIFY(lPIN != NULL);
if(lPIN)
{
if(lJoinFamily)
{
mRHSPINs.insert(std::map<Tstring, PID>::value_type(lRHSStr, lPID));
mNumFamily2PINs++;
}
lPINs.push_back(lPID);
lPIN->destroy();
mNumRHSPINs++;
}
}
// Create PINs for Family1
for(i = 0; i < (int)sNumPINs/2; i++)
{
Value lV[5];
SETVALUE(lV[0], mLHSPropID, mLHSStr.c_str(), OP_SET);
SETVALUE(lV[1], mPropIDs[2], MVTRand::getRange(10, 100), OP_SET);
SETVALUE(lV[2], mPropIDs[3], MVTRand::getBool(), OP_SET);
Tstring lStr; MVTRand::getString(lStr, 10, 10, false, true);
SETVALUE(lV[3], mPropIDs[4], lStr.c_str(), OP_SET);
SETVALUE(lV[4], mPropIDs[5], lPINs[i], OP_SET); // add VT_REFID property to pins created before
PID lPID = {STORE_INVALID_PID, STORE_OWNER};
CREATEPIN(mSession, &lPID, lV, 5);
IPIN *lPIN = mSession->getPIN(lPID); TVERIFY(lPIN != NULL);
mLHSPINs.push_back(lPID);
if(lPIN) lPIN->destroy();
}
lPINs.clear();
}
IdentityID TestACLsInfer::getIdentityID(int pIndex)
{
TVERIFY(pIndex < sNumIdentities);
char lIdentity[255];
sprintf(lIdentity, "testaclsinfer.identity%d", pIndex);
IdentityID const lIID = mSession->getIdentityID(lIdentity);
TVERIFY(lIID != STORE_INVALID_IDENTITY);
return lIID;
}
void TestACLsInfer::testIdentities()
{
int i = 0;
for(i = 0; i < sNumIdentities; i++)
{
char lIdentity[255]; sprintf(lIdentity, "testaclsinfer.identity%d", i);
ISession *lSession = MVTApp::startSession(0, lIdentity); TVERIFY(lSession != NULL);
IdentityID lIID = lSession->getCurrentIdentityID(); TVERIFY(lIID != STORE_INVALID_IDENTITY);
testACLs(lSession);
testJoinACLs(lSession);
lSession->terminate();
}
}
void TestLeftJoin::testLeftJoinEQ()
{
Value lLHSValue[1];
lLHSValue[0].set(mLHSStr.c_str());
SourceSpec lLHSCS[1];
lLHSCS[0].objectID = getDataEventID(0);
lLHSCS[0].nParams = 1;
lLHSCS[0].params = lLHSValue;
Value lRHSValue[1];
lRHSValue[0].set(sRHSStr[0]);
SourceSpec lRHSCS[1];
lRHSCS[0].objectID = getDataEventID(1);
lRHSCS[0].nParams = 1;
lRHSCS[0].params = lRHSValue;
IStmt * lQ = mSession->createStmt();
unsigned char lVar1 = lQ->addVariable(lLHSCS, 1);
unsigned char lVar2 = lQ->addVariable(lRHSCS, 1);
Value lV[2];
lV[1].setVarRef(lVar1,mRefPropID);
lV[0].setVarRef(lVar2,mPINPropID);
CmvautoPtr<IExprNode> lJoinET(mSession->expr(OP_EQ,2,lV));
lQ->join(lVar1, lVar2, lJoinET, QRY_LEFT_OUTER_JOIN);
uint64_t lCount = 0;
TVERIFYRC(lQ->count(lCount, 0, 0, ~0));
TVERIFY(lCount == (uint64_t)mLHSPINs.size());
lQ->destroy();
}
void TestFTIndexRebuild::verifyFTIndex(ISession *session)
{
static char const * const search[] =
{
"Pirrip","Gargery","mother","fancies","grave","marsh",
"memorable","Bartholomew","scattered","shivers","briars",
"tombstone","roasted","pecooliar","gibbet","apron","improbable",
"elixir","garret","blubbered","penknife","Pumblechook","scornful",
"fireside","Sundays","Mooncalfs","Havisham","unpromoted","triumphantly",
"discernible","countenance","politely omitting","forcible argumentation",
"muffins","to express","something unwonted","bearing his poverty","unacquainted",
"prosperous","where Wemmick","Estella","Richmond","natural","barrack way",
"thankfulness","tranquil",
};
size_t i;
for (i=0; i<sizeof(search) / sizeof(search[0]); i++){
IStmt *query = session->createStmt();
unsigned char var = query->addVariable();
query->setConditionFT(var,search[i],MODE_ALL_WORDS);
uint64_t cnt = 0;
query->count(cnt);
query->destroy();
if (cnt == 0){
std::cout<<"FT Returned Zero results for search "<<search[i]<<std::endl;
TVERIFY(false);
}
}
}
int TestUndelete::getPINIndex(PID lPID)
{
assert(lPID.pid != STORE_INVALID_PID);
IPIN *lPIN = mSession->getPIN(lPID);
if(!lPIN)
{
int i = 0;
for( i = 0; i < (int)mPIDs.size(); i++) if(lPID.pid == mPIDs[i].pid && lPID.ident == mPIDs[i].ident) break;
Value lV[1]; lV[0].set(i);
IStmt *lQ = getQuery(4, mPropIDs[1], lV);
ICursor *lR = NULL;
TVERIFYRC(lQ->execute(&lR, 0,0,~0,0,MODE_DELETED));
if(lR) { lPIN = lR->next(); lR->destroy(); } else assert(lPIN!=NULL && "Failed to get PIN");
lQ->destroy();
}
int lRetVal = 0;
if(lPIN->defined(&mPropIDs[1], 1))
{
Value const *lV = lPIN->getValue(mPropIDs[1]);
lRetVal = lV->i;
TVERIFY(lV!=NULL && "NULL Value returned");
}
lPIN->destroy();
return lRetVal;
}
void TestLeftJoin::testLeftJoinIN()
{
Value lVal[2]; lVal[0].set(mLHSStr.c_str()); lVal[1].set(mLHSStr.c_str());
Value lLHSVal[1]; lLHSVal[0].setRange(lVal);
SourceSpec lLHSCS[1];
lLHSCS[0].objectID = getDataEventID(2);
lLHSCS[0].nParams = 1;
lLHSCS[0].params = lLHSVal;
char lStart[2]; lStart[0] = (char)0; lStart[1] = '\0';
char lEnd[2]; lEnd[0] = (char)255; lEnd[1] = '\0';
Value lVal2[2]; lVal2[0].set(lStart); lVal2[1].set(lEnd);
Value lRHSVal[1]; lRHSVal[0].setRange(lVal2);
SourceSpec lRHSCS[1];
lRHSCS[0].objectID = getDataEventID(3);
lRHSCS[0].nParams = 1;
lRHSCS[0].params = lRHSVal;
IStmt * lQ = mSession->createStmt();
unsigned char lVar1 = lQ->addVariable(lLHSCS, 1);
unsigned char lVar2 = lQ->addVariable(lRHSCS, 1);
Value lV[2];
lV[1].setVarRef(lVar1,mRefPropID);
lV[0].setVarRef(lVar2,mPINPropID);
CmvautoPtr<IExprNode> lJoinET(mSession->expr(OP_EQ,2,lV));
lQ->join(lVar1, lVar2, lJoinET, QRY_LEFT_OUTER_JOIN);
uint64_t lCount = 0;
TVERIFYRC(lQ->count(lCount, 0, 0, ~0));
TVERIFY((int)lCount == mNumRHSPINs);
lQ->destroy();
}
// Implement this test.
int TestRandomPIDs::execute()
{
bool lSuccess = true;
if (MVTApp::startStore())
{
ISession * const lSession = MVTApp::startSession();
for (int i = 0; i < 1000; i++)
{
PID lPID;
unsigned storeid=MVTApp::Suite().mStoreID;
//Big range to ensure we go beyond the default alloc
ulong page= MVTRand::getRange(0,5000);
unsigned pageslot = MVTRand::getRange(1,100);
lPID.pid = BUILDPID(storeid,page,pageslot) ;
lPID.ident = STORE_OWNER;
IPIN * const lPIN = lSession->getPIN(lPID);
if (lPIN){
// Unlikely, but we can generate a real pin id and get something valid
// if we get anything is should be valid so attempt an operation
lPIN->getNumberOfProperties();
lPIN->destroy();
}
}
lSession->terminate();
MVTApp::stopStore();
}
else { TVERIFY(!"Unable to start store"); }
return lSuccess ? 0 : 1;
}
void testlistwords::verifyListWords(const char* q,const char* rstr,bool fExpected)
{
int i=0;int j=0;int k=0;
string tstring; string substring[10];
tstring=rstr;
while(rstr[i]!='\0')
{
if(rstr[i]==' ')
{
substring[k]=tstring.substr(j,i-j);
j=i+1;k++;
}
i++;
}
substring[k]=tstring.substr(j);
StringEnum *strEnm;
const char * strE;
TVERIFYRC(mSession->listWords(q,strEnm));
int enmCnt=0;
for(;;)
{
strE=strEnm->next();
if(strE==NULL)
{
TVERIFY((enmCnt>=k)||fExpected);break;
}
else
{
for(i=0;i<=k;i++)
{
if(!(strcmp(strE,substring[i].c_str())))
{substring[i].clear();}
}
}
enmCnt++;
}
strEnm->destroy();
for(i=0;i<=k;i++)
{
TVERIFY(((strcmp(substring[i].c_str(),""))==0)||fExpected);
}
}
void TestLeftJoin::executeQuery(SourceSpec *pLHSCS, SourceSpec *pRHSCS, IExprNode *pET, unsigned pMode)
{
IStmt * lQ = mSession->createStmt();
unsigned char lVar1 = lQ->addVariable(pLHSCS, 1);
unsigned char lVar2 = lQ->addVariable(pRHSCS, 1);
Value lV[2];
lV[1].setVarRef(lVar1,mRefPropID);
lV[0].setVarRef(lVar2,mPINPropID);
CmvautoPtr<IExprNode> lJoinET(mSession->expr(OP_EQ,2,lV));
lQ->join(lVar1, lVar2, lJoinET, QRY_LEFT_OUTER_JOIN);
uint64_t lCount = 0;
TVERIFYRC(lQ->count(lCount, 0, 0, ~0));
TVERIFY(lCount == (uint64_t)mLHSPINs.size());
OrderSeg lOrder = {NULL,mRHSPropID,ORD_DESC,0,0};
lQ->setOrder(&lOrder, 1);
Afy::ICursor *lR = NULL;
lQ->execute(&lR, NULL, 0, ~0, 0, pMode);
int lResultCount = 0;
if(lR)
{
for(IPIN *lPIN = lR->next(); lPIN != NULL; lPIN = lR->next())
{
lResultCount++;
PID lResultPID = lPIN->getPID();
if(isVerbose()) mLogger.out() << std::hex << lResultPID.pid << std::endl;
TVERIFY(lResultPID.pid != STORE_INVALID_PID && "Junk PIN returned in the result set");
bool lFound = false;
size_t j = 0;
for(j = 0; j < mLHSPINs.size(); j++)
{
PID lPID = mLHSPINs[j];
if(lPID.pid == lResultPID.pid)
{
lFound = true; break;
}
}
if(!lFound) TVERIFY(false && "PIN belonging to Family1 wasn't returned in LEFT JOIN");
}
lR->destroy();
}
TVERIFY(lResultCount == (int)mLHSPINs.size() && "Not all PINs were returned");
lQ->destroy();
}
bool
TestBindata::cbRetrieve (QByteArray serverdata)
{
TVERIFY (m_testdata == serverdata,
"Our local file is different from the retrieved one");
waitDone ();
return true;
}
bool
TestBindata::cbRemove2 (QVariantList list)
{
QVariant hash (m_serverhash);
TVERIFY (!list.contains (hash), "Server still contains Bindata");
waitDone ();
return true;
}
bool
TestBindata::cbList (QVariantList list)
{
QVariant hash (m_serverhash);
TVERIFY (list.contains (hash), "Server doesn't have the file we sent");
waitDone ();
return true;
}
void TestACLsInfer::createIdentities()
{
int i = 0;
for (i = 0; i < sNumIdentities; i++)
{
char lIdentity[255];
sprintf(lIdentity, "testaclsinfer.identity%d", i);
IdentityID const lIID = mSession->storeIdentity(lIdentity, NULL);
TVERIFY(lIID != STORE_INVALID_IDENTITY);
}
}
int TestACLsInfer::execute()
{
bool lSuccess = true;
if (MVTApp::startStore())
{
MVTRand::getString(mClassStr, 5, 10, false, true);
doTest() ;
MVTApp::stopStore();
}
else { TVERIFY(!"Unable to start store"); }
return lSuccess?0:1;
}
bool
TestBindata::cbAdd (QString hash)
{
m_serverhash = hash;
TVERIFY (hash.toAscii () ==
QCryptographicHash::hash (m_testdata, QCryptographicHash::Md5).toHex (),
"Returned String doesn't match md5 hash of data");
waitDone ();
return true;
}
int TestPageInsertOverflow::execute()
{
bool lSuccess = true;
if (MVTApp::startStore())
{
ISession * session = MVTApp::startSession();
Value val[sNumProps];PID pid1;IPIN *pin1;
MVTApp::mapURIs(session, "TestPageInsertOverflow.prop.", sNumProps, lPropIDs);
TVERIFYRC(session->createPIN(NULL,0,&pin1,MODE_PERSISTENT));
pid1 = pin1->getPID();
if(pin1!=NULL) pin1->destroy();
for (int i=0; i < 10; i++)
{
IPIN *pin;Tstring str;int k=0;int x=0;
for (k=0; k < 10; k++)
{
MVTApp::randomString(str,1,30);
val[k].set(str.c_str());val[k].setPropID(lPropIDs[k]);
}
TVERIFYRC(session->createPIN(val,k-1,&pin,MODE_PERSISTENT|MODE_COPY_VALUES));
for (x =0; x < 10;x++,k++)
{
val[x].set(pid1);val[x].setPropID(lPropIDs[k]);
val[x].op = OP_ADD;val[x].eid = STORE_FIRST_ELEMENT;
}
TVERIFYRC(pin->modify(val,x));
for (x =0; x < 40;x++,k++)
{
val[x].set("a");val[x].setPropID(lPropIDs[k]);
}
TVERIFYRC(pin->modify(val,x));
for (x =0; x < 10;x++,k++)
{
val[x].set(pid1);val[x].setPropID(lPropIDs[k]);
val[x].op = OP_ADD;val[x].eid = STORE_FIRST_ELEMENT;
}
TVERIFYRC(pin->modify(val,x));
for (x =0; x < 10;x++,k++)
{
val[x].set(pid1);val[x].setPropID(lPropIDs[k]);
}
session->startTransaction();
TVERIFYRC(pin->modify(val,x));
if(pin!=NULL) pin->destroy();
session->rollback();
}
session->terminate();
MVTApp::stopStore();
}
else { TVERIFY(!"could not open store") ; }
return lSuccess ? 0 : 1;
}
void TestFTIndexRebuild::verifyMiscOps(ISession *session)
{
Value val[4];
//case 1: META_PROP_NOFTINDEX should be honored
val[0].set("Wollongabba");val[0].setPropID(mPropIds[1]);
TVERIFYRC(session->createPIN(val,1,NULL,MODE_PERSISTENT|MODE_COPY_VALUES));
TVERIFYRC(session->rebuildIndexFT());
TVERIFY(verify2(session,"Wollongabba",0));
//case 2: META_PROP_STOPWORDS should be honored
val[0].set("brisbane is somewhere");val[0].setPropID(mPropIds[1]); //val[0].meta = META_PROP_STOPWORDS; -- always excludes stopwords
TVERIFYRC(session->createPIN(val,1,NULL,MODE_PERSISTENT|MODE_COPY_VALUES));
TVERIFYRC(session->rebuildIndexFT());
TVERIFY(verify2(session,"somewhere",0));
//case 3: PIN_HIDDEN should be honored
val[0].set("adeleide is somewhere");val[0].setPropID(mPropIds[1]);
TVERIFYRC(session->createPIN(val,1,NULL,MODE_PERSISTENT|MODE_COPY_VALUES|PIN_HIDDEN));
TVERIFYRC(session->rebuildIndexFT());
TVERIFY(verify2(session,"adeleide",0));
//case 4: Extended char set tests
}
void TestUndelete::test(IStmt *pQuery)
{
uint64_t lActualCount = 0, lDeleteCount = 0, lAftDeleteCount = 0, lAftUndeleteCount = 0;
std::vector<PID> lDeletedPINs;
pQuery->count(lActualCount);
ICursor *lR = NULL;
TVERIFYRC(pQuery->execute(&lR));
if(lR)
{
PID lPID = {STORE_INVALID_PID, STORE_OWNER};
while(RC_OK == lR->next(lPID))
{
if(MVTRand::getBool())
{
TVERIFYRC(mSession->deletePINs(&lPID, 1));
lDeletedPINs.push_back(lPID);
}
}
lR->destroy(); lR = NULL;
}
uint64_t lNumDeletePINs = lDeletedPINs.size();
long const lCountStartTime = getTimeInMs();
pQuery->count(lDeleteCount, NULL, 0, ~0, MODE_DELETED);
long const lCountEndTime = getTimeInMs();
mLogger.out() << "Num of Deleted PINs :: " << lDeleteCount << ", Time taken to IStmt::count() on deleted PINs :: " << (lCountEndTime - lCountStartTime) << " ms" << std::endl;
TVERIFY(lNumDeletePINs == lDeleteCount && "More/Less PINs returned after delete");
pQuery->count(lAftDeleteCount);
TVERIFY((lActualCount-lNumDeletePINs) == lAftDeleteCount && "Deleted PINs not returned in query");
long const lResultStartTime = getTimeInMs();
TVERIFYRC(pQuery->execute(&lR, 0, 0, ~0, 0, MODE_DELETED));
unsigned long lIResultCount = 0;
if(lR)
{
PID lPID = {STORE_INVALID_PID, STORE_OWNER};
while(RC_OK == lR->next(lPID)) lIResultCount++;
lR->destroy();
}
else
TVERIFY(false && "Failed to return ICursor");
long const lResultEndTime = getTimeInMs();
mLogger.out() << "Num of Deleted PINs :: " << lIResultCount << ", Time taken to Iterate thro ICursor::next(&PID) on deleted PINs :: " << (lResultEndTime - lResultStartTime) << " ms" << std::endl;
TVERIFY(lIResultCount == lNumDeletePINs && "ICursor->next() did not return any/all pins");
undeletePINs(2, &lDeletedPINs[0], int(lNumDeletePINs));
pQuery->count(lDeleteCount, NULL, 0, ~0, MODE_DELETED);
TVERIFY(lDeleteCount == 0 && "Not all PINs were undeleted");
pQuery->count(lAftUndeleteCount);
TVERIFY(lActualCount == lAftUndeleteCount && "Not all PINs were undeleted");
lDeletedPINs.clear();
undeletePINs(2, &mPIDs[0], sNumPINs);
}
int TestLeftJoin::execute()
{
bool lSuccess = true;
if (MVTApp::startStore())
{
mSession = MVTApp::startSession();
MVTApp::mapURIs(mSession, "TestLeftJoin.prop.", sNumProps, mPropIDs);
doTest();
mSession->terminate();
MVTApp::stopStore();
}
else { TVERIFY(!"could not open store") ; }
return lSuccess ? 0 : 1;
}
void TestUndelete::deletePINs(int pUndeleteType, PID *pPIDs, int pNumPIDs)
{
int i = 0;
switch(pUndeleteType)
{
case 0: //IPIN::deletePIN();
for(i = 0; i < pNumPIDs; i++)
{
IPIN *lPIN = mSession->getPIN(pPIDs[i]); assert(lPIN!=NULL);
TVERIFYRC(lPIN->deletePIN());
lPIN=NULL; // pin has been deleted
}
break;
case 1: // IStmt::deletePINs();
for(i = 0; i < pNumPIDs; i++)
{
Value lV[1]; lV[0].set(getPINIndex(pPIDs[i]));
IStmt *lQ = getQuery(4, mPropIDs[1], lV, STMT_DELETE);
TVERIFYRC(lQ->execute());
lQ->destroy();
}
break;
case 2: // ISession::deletePINs();
// Get a snapshot to see what happens to snapshot
IPIN *lPIN = mSession->getPIN(pPIDs[i]); assert(lPIN!=NULL);
TVERIFYRC(mSession->deletePINs(pPIDs, pNumPIDs,0));
TVERIFY((lPIN->getFlags()&PIN_DELETED)==0); // pin doesn't know that it is deleted
TVERIFY(RC_DELETED == lPIN->refresh()) ;
TVERIFY((lPIN->getFlags()&PIN_DELETED)!=0);
lPIN->destroy() ;
break;
}
}
void TestACLsInfer::testJoinACLs(ISession *pSession)
{
TVERIFY(pSession != NULL);
CmvautoPtr<IStmt> lQ(pSession->createStmt());
Value lParam[3];
lParam[0].setError(mPropIDs[2]); lParam[1].setError(mPropIDs[2]); lParam[2].setRange(lParam);
SourceSpec lCS[2] = {{mCLSID, 0, NULL}, {mCLSID2, 1, &lParam[2]}};
unsigned char lVar1 = lQ->addVariable(&lCS[0], 1);
unsigned char lVar2 = lQ->addVariable(&lCS[1], 1);
IExprNode *lET;
{
Value lV[2];
lV[0].setVarRef(lVar1,mPropIDs[1]);
lV[1].setVarRef(lVar2,mPropIDs[2]);
lET = pSession->expr(OP_EQ, 2, lV);
}
lQ->join(lVar1, lVar2, lET);
uint64_t lCount = 0;
TVERIFYRC(lQ->count(lCount));
TVERIFY(lCount == uint64_t(mExpectedCount));
unsigned long lResultCount = 0;
ICursor* lC = NULL;
TVERIFYRC(lQ->execute(&lC));
CmvautoPtr<ICursor> lR(lC);
if(lR.IsValid())
{
for(IPIN *lPIN = lR->next(); lPIN != NULL; lPIN = lR->next(), lResultCount++)
{
PID lPID = lPIN->getPID();
lPIN->destroy(); lPIN = NULL;
lPIN = pSession->getPIN(lPID); TVERIFY(lPIN != NULL);
lPIN->destroy();
}
}
TVERIFY(lResultCount == (unsigned long)mExpectedCount);
}
int TestAbortQuery::execute()
{
bool lSuccess = true;
if (MVTApp::startStore())
{
mSession = MVTApp::startSession();
MVTApp::mapURIs(mSession, "TestAbortQuery.prop.", sNumProps, mPropIDs);
mStoreCtx = MVTApp::getStoreCtx();
doTest();
mSession->terminate();
MVTApp::stopStore();
}
else { TVERIFY(!"Unable to start store"); }
return lSuccess?0:1;
}
int TestUndelete::execute()
{
bool lSuccess = true;
if (MVTApp::startStore())
{
mSession = MVTApp::startSession();
MVTApp::mapURIs(mSession, "TestUndelete.prop.", sNumProps, mPropIDs);
createMeta();
createData();
doTest() ;
mSession->terminate();
MVTApp::stopStore();
}
else { TVERIFY(!"Unable to start store"); }
return lSuccess?0:1;
}
int TestFamilyOrder::execute()
{
bool lSuccess = true;
if (MVTApp::startStore())
{
mSession = MVTApp::startSession();
MVTApp::mapURIs(mSession, "TestAbortQuery.prop.", sNumProps, mPropIDs);
fID = STORE_INVALID_CLASSID;
DataEventID cid1,cid2;
/*write the code here*/
createFamily(CASE_INSENSITIVE_OP);
cid1 = fID;
createFamily(0);
cid2 = fID;
createPINs();
mLogger.out()<<"Quering CASE INSENSITIVE family...\n";
mLogger.out()<<endl<<"--------------------------"<<endl;
for(int i=0;i<8;i++)
queryFamily(cid1,i);
//validate();
mLogger.out()<<"Quering CASE SENSITIVE family...\n";
mLogger.out()<<endl<<"--------------------------"<<endl;
for(int i=0;i<8;i++)
queryFamily(cid2,i);
//validate();
mSession->terminate();
MVTApp::stopStore();
}
else{ TVERIFY(!"Unable to start store"); }
return lSuccess?0:1;
}
void TestFamilyOrder::queryFamily(DataEventID cid,int opt)
{
IStmt *lQ = mSession->createStmt();
Value paramVals;
unsigned char lVar;
SourceSpec cs ;
ICursor *lR;
OrderSeg os={NULL,mPropIDs[0],0,0,0};
IPIN * pResult ;
switch(opt)
{
case 0:
mLogger.out()<<"Query all the entries of the family"<<endl;
mLogger.out()<<"-----------------------------------------\n";
cs.objectID = cid;
cs.nParams = 0 ;
cs.params = NULL;
lVar = lQ->addVariable( &cs, 1 ) ;
break;
case 1:
mLogger.out()<<"Query all the entries of the family ordered by the 1st propery in ASCENDING"<<endl;
mLogger.out()<<"--------------------------------------------------------------------------------\n";
cs.objectID = cid;
cs.nParams = 0 ;
cs.params = NULL;
lVar = lQ->addVariable( &cs, 1 ) ;
os.flags=0;
lQ->setOrder(&os,1);
break;
case 2:
mLogger.out()<<"Query all the entries of the family ordered by the 1st property,in ASCENDING|NCASE order "<<endl;
mLogger.out()<<"-----------------------------------------------------------------------------------------\n";
cs.objectID = cid;
cs.nParams = 0 ;
cs.params = NULL;
lVar = lQ->addVariable( &cs, 1 ) ;
os.flags=ORD_NCASE;
lQ->setOrder( &os,1);
break;
case 3:
mLogger.out()<<"Query all the entries of the family based on the parameter and ordered by prop1, in ASCENDING|NCASE order"<<endl;
mLogger.out()<<"----------------------------------------------------------------------------------------------------------------\n";
cs.objectID = cid;
cs.nParams = 1 ;
paramVals.set(valuestr[0].c_str());
cs.params = ¶mVals ;
lVar = lQ->addVariable( &cs, 1 ) ;
os.flags=ORD_NCASE;
lQ->setOrder( &os, 1);
break;
case 4:
mLogger.out()<<"Query all the entries of the family ordered by the 2nd propery in ASCENDING"<<endl;
mLogger.out()<<"--------------------------------------------------------------------------------\n";
cs.objectID = cid;
cs.nParams = 0 ;
cs.params = NULL;
lVar = lQ->addVariable( &cs, 1 ) ;
os.pid=mPropIDs[1];
lQ->setOrder( &os,1);
break;
case 5:
mLogger.out()<<"Query all the entries of the family ordered by the 2nd property,in ASCENDING|NCASE order "<<endl;
mLogger.out()<<"-----------------------------------------------------------------------------------------\n";
cs.objectID = cid;
cs.nParams = 0 ;
cs.params = NULL;
lVar = lQ->addVariable( &cs, 1 ) ;
os.pid=mPropIDs[1]; os.flags=ORD_NCASE;
lQ->setOrder( &os, 1);
break;
case 6:
mLogger.out()<<"Query all the entries of the family based on the parameter n ordered by prop2, in ASCENDING|NCASE order"<<endl;
mLogger.out()<<"----------------------------------------------------------------------------------------------------------------\n";
cs.objectID = cid;
cs.nParams = 1 ;
paramVals.set(valuestr[0].c_str());
cs.params = ¶mVals ;
lVar = lQ->addVariable( &cs, 1 ) ;
os.pid=mPropIDs[1]; os.flags=ORD_NCASE;
lQ->setOrder( &os, 1);
break;
case 7:
mLogger.out()<<"Query all the entries of the family based on the parameter n ordered by prop2, in DESCENDING|NCASE order"<<endl;
mLogger.out()<<"--------------------------------------------------------------------------------------------------------\n";
cs.objectID = cid;
cs.nParams = 1 ;
paramVals.set(valuestr[0].c_str());
cs.params = ¶mVals ;
lVar = lQ->addVariable( &cs, 1 ) ;
os.pid=mPropIDs[1]; os.flags=ORD_NCASE|ORD_DESC;
lQ->setOrder( &os, 1);
break;
}
TVERIFYRC(lQ->execute(&lR));
mLogger.print("Family queries...\n\n");
int cnt = 0;
mCase = 0;
while ( NULL != ( pResult = lR->next() ) )
{
const Value *pIndex[2];
pIndex[0] = pResult->getValue(mPropIDs[0]) ;
if(isVerbose()) mLogger.print("Prop1:%s\n",pIndex[0]->str);
pIndex[1] = pResult->getValue(mPropIDs[1]) ;
if(isVerbose()) mLogger.print("Prop2:%s\n",pIndex[1]->str);
if(opt == 6)
vPIDS1[cnt++]=pResult->getPID();
if(opt == 7)
{
vPIDS2[cnt++]=pResult->getPID();
mCase++;
}
if(isVerbose()) mLogger.out() << "PIN ID " << pResult->getPID().pid << std::endl;
if ( pIndex == NULL ) { TVERIFY(!"No index prop") ; pResult->destroy() ; continue ; }
pResult->destroy() ;
}
lQ->destroy();
}
void TestFamilyOrder::validate()
{
for(int i=0; i<mCase; i++)
TVERIFY(vPIDS1[i] == vPIDS2[mCase-i-1]);
mLogger.out()<<"Mcase:"<<mCase<<endl;
}
int TestStreams::execute()
{
bool lSuccess = true;
TestStreamsReplCheck lReplCallback(this);
if (MVTApp::startStore(NULL, &lReplCallback))
{
ISession * const lSession = MVTApp::startSession();
static const int sNumProps = 2;
PropertyID lPropIDs[sNumProps];
int k = 0;
for(k = 0; k < sNumProps; k ++)
{
char lB[64];
sprintf(lB,"TestStreams.prop%d",k);
MVTApp::mapStaticProperty(lSession,lB,lPropIDs[k]);
}
//PropertyID const lPropIDs[] = {1000, 1001};
PID lPID, lPID2;
Value lV;
// Basic test.
#if 1
{
CREATEPIN(lSession, &lPID, NULL, 0);
IPIN * const lPIN = lSession->getPIN(lPID);
unsigned long lStreamLengths[] = {150, 6194304};
mLogger.out() << "Creating short stream" << std::endl;
MyStream* mystream1 = new MyStream(lStreamLengths[0]);
SETVALUE(lV, lPropIDs[0], MVTApp::wrapClientStream(lSession, mystream1), OP_ADD);
{
lReplCallback.setCurInputStream(lV.stream.is);
if (RC_OK != lPIN->modify(&lV, 1))
{
lSuccess = false;
assert(false);
}
lReplCallback.setCurInputStream(NULL);
}
lV.stream.is->reset();
mLogger.out() << "Creating pin from short stream" << std::endl;
{
lReplCallback.setCurInputStream(lV.stream.is);
CREATEPIN(lSession, &lPID2, &lV, 1);
lReplCallback.setCurInputStream(NULL);
}
mLogger.out() << "Creating long stream" << std::endl;
MyStream* mystream2 = new MyStream(lStreamLengths[1]);
SETVALUE(lV, lPropIDs[1], MVTApp::wrapClientStream(lSession, mystream2), OP_ADD);
{
lReplCallback.setCurInputStream(lV.stream.is);
if (RC_OK != lPIN->modify(&lV, 1))
{
lSuccess = false;
assert(false);
}
lReplCallback.setCurInputStream(NULL);
}
int p;
for (p = 0; p < 2; p++)
{
Value const * lVal = lPIN->getValue(lPropIDs[p]);
if (!lVal)
{
lSuccess = false;
mLogger.out() << "Error: Could not retrieve property " << lPropIDs[p] << "!" << std::endl;
}
else if (!MyStream::checkStream(mLogger, *lVal, lStreamLengths[p]))
lSuccess = false;
}
delete mystream1;
delete mystream2;
lPIN->destroy();
}
#endif
// Trying to repro 757.
#if 0
if (!MVTApp::isRunningSmokeTest())
{
unsigned long lStreamLengths1[] = {971520, 20971520};
mLogger.out()<<"Trying to repro bug 757"<<std::endl;
SETVALUE(lV, lPropIDs[1], MVTApp::wrapClientStream(lSession, new MyStream(lStreamLengths1[1])), OP_SET);
{
lReplCallback.setCurInputStream(lV.stream.is);
CREATEPIN(lSession, lPID2, &lV, 1);
lReplCallback.setCurInputStream(NULL);
}
SETVALUE(lV, lPropIDs[1], MVTApp::wrapClientStream(lSession, new MyStream(lStreamLengths1[0])), OP_SET);
{
lReplCallback.setCurInputStream(lV.stream.is);
CREATEPIN(lSession, lPID2, &lV, 1);
lReplCallback.setCurInputStream(NULL);
}
#ifdef WIN32
::DebugBreak();
#endif
}
// Log file issue.
if (!MVTApp::isRunningSmokeTest())
{
int x;
IPIN *mp3pin;
Value val[3];
PropertyID lPropIDs[3];
MVTApp::mapURIs(lSession,"TestStreams.prop",3,lPropIDs);
for (x =0; x<20; x++)
{
mLogger.out()<<"Creating streams for Ajay's Scneario"<<std::endl;
SETVALUE(lV, lPropIDs[1], MVTApp::wrapClientStream(lSession, new MyStream(lStreamLengths[1])), OP_SET);
{
lReplCallback.setCurInputStream(lV.stream.is);
CREATEPIN(lSession, lPID2, &lV, 1);
lReplCallback.setCurInputStream(NULL);
}
mp3pin = lSession->getPIN(lPID2);
val[0].set("Test prop1");val[0].setPropID(lPropIDs[0]);
val[1].set("Test prop2");val[0].setPropID(lPropIDs[1]);
val[2].set("Test prop3");val[0].setPropID(lPropIDs[2]);
mp3pin->modify(val,3);
mp3pin->destroy();
}
}
#endif
//returning RC_CORRUPTED
if (!MVTApp::isRunningSmokeTest())
{
unsigned long lStreamLengths1[] = {71520, 971520};
MyStream* mystream1 = new MyStream(lStreamLengths1[0]);
SETVALUE(lV, lPropIDs[1], MVTApp::wrapClientStream(lSession, mystream1), OP_SET);
{
lReplCallback.setCurInputStream(lV.stream.is);
CREATEPIN(lSession, &lPID2, &lV, 1);
lReplCallback.setCurInputStream(NULL);
}
IPIN *pin = lSession->getPIN(lPID2);
MyStream* mystream2 = new MyStream(lStreamLengths1[1]);
SETVALUE(lV, lPropIDs[1], MVTApp::wrapClientStream(lSession, mystream2), OP_SET);
{
lReplCallback.setCurInputStream(lV.stream.is);
TVERIFYRC(pin->modify(&lV,1));
lReplCallback.setCurInputStream(NULL);
}
delete mystream1;
delete mystream2;
pin->destroy();
}
// More aggressive test.
#if 1
#if TESTSTREAMS_BASHQUERY
long volatile lStop = 0;
HTHREAD lThreads[2];
createThread(&threadTestStreamsBashQuery, (void *)&lStop, lThreads[0]);
createThread(&threadTestStreamsBashQuery, (void *)&lStop, lThreads[1]);
static int const sNumTests = 500;
static int const sMinSize = 5000;
static double const sMaxSize = 5000.0;
#else
static int const sNumTests = 20;
static int const sMinSize = 1;
static double const sMaxSize = 200000.0;
#endif
PID lPIDs[sNumTests];
unsigned long lLens[sNumTests];
char lStartChars[sNumTests];
ValueType lVTs[sNumTests];
int lCollectionSizes[sNumTests];
int i, j;
mLogger.out() << "Creating lots of streams..." << std::endl;
for (i = 0; i < sNumTests; i++)
{
mLogger.out() << ".";
lLens[i] = sMinSize + (int)(sMaxSize * rand() / RAND_MAX);
lStartChars[i] = (char)(100.0 * rand() / RAND_MAX);
lVTs[i] = ((100.0 * rand() / RAND_MAX) > 50.0) ? VT_STRING : VT_BSTR;
#if 0
lCollectionSizes[i] = 1;
#else
lCollectionSizes[i] = 1 + (int)(5.0 * rand() / RAND_MAX);
#endif
Value lV;
MyStream* mystream1 = new MyStream(lLens[i], lStartChars[i], lVTs[i]);
SETVALUE(lV, lPropIDs[0], MVTApp::wrapClientStream(lSession, mystream1), OP_ADD);
{
lReplCallback.setCurInputStream(lV.stream.is);
CREATEPIN(lSession, &lPIDs[i], &lV, 1);
lReplCallback.setCurInputStream(NULL);
}
IPIN * const lPIN = lSession->getPIN(lPIDs[i]);
for (j = 1; j < lCollectionSizes[i]; j++)
{
MyStream* mystream2 = new MyStream(lLens[i], lStartChars[i], lVTs[i]);
SETVALUE_C(lV, lPropIDs[0], MVTApp::wrapClientStream(lSession, mystream2), OP_ADD, STORE_LAST_ELEMENT);
{
lReplCallback.setCurInputStream(lV.stream.is);
if (RC_OK != lPIN->modify(&lV, 1))
{
lSuccess = false;
mLogger.out() << "Error: Could not add stream to collection!" << std::endl;
}
lReplCallback.setCurInputStream(NULL);
}
delete mystream2;
}
Value const * lVal = lPIN->getValue(lPropIDs[0]);
if (!testResultingStreams(mLogger, lVal, lLens[i], lStartChars[i], lVTs[i], lCollectionSizes[i]))
lSuccess = false;
delete mystream1;
lPIN->destroy();
}
mLogger.out() << std::endl << "Retesting them..." << std::endl;
for (i = 0; i < sNumTests; i++)
{
mLogger.out() << ".";
IPIN * const lPIN = lSession->getPIN(lPIDs[i]);
Value const * lVal = lPIN->getValue(lPropIDs[0]);
if (!testResultingStreams(mLogger, lVal, lLens[i], lStartChars[i], lVTs[i], lCollectionSizes[i]))
lSuccess = false;
lPIN->destroy();
}
#endif
#if TESTSTREAMS_BASHQUERY
lStop = 1;
MVTestsPortability::threadsWaitFor(2, lThreads);
#endif
lSession->terminate();
MVTApp::stopStore();
}
else { TVERIFY(!"Unable to start store"); }
return lSuccess ? 0 : 1;
}
int testjoinorderby::execute()
{
ISession * mSession ;int i;
if (!MVTApp::startStore()) {mLogger.print("Failed to start store\n"); return RC_NOACCESS;}
mSession = MVTApp::startSession();
//Properties - mapping properties
PropertyID date_original_modifiedPropID;
char *propName2;char lB[64]; sprintf(lB, "http://vmware.com/core/date_original_modified");propName2=lB;
date_original_modifiedPropID=MVTUtil::getPropRand(mSession,propName2);
for(i=0;i<6;i++)
{
char lB[64]; sprintf(lB, "%d.propery", i);
propName2=lB;
mProp[i]=MVTUtil::getPropRand(mSession,propName2);
}
//DEfining Classes
const char *lClassList[] = {"unprocessedAudioMP31","unprocessedMeta1","unprocessedPDF1","unprocessedDocx1","unprocessedTXT1"};
const char *lClassList2[] = {"hostingPinsPushShredder","hostingPinsNotShredded1"};
size_t nClasses = sizeof(lClassList)/sizeof(lClassList[0]);
for(i=0;i<6;i++)
{
IStmt *lFamilyQ=mSession->createStmt() ;
unsigned char lVar = lFamilyQ->addVariable() ;
Value ops[2] ;
Value ops1[1] ;
Value ops2[2] ;
ops[0].setVarRef(0, date_original_modifiedPropID ) ;ops[1].setParam(0);
IExprNode *lE= mSession->expr(OP_IN, 2, ops ) ;
ops1[0].setVarRef(0, mProp[i] ) ;
IExprNode *lE1= mSession->expr(OP_EXISTS, 1, ops1 ) ;
ops2[0].set(lE);
ops2[1].set(lE1);
IExprNode *lE2= mSession->expr(OP_LAND, 2, ops2 ) ;
TVERIFYRC(lFamilyQ->addCondition( lVar, lE2 )) ;
if(i<4)
{
TVERIFYRC(defineClass(mSession, lClassList[i], lFamilyQ ));
}
else
{
TVERIFYRC(defineClass(mSession, lClassList2[i-4], lFamilyQ ));
}
lE2->destroy();
lFamilyQ->destroy();
}
//Creating Pins
{
Value lV[7];
TIMESTAMP lTS;
for(i=0;i<15;i++)
{
lTS=MVTRand::getDateTime(mSession);
lV[0].setDateTime(lTS);lV[0].setPropID(date_original_modifiedPropID);
lV[1].setDateTime(lTS);lV[1].property=mProp[0];
lV[2].setDateTime(lTS);lV[2].property=mProp[1];
lV[3].setDateTime(lTS);lV[3].property=mProp[2];
lV[4].setDateTime(lTS);lV[4].property=mProp[3];
lV[5].setDateTime(lTS);lV[5].property=mProp[4];
lV[6].setDateTime(lTS);lV[6].property=mProp[5];
TVERIFYRC(mSession->createPIN(lV,7,NULL,MODE_COPY_VALUES|MODE_PERSISTENT));
}
}
//Query
IStmt *lQuery = mSession->createStmt();
//union of four classes
RC rc = RC_OK;
if(lQuery)
{
unsigned char lastvar = 0;bool bSuccess = true;
for(unsigned long iidx = 0 ; iidx < nClasses && bSuccess; iidx++)
{
Afy::SourceSpec lclassSpec;
lclassSpec.nParams=0;
lclassSpec.params=NULL;
if(RC_OK == (rc = mSession->getDataEventID(lClassList[iidx],lclassSpec.objectID)))
{
unsigned char tmpVar = lQuery->addVariable(&lclassSpec,1);
lastvar = iidx==0 ? tmpVar : lQuery->setOp(lastvar,tmpVar,Afy::QRY_UNION);
}
else
bSuccess = false;
}
//intersection of fifth class
Afy::Value lrange[2];Afy::Value lparam;
if(bSuccess)
{
Afy::SourceSpec lclassSpec;
if( RC_OK == (rc =mSession->getDataEventID("hostingPinsPushShredder",lclassSpec.objectID)))
{
lclassSpec.nParams=0;
lclassSpec.params=NULL;
unsigned char tmpVar = lQuery->addVariable(&lclassSpec,1);
lastvar = lQuery->setOp(lastvar,tmpVar,Afy::QRY_INTERSECT);
if( RC_OK == (rc =mSession->getDataEventID("hostingPinsNotShredded1",lclassSpec.objectID)))
{
TIMESTAMP lTS;getTimestamp(lTS);
DateTime lDT;mSession->convDateTime(lTS,lDT,true/*UTC*/);
lrange[0].setDateTime(0);
lrange[1].setDateTime(lTS);
lparam.setRange(lrange);
lclassSpec.nParams=1;
lclassSpec.params=&lparam;
tmpVar = lQuery->addVariable(&lclassSpec,1);
lastvar = lQuery->setOp(lastvar,tmpVar,Afy::QRY_UNION);
}
else
bSuccess = false;
}
else
bSuccess = false;
}
OrderSeg ord = {NULL,date_original_modifiedPropID,ORD_DESC,0,0};
TVERIFYRC(lQuery->setOrder( &ord,1));
//Execution
int ncount=9;
Afy::ICursor *lResult = NULL;
TVERIFYRC(lQuery->execute(&lResult,NULL, 0,(unsigned int)ncount,0)) ;
//Afy::ICursor *lResult = lQuery->execute();
IPIN *pin;
const Value * rV;
uint16_t tempYear=0; i=0;
while( pin = lResult->next() )
{
DateTime lDT2;
rV=pin->getValue(date_original_modifiedPropID);
TVERIFYRC(mSession->convDateTime(rV->ui64,lDT2));
if(i!=0)
{
TVERIFY(lDT2.year<=tempYear);
}
tempYear=lDT2.year;i++;
}
}
lQuery->destroy();
mSession->terminate();
MVTApp::stopStore();
return RC_OK;
}
