void do_give(int descr, dbref player, const char *recipient, int amount) { dbref who; char buf[BUFFER_LEN]; struct match_data md; /* do amount consistency check */ if (amount < 0 && !Wizard(OWNER(player))) { notify(player, "Try using the \"rob\" command."); return; } else if (amount == 0) { notify_fmt(player, "You must specify a positive number of %s.", tp_pennies); return; } /* check recipient */ init_match(descr, player, recipient, TYPE_PLAYER, &md); match_neighbor(&md); match_me(&md); if (Wizard(OWNER(player))) { match_player(&md); match_absolute(&md); } switch (who = match_result(&md)) { case NOTHING: notify(player, "Give to whom?"); return; case AMBIGUOUS: notify(player, "I don't know who you mean!"); return; default: if (!Wizard(OWNER(player))) { if (Typeof(who) != TYPE_PLAYER) { notify(player, "You can only give to other players."); return; } else if (GETVALUE(who) + amount > tp_max_pennies) { notify_fmt(player, "That player doesn't need that many %s!", tp_pennies); return; } } break; } /* try to do the give */ if (!payfor(player, amount)) { notify_fmt(player, "You don't have that many %s to give!", tp_pennies); } else { /* he can do it */ switch (Typeof(who)) { case TYPE_PLAYER: SETVALUE(who, GETVALUE(who) + amount); if(amount >= 0) { snprintf(buf, sizeof(buf), "You give %d %s to %s.", amount, amount == 1 ? tp_penny : tp_pennies, NAME(who)); notify(player, buf); snprintf(buf, sizeof(buf), "%s gives you %d %s.", NAME(player), amount, amount == 1 ? tp_penny : tp_pennies); notify(who, buf); } else { snprintf(buf, sizeof(buf), "You take %d %s from %s.", -amount, amount == -1 ? tp_penny : tp_pennies, NAME(who)); notify(player, buf); snprintf(buf, sizeof(buf), "%s takes %d %s from you!", NAME(player), -amount, -amount == 1 ? tp_penny : tp_pennies); notify(who, buf); } break; case TYPE_THING: SETVALUE(who, (GETVALUE(who) + amount)); snprintf(buf, sizeof(buf), "You change the value of %s to %d %s.", NAME(who), GETVALUE(who), GETVALUE(who) == 1 ? tp_penny : tp_pennies); notify(player, buf); break; default: notify_fmt(player, "You can't give %s to that!", tp_pennies); break; } DBDIRTY(who); } }
void do_kill(int descr, dbref player, const char *what, int cost) { dbref victim; char buf[BUFFER_LEN]; struct match_data md; init_match(descr, player, what, TYPE_PLAYER, &md); match_neighbor(&md); match_me(&md); if (Wizard(OWNER(player))) { match_player(&md); match_absolute(&md); } victim = match_result(&md); switch (victim) { case NOTHING: notify(player, "I don't see that player here."); break; case AMBIGUOUS: notify(player, "I don't know who you mean!"); break; default: if (Typeof(victim) != TYPE_PLAYER) { notify(player, "Sorry, you can only kill other players."); } else { /* go for it */ /* set cost */ if (cost < tp_kill_min_cost) cost = tp_kill_min_cost; if (FLAGS(DBFETCH(player)->location) & HAVEN) { notify(player, "You can't kill anyone here!"); break; } if (tp_restrict_kill) { if (!(FLAGS(player) & KILL_OK)) { notify(player, "You have to be set Kill_OK to kill someone."); break; } if (!(FLAGS(victim) & KILL_OK)) { notify(player, "They don't want to be killed."); break; } } /* see if it works */ if (!payfor(player, cost)) { notify_fmt(player, "You don't have enough %s.", tp_pennies); } else if ((RANDOM() % tp_kill_base_cost) < cost && !Wizard(OWNER(victim))) { /* you killed him */ if (GETDROP(victim)) /* give him the drop message */ notify(player, GETDROP(victim)); else { snprintf(buf, sizeof(buf), "You killed %s!", NAME(victim)); notify(player, buf); } /* now notify everybody else */ if (GETODROP(victim)) { snprintf(buf, sizeof(buf), "%s killed %s! ", NAME(player), NAME(victim)); parse_oprop(descr, player, getloc(player), victim, MESGPROP_ODROP, buf, "(@Odrop)"); } else { snprintf(buf, sizeof(buf), "%s killed %s!", NAME(player), NAME(victim)); } notify_except(DBFETCH(DBFETCH(player)->location)->contents, player, buf, player); /* maybe pay off the bonus */ if (GETVALUE(victim) < tp_max_pennies) { snprintf(buf, sizeof(buf), "Your insurance policy pays %d %s.", tp_kill_bonus, tp_pennies); notify(victim, buf); SETVALUE(victim, GETVALUE(victim) + tp_kill_bonus); DBDIRTY(victim); } else { notify(victim, "Your insurance policy has been revoked."); } /* send him home */ send_home(descr, victim, 1); } else { /* notify player and victim only */ notify(player, "Your murder attempt failed."); snprintf(buf, sizeof(buf), "%s tried to kill you!", NAME(player)); notify(victim, buf); } break; } } }
void do_toad(int descr, dbref player, const char *name, const char *recip) { dbref victim; dbref recipient; dbref stuff; char buf[BUFFER_LEN]; if (!Wizard(player) || Typeof(player) != TYPE_PLAYER) { notify(player, "Only a Wizard player can turn a person into a toad."); return; } if ((victim = lookup_player(name)) == NOTHING) { notify(player, "That player does not exist."); return; } #ifdef GOD_PRIV if (God(victim)) { notify(player, "You cannot @toad God."); if(!God(player)) { log_status("TOAD ATTEMPT: %s(#%d) tried to toad God.",NAME(player),player); } return; } #endif if(player == victim) { /* If GOD_PRIV isn't defined, this could happen: we don't want the * last wizard to be toaded, in any case, so only someone else can * do it. */ notify(player, "You cannot toad yourself. Get someone else to do it for you."); return; } if (victim == tp_toad_default_recipient) { notify(player, "That player is part of the @toad process, and cannot be deleted."); return; } if (!*recip) { recipient = tp_toad_default_recipient; } else { if ((recipient = lookup_player(recip)) == NOTHING || recipient == victim) { notify(player, "That recipient does not exist."); return; } } if (Typeof(victim) != TYPE_PLAYER) { notify(player, "You can only turn players into toads!"); #ifdef GOD_PRIV } else if (!(God(player)) && (TrueWizard(victim))) { #else } else if (TrueWizard(victim)) { #endif notify(player, "You can't turn a Wizard into a toad."); } else { /* we're ok */ /* do it */ send_contents(descr, victim, HOME); dequeue_prog(victim, 0); /* Dequeue the programs that the player's running */ for (stuff = 0; stuff < db_top; stuff++) { if (OWNER(stuff) == victim) { switch (Typeof(stuff)) { case TYPE_PROGRAM: dequeue_prog(stuff, 0); /* dequeue player's progs */ if (TrueWizard(recipient)) { FLAGS(stuff) &= ~(ABODE | WIZARD); SetMLevel(stuff, 1); } case TYPE_ROOM: case TYPE_THING: case TYPE_EXIT: OWNER(stuff) = recipient; DBDIRTY(stuff); break; } } if (Typeof(stuff) == TYPE_THING && THING_HOME(stuff) == victim) { THING_SET_HOME(stuff, tp_lost_and_found); } } chown_macros(victim, recipient); if (PLAYER_PASSWORD(victim)) { free((void *) PLAYER_PASSWORD(victim)); PLAYER_SET_PASSWORD(victim, 0); } /* notify people */ notify(victim, "You have been turned into a toad."); snprintf(buf, sizeof(buf), "You turned %s into a toad!", NAME(victim)); notify(player, buf); log_status("TOADED: %s(%d) by %s(%d)", NAME(victim), victim, NAME(player), player); /* reset name */ delete_player(victim); snprintf(buf, sizeof(buf), "A slimy toad named %s", NAME(victim)); free((void *) NAME(victim)); NAME(victim) = alloc_string(buf); DBDIRTY(victim); boot_player_off(victim); /* Disconnect the toad */ if (PLAYER_DESCRS(victim)) { free(PLAYER_DESCRS(victim)); PLAYER_SET_DESCRS(victim, NULL); PLAYER_SET_DESCRCOUNT(victim, 0); } ignore_remove_from_all_players(victim); ignore_flush_cache(victim); FREE_PLAYER_SP(victim); ALLOC_THING_SP(victim); THING_SET_HOME(victim, PLAYER_HOME(player)); FLAGS(victim) = TYPE_THING; OWNER(victim) = player; /* you get it */ SETVALUE(victim, 1); /* don't let him keep his immense wealth */ } }
bool config_setLocation( int argc, const char *argv[], void *data ) { #define configSetLocation_RouteId 0 #define configSetLocation_StopId 1 #define configSetLocation_EntryPointId 2 #define configSetLocation_Unavailable 3 const char *rtId = argv[ configSetLocation_RouteId ]; const char *stopId = argv[ configSetLocation_StopId ]; const char *epId = argc >= ( configSetLocation_EntryPointId + 1 ) ? argv[ configSetLocation_EntryPointId ] : NULL; const char *locUnav = argc >= ( configSetLocation_Unavailable + 1 ) ? argv[ configSetLocation_Unavailable ] : NULL; bool ret = false; unsigned long id = 0; char waste = 0; MYKI_BR_ContextData_t *pContextData = GetCardProcessingThreadContextData(); IPC_IntPayload_t ipcSetLocation; int nLineId = pContextData->DynamicData.lineId; int nStopId = pContextData->DynamicData.stopId; int nEntryPointId = pContextData->DynamicData.entryPointId; bool locAvailable = true; int nResult = 0; int AppQueueId = IpcGetID( APP_TASK ); CsDebug( 9, ( 9, "Set location to %s, %s, %s, %s", ( rtId == NULL ? "(null)" : rtId ), ( stopId == NULL ? "(null)" : stopId ), ( epId == NULL ? "(null)" : epId ), ( locUnav == NULL ? "(null)" : locUnav ) ) ); memset( &ipcSetLocation, 0, sizeof( ipcSetLocation ) ); #define SETVALUE(INPUT, OUTPUT, MAXVALUE, DESC) \ if ( INPUT != 0 && INPUT[0] != '-' ) \ { \ if ( sscanf(INPUT, "%ld%c", &id, &waste) != 1 || id > (unsigned long)(MAXVALUE) ) \ { \ CsDebug(9, (9, "Invalid %s '%s'", DESC, INPUT)); \ } \ else \ { \ OUTPUT = id; \ CsDebug(9, (9, "Successfully set %s to '%s', %d", DESC, INPUT, int(OUTPUT))); \ ret = true; \ } \ } \ else \ { \ CsDebug(9, (9, "Default %s is %d", DESC, (int)OUTPUT)); \ } SETVALUE( rtId, nLineId, 0xffff, "route ID" ); SETVALUE( stopId, nStopId, 0xff, "stop ID" ); SETVALUE( epId, nEntryPointId, 0x7fffffff, "entry point ID" ); #undef SETVALUE if ( ret == true ) { pContextData->DynamicData.entryPointId = nEntryPointId; if ( locUnav != NULL ) { locAvailable = ( locUnav[ 0 ] == 't' || locUnav[ 0 ] == 'T' || /* [Tt]rue */ locUnav[ 0 ] == 'y' || locUnav[ 0 ] == 'Y' || /* [Yy]es */ locUnav[ 0 ] == '1' ) ? false : true; } ipcSetLocation.hdr.type = IPC_SET_LOCATION; ipcSetLocation.hdr.source = APP_TASK; ipcSetLocation.data = ( nLineId & 0x0000ffff ) | ( ( nStopId << 16 ) & 0x00ff0000 ) | ( ( locAvailable != false ? 0x80000000 : 0x00000000 ) ); if ( ( nResult = IpcSend( AppQueueId, &ipcSetLocation, sizeof( ipcSetLocation ) ) ) != 0 ) { CsErrx( "config_setLocation : IpcSend failed (%d)", nResult ); ret = false; } } return ret; }
int TestRefVal::execute() { bool lSuccess = true; if (MVTApp::startStore()) { ISession * const lSession = MVTApp::startSession(); const static int lNumProps = 25; PropertyID lPropIDs[lNumProps]; MVTApp::mapURIs(lSession,"TestRefVal.prop",lNumProps,lPropIDs); // Create a few pins with properties, collections, // and references to other properties or values. typedef std::set<StoreReference, SortByReferenced> TReferences; TReferences lReferences; int i, j, k; PID lPIDs[100]; for (i = 0; i < 100; i++) { CREATEPIN(lSession, &lPIDs[i], NULL, 0); IPIN * const lPIN = lSession->getPIN(lPIDs[i]); int const lNumProps = MVTRand::getRange(1, 20); for (j = 0; j < lNumProps; j++) { int const lNumVals = MVTRand::getRange(1, 5); for (k = 0; k < lNumVals; k++) { bool lDoReference = i > 0 && MVTRand::getRange(0, 10) > 3; // Either create a reference to some other property/value created earlier... if (lDoReference) { StoreReference lReference; lReference.mReferencing.id = lPIDs[i]; lReference.mReferencing.pid = lPropIDs[j]; lReference.mReferencing.eid = 0; // Choose a PIN to reference. int const lPINReferencedIndex = MVTRand::getRange(0, i-1); lReference.mReferenced.id = lPIDs[lPINReferencedIndex]; // Choose a property to reference. IPIN * lPINReferenced; bool lOLMethod = MVTRand::getRange(0, 100) > 33; if(lOLMethod){ lPINReferenced = lSession->getPIN(lReference.mReferenced.id); } else{ Value lVal; lVal.set(lReference.mReferenced.id); lPINReferenced = lSession->getPIN(lVal); } int lNumPINProps = (int)lPINReferenced->getNumberOfProperties(); unsigned int const lPropReferencedIndex = (unsigned int)MVTRand::getRange(0, lNumPINProps-1); Value const * const lPropReferenced = lPINReferenced->getValue(lPropIDs[lPropReferencedIndex]); lReference.mReferenced.pid = lPropReferenced->property; // Choose a value to reference, if relevant. if (lPropReferenced->type == VT_COLLECTION && !lPropReferenced->isNav()) { int const lValueReferencedIndex = MVTRand::getRange(0, (int)lPropReferenced->length-1); lReference.mReferenced.eid = lPropReferenced->varray[lValueReferencedIndex].eid; } else { lReference.mReferenced.eid = STORE_COLLECTION_ID; if(lPropReferenced->type == VT_COLLECTION) TVERIFY(false && "navigator returned even after setting session interface mode to ITF_COLLECTIONS_AS_ARRAYS"); } // Unless this exact same reference already exists, create it. if (lReferences.end() != lReferences.find(lReference)) lDoReference = false; else { Value lPV; SETVALUE(lPV, lPropIDs[j], lReference.mReferenced, OP_ADD); if (RC_OK != lPIN->modify(&lPV, 1)) { lSuccess = false; assert(false); } else lReferences.insert(lReference); } } // Or create a new property. if (!lDoReference) { Value lPV; Tstring lString; MVTRand::getString(lString, 20, 0, false); SETVALUE_C(lPV, lPropIDs[j], lString.c_str(), OP_ADD, STORE_LAST_ELEMENT); if (RC_OK != lPIN->modify(&lPV, 1)) { #if 0 lSuccess = false; assert(false); #endif } } } } lPIN->destroy(); } #if 0 // Note: Queries for VT_REFIDELT not supported yet... // Query to see if all relationships are found. TReferences::iterator lItRef; for (lItRef = lReferences.begin(); lReferences.end() != lItRef; lItRef++) { // Execute the mvstore query. IStmt * const lQ = lSession->createStmt(); unsigned char const lVar = lQ->addVariable(); Value lV[2]; PropertyID lPropIds[] = {(*lItRef).mReferencing.pid}; lV[0].setVarRef(0, *lPropIds); lV[1].set((*lItRef).mReferenced); TExprTreePtr lExprTree = EXPRTREEGEN(lSession)(OP_EQ, 2, lV, 0); lQ->addCondition(lExprTree); ICursor * const lQR = lQ->execute(); // Check that all objects found by the mvstore query are correct. IPIN * lQRIter; int lNumFound = 0; for (lQRIter = lQR->next(); NULL != lQRIter; lQRIter = lQR->next(), lNumFound++) { StoreReference lRef; lRef.mReferencing.id = lQRIter->getPID(); lRef.mReferencing.pid = (*lItRef).mReferencing.pid; lRef.mReferenced = (*lItRef).mReferenced; if (lReferences.end() == lReferences.find(lRef)) { lSuccess = false; mLogger.out() << "Query found a reference that did not exist!" << std::endl; } } // Check that the mvstore query found exactly the right number of objects. int lNumExpected = 0; TReferences::iterator lItRef2; StoreReference lRef; lRef.mReferenced = (*lItRef).mReferenced; INITLOCALPID(lRef.mReferencing.id); LOCALPID(lRef.mReferencing) = 0; lRef.mReferencing.pid = 0; lRef.mReferencing.eid = 0; for (lItRef2 = lReferences.lower_bound(lRef); lReferences.end() != lItRef2 && equalRefVIDs((*lItRef2).mReferenced, lRef.mReferenced); lItRef2++) if ((*lItRef2).mReferencing.pid == (*lItRef).mReferencing.pid) lNumExpected++; if (lNumFound != lNumExpected) { lSuccess = false; mLogger.out() << "Query found " << lNumFound << " referencing objects instead of " << lNumExpected << std::endl; } // Cleanup. lQR->destroy(); lQ->destroy(); } #endif lSession->terminate(); MVTApp::stopStore(); } else { TVERIFY(!"Unable to start store"); } return lSuccess ? 0 : 1; }
// Implement this test. int TestMergeCollections::execute() { bool lSuccess = true; if (MVTApp::startStore()) { ISession * const lSession = MVTApp::startSession(); // Declare properties. URIMap lData[2]; MVTApp::mapURIs(lSession,"TestMergeCollections.prop",2,lData); PropertyID const lPropIdVal = lData[0].uid; PropertyID const lPropIdRef = lData[1].uid; PropertyID const lPropIdPinId = PROP_SPEC_PINID; DataEventID lClassVal = STORE_INVALID_CLASSID; { char lB[100]; sprintf(lB,"TestMergeCollections.ClassVal.%d",rand()); Value lV[2]; lV[0].setVarRef(0,lPropIdVal); lV[1].setParam(0); IExprNode *expr=lSession->expr(OP_LT,2,lV); IStmt *lQ = lSession->createStmt(); lQ->addVariable(NULL,0,expr); TVERIFYRC(defineClass(lSession,lB,lQ,&lClassVal)); lQ->destroy(); } DataEventID lClassRef = STORE_INVALID_CLASSID; { char lB[100]; sprintf(lB,"TestMergeCollections.ClassRef.%d",rand()); IStmt *lQ = lSession->createStmt(); lQ->addVariable(); lQ->setPropCondition(0,&lPropIdRef,1); TVERIFYRC(defineClass(lSession,lB,lQ,&lClassRef)); lQ->destroy(); } /** * The following creates the family on reference class... **/ DataEventID lClassFamilyOnRef = STORE_INVALID_CLASSID; { char lB[100]; sprintf(lB,"TestMergeCollections.ClassFamilyOnRef.%d",rand()); Value lVFoR[2]; lVFoR[0].setVarRef(0,lPropIdRef); lVFoR[1].setParam(0); IExprNode *expr=lSession->expr(OP_IN,2,lVFoR); IStmt *lQ = lSession->createStmt(); lQ->addVariable(NULL,0,expr); TVERIFYRC(defineClass(lSession,lB,lQ,&lClassFamilyOnRef)); lQ->destroy(); } // Create a few pins mLogger.out() << "Creating " << NPINS*2 << " pins... "; PID pins[NPINS]; bool lfMember[NPINS]; PID refferedPins[NPINS]; //Creating first group of pins: // - each pin may have an interger value, or collection of interger values; // - each pin may have the same interger value within collection; // - if at least one of the values within pin < treshold, it should be picked up by the family... const int threshold = RANGE/3; int i; if(isVerbose()) mLogger.out() << " List of PINs with value less than threshold " << std::endl; for (i = 0; i < NPINS; i++) { Value lV[2]; int val = MVTRand::getRange(0, RANGE); lfMember[i] = val < threshold; SETVALUE(lV[0], lPropIdVal, val, OP_SET); CREATEPIN(lSession, &pins[i], lV, 1); IPIN *ppin = lSession->getPIN(pins[i]); int elemincollection = MVTRand::getRange(1, MAX_ELEM_INCOLLECTION); for(int jj = 0; jj < elemincollection; jj++) { int val2 = MVTRand::getRange(1, RANGE); if(!lfMember[i] && (val2 < threshold)) lfMember[i] = true; SETVALUE_C(lV[0], lPropIdVal, val2, OP_ADD, STORE_LAST_ELEMENT); TVERIFYRC(ppin->modify(lV,1)); } if(isVerbose() && lfMember[i]) mLogger.out() << std::hex << pins[i].pid << std::endl; ppin->destroy(); } // Create second group of pins: // - each pin within that group has either reference or collection of references // to a random pin(s) in the set above // - the reference to the pin, which value < threshold may be within any position within collection; // - it may be multiple references to the same pin, including the pin which value < threshold; if(isVerbose()) mLogger.out() << " List of PINs with refs whose value is less than threshold " << std::endl; int lCount = 0; int lCountDiff = 0; //counts how many pins with value < threshold has been added while creating collection... for (i = 0; i < NPINS; i++) { PID lReferPID; INITLOCALPID(lReferPID); lReferPID.pid = STORE_INVALID_PID; Value lV[2]; int idx = MVTRand::getRange(0, NPINS-1); PID id; bool willbefound = false; if (lfMember[idx]) { lCount++; willbefound = true; // The referenced pin will match the family query lReferPID = pins[idx]; } SETVALUE(lV[0], lPropIdRef, pins[idx], OP_SET); refferedPins[i] = pins[idx]; // to remember reffered pins; CREATEPIN(lSession, &id, lV, 1); IPIN *ppin = lSession->getPIN(id); int elemincollection = MVTRand::getRange(1, MAX_ELEM_INCOLLECTION); for(int jj = 0; jj < elemincollection; jj++) { int idx1 = MVTRand::getRange(0, NPINS-1); SETVALUE_C(lV[0], lPropIdRef, pins[idx1], OP_ADD, STORE_LAST_ELEMENT); TVERIFYRC(ppin->modify(lV,1)); if(!willbefound && lfMember[idx1]) { lCount++; willbefound = true; lReferPID = pins[idx1]; lCountDiff++; } } if(isVerbose() && willbefound) mLogger.out() << std::hex << id.pid << " with ref to " << lReferPID.pid << std::endl; ppin->destroy(); } mLogger.out() << std::dec << "DONE" << std::endl; // Do a simple join search. // " All pins from lClassFamilyOnRef Family, where any of the PINs in lPropIdRef has (lPropIdVal < threshhold) // "All pins, from lClassRef class, where the lPropIdRef property is equal // to the PROP_SPEC_PINID of a PIN matching the lClassVal query of (lPropIdVal < threshhold)" // IStmt *lQ = lSession->createStmt(); Value lV[4]; lV[0].setError(lPropIdRef); lV[1].setError(lPropIdRef); lV[2].setRange(&lV[0]); lV[3].set(threshold); // Family query will find all pins with lPropIdVal < threshhold SourceSpec classSpec[2]={{lClassFamilyOnRef,1,&lV[2]},{lClassVal,1,&lV[3]}}; unsigned char lVar1 = lQ->addVariable(&classSpec[0],1),lVar2 = lQ->addVariable(&classSpec[1],1); lV[0].setVarRef(lVar1,lPropIdRef); lV[1].setVarRef(lVar2,lPropIdPinId); IExprNode *expr = lSession->expr(OP_EQ,2,lV); lQ->join(lVar1,lVar2,expr); OrderSeg ord={NULL,lPropIdRef,0,0,0}; lQ->setOrder(&ord,1); uint64_t lCnt = 0; TVERIFYRC(lQ->count(lCnt,NULL,0,~0u)); TVERIFY((int)lCnt == lCount); { mLogger.out() << "Count returned = " << lCnt << "; Expected Count = " << lCount << "; lCountDiff = " << lCountDiff << ";" << std::endl; //The query below - attempt to find how many pins with at least one value < threshold were found by Family... mLogger.out() << "The query below - attempt to find how many pins with at least one value < threshold were found by Family..." << std::endl; IStmt *lQFamily = lSession->createStmt(); lQFamily->addVariable(&classSpec[1],1); uint64_t lCntFFound = 0; TVERIFYRC(lQFamily->count(lCntFFound)); mLogger.out() << "lCntFFound= " << lCntFFound << ";" << std::endl; lQFamily->destroy(); } ICursor *lR = NULL; TVERIFYRC(lQ->execute(&lR, NULL,0,~0u,0)); int lResultCount = 0; IPIN *pInResults; if (isVerbose()) mLogger.out() << "List of PINs returned " << std::endl; while((pInResults=lR->next())!=NULL) { lResultCount++; //if (isVerbose()) MVTApp::output(*pInResults,mLogger.out()); if (isVerbose()) mLogger.out() << std::hex << pInResults->getPID().pid << std::endl; const Value * refVal = pInResults->getValue(lPropIdRef); if ( refVal!=NULL ) { MvStoreEx::CollectionIterator lCollection(refVal); bool lBelongs = false; const Value *lValue; for(lValue = lCollection.getFirst(); lValue!=NULL; lValue = lCollection.getNext()) { TVERIFY(lValue->type == VT_REFID); IPIN *lPIN = lSession->getPIN(lValue->id); TVERIFY(lPIN != NULL); const Value *lVal = lPIN->getValue(lPropIdVal); MvStoreEx::CollectionIterator lValues(lVal); const Value *lVal1; for(lVal1 = lValues.getFirst(); lVal1!=NULL; lVal1 = lValues.getNext()) { TVERIFY(lVal1->type == VT_INT); if(lVal1->i < threshold) { lBelongs = true; break; } } lPIN->destroy(); if(lBelongs) break; } TVERIFY(lBelongs && "Unexpected PIN returned"); } else { TVERIFY(false && "Failed to fetch the collection"); } pInResults->destroy(); } mLogger.out() << " Total PINs returned in the result set " << std::dec << lResultCount << std::endl; TVERIFY(lResultCount == lCount); lR->destroy(); lQ->destroy(); lSession->terminate(); MVTApp::stopStore(); } else { TVERIFY(!"could not open store") ; } return lSuccess ? 0 : 1; }
static int Set(advanced* p, int No, const void* Data, int Size) { int Result = ERR_INVALID_PARAM; switch (No) { case ADVANCED_OLDSHELL: SETVALUE(p->OldShell,bool_t,ERR_NONE); break; case ADVANCED_HOMESCREEN: SETVALUE(p->HomeScreen,bool_t,ERR_NONE); break; case ADVANCED_NOBACKLIGHT: SETVALUE(p->NoBackLight,bool_t,ERR_NONE); break; case ADVANCED_VR41XX: SETVALUE(p->VR41XX,bool_t,ERR_NONE); break; case ADVANCED_IDCTSWAP: SETVALUECMP(p->IDCTSwap,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_NOWMMX: SETVALUE(p->NoWMMX,bool_t,ERR_NONE); break; case ADVANCED_BLINKLED: SETVALUE(p->BlinkLED,bool_t,ERR_NONE); break; case ADVANCED_NODEBLOCKING: SETVALUECMP(p->NoDeblocking,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_PRIORITY: SETVALUECMP(p->Priority,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_SYSTEMVOLUME: SETVALUECMP(p->SystemVolume,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_SLOW_VIDEO: SETVALUECMP(p->SlowVideo,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_COLOR_LOOKUP: SETVALUECMP(p->ColorLookup,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_DROPTOL: SETVALUECMP(p->DropTolerance,tick_t,NodeSettingsChanged(),EqInt); break; case ADVANCED_SKIPTOL: SETVALUECMP(p->SkipTolerance,tick_t,NodeSettingsChanged(),EqInt); break; case ADVANCED_AVOFFSET: SETVALUECMP(p->AVOffset,tick_t,NodeSettingsChanged(),EqInt); break; case ADVANCED_BENCHFROMPOS: SETVALUE(p->BenchFromPos,bool_t,ERR_NONE); break; case ADVANCED_AVIFRAMERATE: SETVALUECMP(p->AviFrameRate,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_WIDCOMMAUDIO: SETVALUE(p->WidcommAudio,bool_t,ERR_NONE); break; case ADVANCED_KEYFOLLOWDIR: SETVALUE(p->KeyFollowDir,bool_t,ERR_NONE); break; case ADVANCED_WAVEOUTPRIORITY: SETVALUECMP(p->WaveoutPriority,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_MEMORYOVERRIDE: SETVALUECOND(p->MemoryOverride,bool_t,ERR_NONE,MemGetInfo(NULL)); break; case ADVANCED_NOBATTERYWARNING: SETVALUE(p->NoBatteryWarning,bool_t,ERR_NONE); break; case ADVANCED_NOEVENTCHECKING: SETVALUECMP(p->NoEventChecking,bool_t,NodeSettingsChanged(),EqBool); break; case ADVANCED_CARDPLUGINS: SETVALUE(p->CardPlugins,bool_t,ERR_NONE); break; case ADVANCED_WIDCOMMDLL: assert(Size==sizeof(bool_t)); if (p->WidcommDLL && !*(bool_t*)Data) p->WidcommAudio = 1; break; } return Result; }
void TestAbortQuery::quickTest() { CmvautoPtr<IStmt> lQ(mSession->createStmt()); unsigned char lVar = lQ->addVariable(); IExprNode *lET; { Value lV[2]; lV[0].setVarRef(0,mPropIDs[0]); lV[1].set(10000); IExprNode *lET1 = mSession->expr(OP_LT, 2, lV); lV[0].setVarRef(0,mPropIDs[4]); lV[1].set(10); IExprNode *lET2 = mSession->expr(OP_GT, 2, lV); lV[0].set(lET1); lV[1].set(lET2); IExprNode *lET3 = mSession->expr(OP_LAND, 2, lV); lV[0].setVarRef(0,mPropIDs[1]); lV[1].set("a"); IExprNode *lET4 = mSession->expr(OP_CONTAINS, 2, lV, CASE_INSENSITIVE_OP); lV[0].set(lET3); lV[1].set(lET4); lET = mSession->expr(OP_LAND, 2, lV); } lQ->addCondition(lVar,lET); lET->destroy(); uint64_t lCount = 0; ICursor *lRes; setAbortQ(); for(int i = 0;i<nTimes;i++) { TVERIFYRC(lQ->execute(&lRes)); if( (RC_TIMEOUT == lQ->count(lCount)) && (NULL == lRes) ) cnt++; } mLogger.print("lQ->count(lCount)\n"); mLogger.print("lQ->execute()\n"); TVERIFY(cnt > 0); if(lRes) lRes->destroy(); resetAbortQ(); ICursor *lR; unsigned long lResultCount = 0; TVERIFYRC(lQ->count(lCount)); TVERIFYRC(lQ->execute(&lR)); if(lR) { for(IPIN *lPIN = lR->next(); lPIN != NULL; lPIN = lR->next(), lResultCount++) lPIN->destroy(); lR->destroy(); }else TVERIFY(false && "NULL ICursor returned"); TVERIFY(lResultCount < lCount || lResultCount == lCount); //Values to be used by copyPINs,modifyPINs calls. Value lV[8]; lV[0].setNow(); SETVATTR(lV[0], mPropIDs[7], OP_SET); IStream *lStream = new TestStringStream(MVTRand::getRange(10, 30) * 1024); SETVALUE(lV[1], mPropIDs[8], MVTApp::wrapClientStream(mSession, lStream), OP_SET); IStream *lStream1 = new TestStringStream(MVTRand::getRange(10, 30) * 1024); SETVALUE(lV[2], mPropIDs[9], MVTApp::wrapClientStream(mSession, lStream1), OP_SET); SETVALUE(lV[3], mPropIDs[10], MVTRand::getRange(10, 100), OP_SET); Tstring lStr; MVTRand::getString(lStr, 10, 100, true, false); SETVALUE(lV[4], mPropIDs[11], lStr.c_str(), OP_SET); SETVALUE(lV[5], mPropIDs[12], lStr.c_str(), OP_SET); Tstring lWStr; MVTRand::getString(lWStr, 10, 100, true, false); SETVALUE(lV[6], mPropIDs[13], lWStr.c_str(), OP_SET); double lDouble = (double)MVTRand::getRange(10, 1000); SETVALUE(lV[7], mPropIDs[14], lDouble, OP_SET); IStmt *lModQ = lQ->clone(STMT_UPDATE); lModQ->setValues(lV,8); IStmt *lDelQ = lQ->clone(STMT_DELETE); setAbortQ(); for(int i = 0; i<nTimes; i++) if((RC_TIMEOUT == lModQ->execute()) && (RC_TIMEOUT == lDelQ->execute())) cnt++; mLogger.print("lQ->modifyPINs(lV, 8)\n"); TVERIFY(cnt>0); resetAbortQ(); TVERIFYRC(lModQ->execute()); TVERIFYRC(lDelQ->execute()); lModQ->destroy(); lDelQ->destroy(); setAbortQ(); IStmt *lUDelQ = lQ->clone(STMT_UNDELETE); cnt = 0; for(int i = 0; i<nTimes; i++) if(RC_TIMEOUT == lUDelQ->execute()) cnt++; mLogger.print("lQ->undeletePINs()\n"); TVERIFY(cnt>0); resetAbortQ(); TVERIFYRC(lUDelQ->execute()); lUDelQ->destroy(); setAbortQ(); IStmt *lCopyQ = lQ->clone(STMT_INSERT); lCopyQ->setValues(lV,8); for(int i = 0; i<nTimes; i++) if(RC_TIMEOUT == lCopyQ->execute()) cnt++; mLogger.print("lQ->copyPINs(lV,8)\n"); TVERIFY(cnt>0); lCopyQ->destroy(); mStop = true; }
THREAD_SIGNATURE TestCustom59::threadTestCustom59(void * pC) { testCustom59_s * const lC = (testCustom59_s *)pC; ISession * const lSession = MVTApp::startSession(lC->mTest.mStoreCtx); lC->mThreadId = (long int)getThreadId(); bool lFreeRun = false; long lFreeStep; long volatile * lStepPtr = &lC->mTest.mStep; while (*lStepPtr < lC->mNumSteps) { RC lRC = RC_OK; Value lV[2]; SETVALUE(lV[0], lC->mTest.mPropIds[0], "pomme poire banane", OP_SET); SETVALUE_C(lV[1], lC->mTest.mPropIds[1], (int)lC->mThreadId, OP_ADD, STORE_LAST_ELEMENT); lV[0].meta = lV[1].meta = META_PROP_FTINDEX; long const lStepIndex = *lStepPtr; TestCustom59::eSteps const lStep = lC->mSteps[lStepIndex]; if (TestCustom59::kSLastSynchroStep < lStep) { lC->mTest.mOutputLock.lock(); lC->mTest.logLineHeader(lC->mThreadIndex); lC->mTest.getLogger().out() << "step #" << std::dec << lStepIndex << ":"; lC->mTest.getLogger().out() << lC->mTest.stepName(lStep); lC->mTest.getLogger().out() << std::endl; lC->mTest.mOutputLock.unlock(); } switch (lStep) { case TestCustom59::kSWaiting: if (!lFreeRun) lC->mTest.nextStep(lStepIndex); break; case TestCustom59::kSSleepAndGo: { MVTestsPortability::threadSleep(1000); if (!lFreeRun) { lFreeStep = lC->mTest.detachStepping(lC->mDetachedStepping); lStepPtr = &lFreeStep; lFreeRun = true; } lFreeStep++; break; } case TestCustom59::kSSleep: MVTestsPortability::threadSleep(1000); lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSStartTx: lSession->startTransaction(); lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSCommitTx: lRC = lSession->commit(); lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSRead1: if (NULL == lSession->getPIN(lC->mTest.mPID1)) lC->mDeadlocked = true; lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSRead2: if (NULL == lSession->getPIN(lC->mTest.mPID2)) lC->mDeadlocked = true; lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSRead3: if (NULL == lSession->getPIN(lC->mTest.mPID3)) lC->mDeadlocked = true; lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSWrite1: lRC = lSession->modifyPIN(lC->mTest.mPID1, lV, 2); lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSWrite2: lRC = lSession->modifyPIN(lC->mTest.mPID2, lV, 2); lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSWrite3: lRC = lSession->modifyPIN(lC->mTest.mPID3, lV, 2); lC->mTest.nextStep(lFreeRun, lFreeStep); break; case TestCustom59::kSQuickCheckFTIndexingIsolation: { IStmt * lQWord = lSession->createStmt(); unsigned char lVar = lQWord->addVariable(); lQWord->setConditionFT(lVar, "poire"); ICursor * lRWord = NULL; lQWord->execute(&lRWord); if (lRWord) { IPIN * lNext; while (NULL != (lNext = lRWord->next())) { if (lC->mTest.mPID1 == lNext->getPID() || lC->mTest.mPID2 == lNext->getPID() || lC->mTest.mPID3 == lNext->getPID()) { lC->mTest.mOutputLock.lock(); lC->mTest.logLineHeader(lC->mThreadIndex); lC->mTest.getLogger().out() << "WARNING: FT found pin " << std::hex << lNext->getPID().pid << std::endl; lC->mTest.mOutputLock.unlock(); } lNext->destroy(); } lRWord->destroy(); } else { lC->mTest.logLineHeader(lC->mThreadIndex); lC->mTest.getLogger().out() << "WARNING: Couldn't obtain a query result!?" << std::endl; } lQWord->destroy(); lC->mTest.nextStep(lFreeRun, lFreeStep); break; } default: assert(false); break; } if (RC_DEADLOCK == lRC) lC->mDeadlocked = true; else if (RC_OK != lRC) { lC->mTest.mOutputLock.lock(); lC->mTest.logLineHeader(lC->mThreadIndex); lC->mTest.getLogger().out() << "Failure " << std::dec << lRC << std::endl; lC->mTest.mOutputLock.unlock(); } if (lC->mDeadlocked) { lSession->rollback(); // Review: This will not be needed later on. lC->mTest.mOutputLock.lock(); lC->mTest.logLineHeader(lC->mThreadIndex); lC->mTest.getLogger().out() << "DEADLOCKED" << std::endl; lC->mTest.mOutputLock.unlock(); lC->mTest.detachStepping(lC->mDetachedStepping); lFreeStep = lC->mNumSteps; lStepPtr = &lFreeStep; lFreeRun = true; } } lC->mTest.detachStepping(lC->mDetachedStepping); lC->mTest.mOutputLock.lock(); lC->mTest.logLineHeader(lC->mThreadIndex); lC->mTest.getLogger().out() << "done" << std::endl; lC->mTest.mOutputLock.unlock(); lSession->terminate(); return 0; }