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; }