UtlContainable* UtlSListIterator::peekAtNext(void) { UtlContainable* match = NULL; UtlContainer::acquireIteratorConnectionLock(); OsLock takeContainer(mContainerRefLock); UtlSList* myList = dynamic_cast<UtlSList*>(mpMyContainer); if (myList != NULL) // list still valid? { OsLock take(myList->mContainerLock); UtlContainer::releaseIteratorConnectionLock(); // advance the iterator UtlLink* nextLink = (mpCurrentNode == NULL ? myList->head() : mpCurrentNode->next() ); if( nextLink ) { match = (UtlContainable*)nextLink->data; } } else { UtlContainer::releaseIteratorConnectionLock(); } return match; }
void testNoRouteLocal() { const char* message = "INVITE sip:[email protected] SIP/2.0\r\n" "Via: SIP/2.0/TCP 10.1.1.3:33855\r\n" "To: sip:[email protected]\r\n" "From: Caller <sip:[email protected]>; tag=30543f3483e1cb11ecb40866edd3295b\r\n" "Call-Id: f88dfabce84b6a2787ef024a7dbe8749\r\n" "Cseq: 1 INVITE\r\n" "Max-Forwards: 20\r\n" "Contact: [email protected]\r\n" "Content-Length: 0\r\n" "\r\n"; SipMessage testMsg(message, strlen(message)); Url requestUri; UtlSList removedRoutes; testMsg.normalizeProxyRoutes(UserAgent, requestUri, &removedRoutes); UtlString normalizedMsg; int msgLen; testMsg.getBytes(&normalizedMsg, &msgLen); ASSERT_STR_EQUAL(message, normalizedMsg.data()); UtlString requestUriResult; requestUri.toString(requestUriResult); ASSERT_STR_EQUAL("sip:[email protected]", requestUriResult.data()); CPPUNIT_ASSERT(removedRoutes.isEmpty()); }
OsStatus CpNotificationRegister::unsubscribe(CP_NOTIFICATION_TYPE notificationType, const SipDialog& callbackSipDialog) { OsStatus result = OS_FAILED; UtlInt key((int)notificationType); UtlSList* pDialogList = dynamic_cast<UtlSList*>(m_register.findValue(&key)); if (!pDialogList) { return OS_SUCCESS; } if (pDialogList) { UtlSListIterator itor(*pDialogList); while (itor()) { SipDialog* pSipDialog = dynamic_cast<SipDialog*>(itor.item()); if (pSipDialog && pSipDialog->compareDialogs(callbackSipDialog) != SipDialog::DIALOG_MISMATCH) { pDialogList->destroy(pSipDialog); } } result = OS_SUCCESS; } return result; }
/*!a Test the occurancesOf() method . * * The test data for this test are :- * a) When the search data is the first entry * b) When the search data is the last entry * c) When the search data is the mid(unique) entry * d) When the search data has a matching value but not ref. * e) When the search data has multiple matches - mixture of ref / values * f) When the search data has no match at all. */ void testOccurancesOf() { const int testCount = 6 ; const char* prefix = "Test the occurancesOf(UtlContainable* cl); where cl " ; const char* Msgs[] = { \ "is the first entry ", \ "is the last entry and ref matches ", \ "is the mid entry and is unique ", \ "has a matching value but not reference ", \ "has multiple matches ", \ "has no match at all " \ } ; commonList.insertAt(3, commonContainables_Clone[4]) ; commonList.insertAt(5, commonContainables[4]) ; UtlString notExistCollectable("This cannot and willnot exist"); UtlContainable* searchValues[] = { \ commonContainables[0], commonContainables[commonEntriesCount -1], \ commonContainables[2], commonContainables_Clone[3], \ commonContainables[4], ¬ExistCollectable \ } ; int matchCount[] = { 1, 1, 1, 1, 3, 0 } ; for (int i = 0 ; i < testCount ; i++) { string msg ; TestUtilities::createMessage(2, &msg, prefix, Msgs[i]) ; int actual = commonList.occurrencesOf(searchValues[i]) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), matchCount[i], actual) ; } } //testOccurancesOf
void testUpdateExistingBinding() { UtlSList bindings; RegistrationBinding* binding; RegistrationDbTestContext testDbContext(TEST_DATA_DIR "/regdbdata", TEST_WORK_DIR "/regdbdata" ); testDbContext.inputFile("updateBindings.xml"); RegistrationDB* regDb = RegistrationDB::getInstance(); // Get an existing binding Int64 seqOneUpdates = regDb->getNewUpdatesForRegistrar("seqOne", 2, bindings); CPPUNIT_ASSERT_EQUAL(1LL, seqOneUpdates); binding = (RegistrationBinding*)bindings.first(); // Increment the CSeq number int newCseq = binding->getCseq() + 1; binding->setCseq(newCseq); regDb->updateBinding(*binding); binding->setCseq(0); // Get the same binding bindings.destroyAll(); seqOneUpdates = regDb->getNewUpdatesForRegistrar("seqOne", 2, bindings); CPPUNIT_ASSERT_EQUAL(1LL, seqOneUpdates); // Test if the new CSeq number got updated binding = (RegistrationBinding*)bindings.first(); CPPUNIT_ASSERT_EQUAL(newCseq, binding->getCseq()); }
/*!a Test case to test the destroyAll() * method. */ void testClearAndDestroy() { const char* prefix = "test the destroyAll() method " ; const char* suffix1 = ":- Verify that all entries are removed" ; const char* suffix2 = ":- The objects are deleted" ; UtlContainableTestStub* uStub ; UtlContainableTestStub* uStubPtr ; uStub = new UtlContainableTestStub(0) ; uStubPtr = new UtlContainableTestStub(1) ; emptyList.append(uStub) ; emptyList.append(uStubPtr) ; emptyList.destroyAll() ; int cCountAfter = UtlContainableTestStub::getCount() ; string msg ; TestUtilities::createMessage(2, &msg, prefix, suffix1) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), 0, (int)emptyList.entries()) ; // Since the TestStub has been implemented such that destructor // decrements the static counter, to verify that the objects have // been deleted, verify that the static counter has been decremented. TestUtilities::createMessage(2, &msg, prefix, suffix2) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), 0, cCountAfter) ; } //testClearAndDestroy
void RegistrationDB::getUnexpiredContactsFieldsContaining ( UtlString& substringToMatch, const int& timeNow, UtlSList& matchingContactFields ) const { // Clear the results matchingContactFields.destroyAll(); if( m_pFastDB != NULL ) { SMART_DB_ACCESS; dbCursor< RegistrationRow > cursor; UtlString queryString = "contact like '%" + substringToMatch + "%' and expires>"; queryString.appendNumber( timeNow ); dbQuery query; query = queryString; if ( cursor.select(query) > 0 ) { // Copy all the unexpired contacts into the result list do { UtlString* contactValue = new UtlString(cursor->contact); matchingContactFields.append( contactValue ); } while ( cursor.next() ); } } else { OsSysLog::add(FAC_DB, PRI_CRIT, "RegistrationDB::getUnexpiredContactsFieldsContaining failed - no DB"); } }
// Find the next like-instance of the designated object . UtlContainable* UtlSListIterator::findNext(const UtlContainable* containableToMatch) { UtlContainable* match = NULL; UtlContainer::acquireIteratorConnectionLock(); OsLock takeContainer(mContainerRefLock); UtlSList* myList = static_cast<UtlSList*>(mpMyContainer); OsLock take(myList->mContainerLock); UtlContainer::releaseIteratorConnectionLock(); // advance the iterator UtlLink* nextLink = (mpCurrentNode == NULL ? myList->head() : mpCurrentNode->next() ); // search for the next match forward while (nextLink && !match) { UtlContainable *candidate = (UtlContainable*)nextLink->data; if (candidate && candidate->compareTo(containableToMatch) == 0) { mpCurrentNode = nextLink; match = candidate; } else { nextLink = nextLink->next(); } } return match; }
void testUpdateExistingUriNewContact() { UtlSList bindings; RegistrationBinding* binding; RegistrationDbTestContext testDbContext(TEST_DATA_DIR "/regdbdata", TEST_WORK_DIR "/regdbdata" ); testDbContext.inputFile("updateBindings.xml"); RegistrationDB* regDb = RegistrationDB::getInstance(); // Get an existing binding Int64 seqOneUpdates = regDb->getNewUpdatesForRegistrar("seqOne", 2, bindings); CPPUNIT_ASSERT_EQUAL(1LL, seqOneUpdates); binding = (RegistrationBinding*)bindings.first(); // Change the contact address const UtlString* oldContact = binding->getContact(); UtlString newContact(*oldContact); newContact.replace('2', '3'); binding->setContact(newContact); regDb->updateBinding(*binding); // We should have 2 bindings now bindings.destroyAll(); seqOneUpdates = regDb->getNewUpdatesForRegistrar("seqOne", 2, bindings); CPPUNIT_ASSERT_EQUAL(2LL, seqOneUpdates); }
void testUpdateSameBinding() { UtlSList bindings; RegistrationBinding* binding; RegistrationDbTestContext testDbContext(TEST_DATA_DIR "/regdbdata", TEST_WORK_DIR "/regdbdata" ); testDbContext.inputFile("updateBindings.xml"); RegistrationDB* regDb = RegistrationDB::getInstance(); // Get an existing binding Int64 seqOneUpdates = regDb->getNewUpdatesForRegistrar("seqOne", 2, bindings); CPPUNIT_ASSERT_EQUAL(1LL, seqOneUpdates); binding = (RegistrationBinding*)bindings.first(); // Call updateBinding with the same binding regDb->updateBinding(*binding); // Get it back and make sure we still only have one bindings.destroyAll(); seqOneUpdates = regDb->getNewUpdatesForRegistrar("seqOne", 2, bindings); CPPUNIT_ASSERT_EQUAL(1LL, seqOneUpdates); }
/*!a Test case to test the destroy() * method. */ void testRemoveAndDestroy() { const char* prefix = "test the destroy() method " ; UtlContainableTestStub uStub(0) ; UtlContainableTestStub* uStubPtr ; uStubPtr = new UtlContainableTestStub(1) ; commonList.append(&uStub) ; commonList.append(uStubPtr) ; int cCountBefore = UtlContainableTestStub :: getCount() ; UtlBoolean returnValue = commonList.destroy(uStubPtr) ; UtlContainable* uLast = commonList.last() ; string msg ; TestUtilities::createMessage(2, &msg, prefix, ":- Verify the return value") ; CPPUNIT_ASSERT_MESSAGE(msg.data(), returnValue) ; TestUtilities::createMessage(2, &msg, prefix, ":- Verify that the entry is removed") ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), (void*)&uStub, (void*)uLast) ; // The CollectableTestStub has been implemented such that a static counter gets decremented // for every descruction of an object instance. To verify that the object was destroyed, // verify that the static count went down. int cCountAfter = UtlContainableTestStub :: getCount() ; TestUtilities::createMessage(2, &msg, prefix, ":- Verify that the object was deleted") ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), cCountBefore -1, cCountAfter) ; }
void XmlRpcResponse::cleanUp(UtlContainable* value) { if (value) { if (value->isInstanceOf(UtlHashMap::TYPE)) { UtlHashMap* map = dynamic_cast<UtlHashMap*>(value); UtlHashMapIterator iterator(*map); UtlString* key; while ((key = dynamic_cast<UtlString*>(iterator()))) { UtlContainable *pName; UtlContainable *member; pName = map->removeKeyAndValue(key, member); delete pName; cleanUp(member); } } else if (value->isInstanceOf(UtlSList::TYPE)) { UtlSList* array = dynamic_cast<UtlSList*>(value); UtlContainable *element; while ((element = array->get()/* pop */)) { cleanUp(element); } } delete value; } }
/*!a Test case for the findNext() method * * The test data for this test case are :- * a) When the match is the first element. * b) When the match is the last element. * c) When the match is a mid element(unique). * d) When the match has two value matches (but a single ref match) * e) When the match has two ref matches. * f) When there is no match at all! * g) When the match is after the current find. */ void testFindNext() { struct TestFindNextStruct { const char* testDescription ; const UtlContainable* searchValue ; const UtlContainable* expectedValue ; } ; const char* prefix = "Test the find() method when the match " ; UtlString noExist("This cannot and should not exist!!!") ; TestFindNextStruct testData[] = { \ { "is the first element ", commonContainables[0], commonContainables[0] }, \ { "is the last element ", commonContainables[5], commonContainables[5] }, \ { "is a mid element (unique match) ", commonContainables[2], \ commonContainables[2] }, \ { "has two value matches but a single ref match ", commonContainables[4], \ commonContainables_Clone[4] }, \ { "has two ref matches", commonContainables[3], commonContainables[3] }, \ { "has a value match but no ref match", commonContainables_Clone[1], \ commonContainables[1] }, \ { "has no match at all", &noExist, NULL } \ } ; // insert a clone of the 4th element to the 1st position commonList.insertAt(1, (UtlContainable*)commonContainables_Clone[4]) ; // The new index for a value match of commonContainables[4] must be 1. // insert another copy of the 3rd element to the 2nd position. commonList.insertAt(2, (UtlContainable*)commonContainables[3]) ; // The new index for commonContainables[3] must be 2) ; // what used to be the second element has now moved to 4. const int testCount = sizeof(testData)/sizeof(testData[0]) ; UtlSListIterator iter(commonList) ; for (int i = 0 ; i < testCount ; i++) { string msg ; const UtlContainable* actualValue = iter.findNext(testData[i].searchValue) ; TestUtilities::createMessage(2, &msg, prefix, testData[i].testDescription) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), testData[i].expectedValue, \ actualValue) ; iter.reset() ; } // Now test the case where the iterator is 'past' the index iter.reset() ; iter() ; iter() ; iter() ; iter() ; iter() ; UtlContainable* actualValue = iter.findNext(commonContainables[1]) ; CPPUNIT_ASSERT_EQUAL_MESSAGE("test findNext() when the iterator has " \ "moved past the search index", (void*)NULL, (void*)actualValue) ; }//testFindNext
void getCountItems(UtlSList& list, size_t itemsToPop) { assert(itemsToPop); for (; !list.isEmpty() && itemsToPop; itemsToPop--) { delete dynamic_cast<UtlString*>(list.get()); } }
void testDoubleRoute() { const char* message = "INVITE sip:[email protected] SIP/2.0\r\n" "Route: <sip:[email protected];lr>, <sip:[email protected];lr>\r\n" "Via: SIP/2.0/TCP 10.1.1.3:33855\r\n" "To: sip:[email protected]\r\n" "From: Caller <sip:[email protected]>; tag=30543f3483e1cb11ecb40866edd3295b\r\n" "Call-Id: f88dfabce84b6a2787ef024a7dbe8749\r\n" "Cseq: 1 INVITE\r\n" "Max-Forwards: 20\r\n" "Contact: [email protected]\r\n" "Content-Length: 0\r\n" "\r\n"; SipMessage testMsg(message, strlen(message)); Url requestUri; UtlSList removedRoutes; testMsg.normalizeProxyRoutes(UserAgent, requestUri, &removedRoutes); UtlString normalizedMsg; int msgLen; testMsg.getBytes(&normalizedMsg, &msgLen); const char* expectedMessage = // route header removed, uri swapped "INVITE sip:[email protected] SIP/2.0\r\n" "Via: SIP/2.0/TCP 10.1.1.3:33855\r\n" "To: sip:[email protected]\r\n" "From: Caller <sip:[email protected]>; tag=30543f3483e1cb11ecb40866edd3295b\r\n" "Call-Id: f88dfabce84b6a2787ef024a7dbe8749\r\n" "Cseq: 1 INVITE\r\n" "Max-Forwards: 20\r\n" "Contact: [email protected]\r\n" "Content-Length: 0\r\n" "\r\n"; ASSERT_STR_EQUAL(expectedMessage, normalizedMsg.data()); UtlString requestUriResult; requestUri.toString(requestUriResult); ASSERT_STR_EQUAL("sip:[email protected]", requestUriResult.data()); UtlString* removedRoute; CPPUNIT_ASSERT( removedRoute = static_cast<UtlString*>(removedRoutes.get())); ASSERT_STR_EQUAL("<sip:[email protected];lr>", removedRoute->data()); delete removedRoute; CPPUNIT_ASSERT( removedRoute = static_cast<UtlString*>(removedRoutes.get())); ASSERT_STR_EQUAL("<sip:[email protected];lr>", removedRoute->data()); delete removedRoute; CPPUNIT_ASSERT(removedRoutes.isEmpty()); }
void doListOperations() { UtlSList testList; // fill the list appendCountItems(testList, NUM_PERFORMANCE_STRINGS); // take the first half off the front if (!testList.isEmpty()) { getCountItems(testList, NUM_PERFORMANCE_STRINGS / 2); } // take the rest off the end by reference if (!testList.isEmpty()) { UtlContainable* lastItem = testList.last(); delete dynamic_cast<UtlString*>(testList.removeReference(lastItem)); } // fill the list appendCountItems(testList, NUM_PERFORMANCE_STRINGS); // search the list for each item by value UtlString target; int targetIndex; for (targetIndex = 0; targetIndex < NUM_PERFORMANCE_STRINGS; targetIndex += 1) { target = string[targetIndex]; UtlString* found = dynamic_cast<UtlString*>(testList.find(&target)); if (found) { externalForSideEffects = found->length(); } } // get the object in the middle of the list by index, and remove it by value while(!testList.isEmpty()) { int numberLeft = testList.entries(); UtlString* middle = dynamic_cast<UtlString*>(testList.at((numberLeft / 2))); delete dynamic_cast<UtlString*>(testList.remove(middle)); } // fill the list appendCountItems(testList, NUM_PERFORMANCE_STRINGS); // iterate over each item in the list UtlSListIterator iterate(testList); UtlString* item; while ((item = dynamic_cast<UtlString*>(iterate()))) { externalForSideEffects = item->length(); delete item; } }
UtlBoolean DialByNameDB::insertRow ( const Url& contact ) const { UtlBoolean result = FALSE; if ( m_pFastDB != NULL ) { // Fetch the display name UtlString identity, displayName, contactString; contact.getIdentity( identity ); contact.getDisplayName( displayName ); contact.toString( contactString ); // Make sure that the contact URL is valid and contains // a contactIdentity and a contactDisplayName if ( !identity.isNull() && !displayName.isNull() ) { UtlSList dtmfStrings; getDigitStrings ( displayName, dtmfStrings ); if ( !dtmfStrings.isEmpty() ) { // Thread Local Storage m_pFastDB->attach(); // Search for a matching row before deciding to update or insert dbCursor< DialByNameRow > cursor(dbCursorForUpdate); DialByNameRow row; dbQuery query; // Primary Key is identity query="np_identity=",identity; // Purge all existing entries associated with this identity if ( cursor.select( query ) > 0 ) { cursor.removeAllSelected(); } // insert all dtmf combinations for this user unsigned int i; for (i=0; i<dtmfStrings.entries(); i++) { UtlString* digits = (UtlString*)dtmfStrings.at(i); row.np_contact = contactString; row.np_identity = identity; row.np_digits = digits->data(); insert (row); } // Commit rows to memory - multiprocess workaround m_pFastDB->detach(0); } } } return result; }
/*!a test case for the interaction of remove() and item(). */ void removeItem() { UtlString v1("a"); UtlString v2("b"); UtlString v3("c"); UtlString v4("d"); UtlContainable* e; UtlSList h; h.insert(&v1); h.insert(&v2); h.insert(&v3); h.insert(&v4); UtlSListIterator iter(h); // Check that item() returns NULL in the initial state. CPPUNIT_ASSERT(iter.item() == NULL); // Step the iterator and check that item() returns v1. e = iter(); CPPUNIT_ASSERT(e == &v1); CPPUNIT_ASSERT(iter.item() == &v1); // Delete the element and check that item() returns NULL. h.remove(e); CPPUNIT_ASSERT(iter.item() == NULL); // Step the iterator and check that item() returns v2. e = iter(); CPPUNIT_ASSERT(e == &v2); CPPUNIT_ASSERT(iter.item() == &v2); // Step the iterator and check that item() returns v3. e = iter(); CPPUNIT_ASSERT(e == &v3); CPPUNIT_ASSERT(iter.item() == &v3); // Delete the element and check that item() returns v2. // (Because deleting an element of a list backs the iterator up // to the previous element.) h.remove(e); CPPUNIT_ASSERT(iter.item() == &v2); // Step the iterator and check that item() returns v4. e = iter(); CPPUNIT_ASSERT(e == &v4); CPPUNIT_ASSERT(iter.item() == &v4); // Step the iterator after the last element and check that // item() returns NULL. e = iter(); CPPUNIT_ASSERT(e == NULL); CPPUNIT_ASSERT(iter.item() == NULL); } //removeItem()
OsStatus SmsNotifier::handleAlarm(const OsTime alarmTime, const UtlString& callingHost, const cAlarmData* alarmData, const UtlString& alarmMsg) { OsStatus retval = OS_FAILED; //execute the mail command for each user UtlString groupKey(alarmData->getGroupName()); if (!groupKey.isNull()) { UtlContainable* pContact = mContacts.findValue(&groupKey); if (pContact) { // Process the comma separated list of contacts UtlString* contactList = dynamic_cast<UtlString*> (pContact); if (!contactList->isNull()) { MailMessage message(mSmsStrFrom, mReplyTo, mSmtpServer); UtlTokenizer tokenList(*contactList); UtlString entry; while (tokenList.next(entry, ",")) { message.To(entry, entry); } UtlString body; UtlString tempStr; UtlString sevStr = Os::Logger::instance().priorityName(alarmData->getSeverity()); body.append(alarmMsg); Os::Logger::instance().log(FAC_ALARM, PRI_DEBUG, "AlarmServer: sms body is %s", body.data()); message.Body(body); UtlSList subjectParams; UtlString codeStr(alarmData->getCode()); UtlString titleStr(sevStr); subjectParams.append(&codeStr); subjectParams.append(&titleStr); assembleMsg(mSmsStrSubject, subjectParams, tempStr); message.Subject(tempStr); // delegate send to separate task so as not to block EmailSendTask::getInstance()->sendMessage(message); } } } return retval; }
void MpRtpInputAudioConnection::handleStartReceiveRtp(UtlSList& codecList, OsSocket& rRtpSocket, OsSocket& rRtcpSocket) { m_bAudioReceived = FALSE; m_inactiveFrameCount = 0; if (codecList.entries() > 0) { // if RFC2833 DTMF is disabled if (!m_bRFC2833DTMFEnabled) { UtlSListIterator itor(codecList); SdpCodec* pCodec = NULL; // go through all codecs, if you find telephone event, remove it while (itor()) { pCodec = dynamic_cast<SdpCodec*>(itor.item()); if (pCodec && pCodec->getCodecType() == SdpCodec::SDP_CODEC_TONES) { codecList.destroy(pCodec); } } } // continue only if numCodecs is still greater than 0 if (codecList.entries() > 0) { // initialize jitter buffers for all codecs mpDejitter->initJitterBuffers(codecList); mpDecode->selectCodecs(codecList); } } // No need to synchronize as the decoder is not part of the // flowgraph. It is part of this connection/resource //mpFlowGraph->synchronize(); prepareStartReceiveRtp(rRtpSocket, rRtcpSocket); // No need to synchronize as the decoder is not part of the // flowgraph. It is part of this connection/resource //mpFlowGraph->synchronize(); if (codecList.entries() > 0) { mpDecode->enable(); if (mpDtmfDetector) { mpDtmfDetector->enable(); } } sendConnectionNotification(MP_NOTIFICATION_START_RTP_RECEIVE, 0); }
void testPeekAtNext() { UtlString v1("a"); UtlString v2("b"); UtlString v3("c"); UtlString v4("d"); UtlContainable* e; UtlSList h; h.insert(&v1); h.insert(&v2); h.insert(&v3); h.insert(&v4); UtlSListIterator iter(h); // check that peekAtNext() returns v1 while iterator points at NULL e = iter.peekAtNext(); CPPUNIT_ASSERT(e == &v1); CPPUNIT_ASSERT(iter.item() == NULL ); // Step the iterator and check that peekAtNext() returns v2 // while iterator points at v1 iter(); e = iter.peekAtNext(); CPPUNIT_ASSERT(e == &v2); CPPUNIT_ASSERT(iter.item() == &v1); // Step the iterator and check that peekAtNext() returns v3 // while iterator points at v2 iter(); e = iter.peekAtNext(); CPPUNIT_ASSERT(e == &v3); CPPUNIT_ASSERT(iter.item() == &v2); // Step the iterator and check that peekAtNext() returns v4 // while iterator points at v3 iter(); e = iter.peekAtNext(); CPPUNIT_ASSERT(e == &v4); CPPUNIT_ASSERT(iter.item() == &v3); // Step the iterator and check that peekAtNext() returns NULL // while iterator points at v4 iter(); e = iter.peekAtNext(); CPPUNIT_ASSERT(e == NULL); CPPUNIT_ASSERT(iter.item() == &v4); }
/*!a Test case to verify insertAt(size_t, UtlContainable*) for a * list that is not empty. * The test data for this test are * a) Insert any UtlContainable to the 0th location, * b) Insert a UtlInt to a 'mid' location, * c) Insert any UtlString object to a 'mid' location * d) Insert any UtlContainable object to the last location */ void testInsertAt_NonEmptyList() { const int testCount = 4 ; const char* prefix = "Test insert(n, Collectable*) for a list that is not empty; "\ "where Collectable is " ; const char* Msgs[] = { \ "a UtlContainableXXX and n = 0", \ "a UtlString and n > 0 && n < size", \ "a UtlInt and n > 0 && n < size", \ "a UtlContainableXXX where n = size-1" \ }; const char* suffix1 = " :- Verify return value" ; const char* suffix2 = " :- Verify value is appended" ; const char* suffix3 = " :- Verify new list size" ; UtlString testFirst("First Entry") ; UtlInt testInt(102) ; UtlString testString("Test String") ; UtlInt testLast(99999) ; UtlContainable* itemToAdd[] = { &testFirst, &testInt, &testString, &testLast } ; UtlContainable* expectedValue[] = { &testFirst, &testInt, &testString, &testLast} ; int insertLocation[] = { 0, 2, 3, commonEntriesCount+3} ; int tmpCount = commonEntriesCount ; int expectedEntries[] = {++tmpCount, ++tmpCount, ++tmpCount, ++tmpCount} ; for (int i = 0 ; i < testCount ; i++) { UtlContainable* uActual ; string msg ; // comment out for now. Uncomment if implementation returns Collectable uActual = commonList.insertAt(insertLocation[i], itemToAdd[i]); //verify that the right value is returned. TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix1) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedValue[i], uActual) ; //`commonList.insertAt(insertLocation[i], itemToAdd[i]); // verify that the value is inserted TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix2) ; uActual = commonList.at(insertLocation[i]) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedValue[i], uActual) ; //verify that the total number of entries has incremented by one. TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix3) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedEntries[i], \ (int)commonList.entries()) ; } }//testInsertAt_NonEmptyList()
int RegistrationDB::getUpdatesForRegistrar(dbQuery& query, UtlSList& bindings) const { int numRows = 0; if ( m_pFastDB != NULL ) { SMART_DB_ACCESS; dbCursor<RegistrationRow> cursor(dbCursorForUpdate); numRows = cursor.select(query); if (numRows > 0) { do { RegistrationBinding* reg = copyRowToRegistrationBinding(cursor); bindings.append(reg); } while (cursor.next()); } } else { OsSysLog::add(FAC_DB, PRI_CRIT, "RegistrationDB::getNewUpdatesForRegistrar failed - no DB"); } return numRows; }
// Generate the partial RLMI list. // Generate list of ResourceReference's corresponding to the URIs in mResourcesList. // Returns true if partialList is non-empty. UtlBoolean ResourceList::genPartialList(UtlSList& partialList) { UtlSListIterator resourcesItor(mResourcesList); ResourceReference* resource; UtlBoolean any_found = FALSE; // Check the resource list for changed items. while ((resource = dynamic_cast <ResourceReference*> (resourcesItor()))) { UtlSListIterator changesItor(mChangesList); UtlString* changedRsrc; UtlBoolean found = FALSE; while ((changedRsrc = dynamic_cast <UtlString*> (changesItor()))) { // Send a partial RLMI (only for resources that changed). if (strcmp(resource->getUri()->data(), changedRsrc->data()) == 0) { found = TRUE; any_found = TRUE; } } if (found) { partialList.append(resource); } } return any_found; }
//deep copy of aliases void SipLine::copyAliases(UtlSList& dest, const UtlSList& source) const { // Clear dest list if (!dest.isEmpty()) { dest.destroyAll() ; } // Copy maintaining order int length = source.entries() ; for (int i=0; i<length; i++) { UtlString* pEntry = (UtlString*) source.at(i) ; dest.append(new UtlString(*pEntry)) ; } }
// Stores a list of strings to the configuration datadase using the // designated prefix as the base for the list items. void OsConfigDb::addList(const UtlString& rPrefix, UtlSList& rList) { OsWriteLock lock(mRWMutex); size_t iNumEntries ; UtlString key ; UtlString* pValue ; // First remove all items start with the specified prefix removeByPrefix(rPrefix) ; // Next add all of the new items iNumEntries = rList.entries() ; if (iNumEntries > 0) { key = rPrefix ; key.append(".COUNT") ; set(key, iNumEntries) ; UtlSListIterator itor(rList) ; int iCount = 1 ; char cTemp[64] ; while ((pValue = (UtlString*) itor())) { sprintf(cTemp, "%d", iCount++); key = rPrefix ; key.append(".") ; key.append(cTemp) ; set(key, *pValue) ; } } }
// Loads a list of strings from the configuration datadase using the // designated prefix as the base for the list items. int OsConfigDb::loadList(const UtlString& rPrefix, UtlSList& rList) const { OsReadLock lock(mRWMutex); int iNumEntries ; int rc = 0 ; UtlString key ; UtlString value ; char cTemp[64] ; // Get number of items key = rPrefix ; key.append(".COUNT") ; if (get(key, iNumEntries) == OS_SUCCESS) { for (int i = 0; i < iNumEntries; i++) { sprintf(cTemp, "%d", i+1); key = rPrefix ; key.append(".") ; key.append(cTemp) ; if (get(key, value) == OS_SUCCESS) { rList.append(new UtlString(value)) ; rc++ ; } } } return rc ; }
/** * Test for SListIterator::findNext only at places that could break * - find item not in list * - find items at endpoints * - find items after reseting iterator */ void testFindNextForDummies() { UtlString fruitData[] = { UtlString("apple"), // 0 UtlString("orange"), // 1 UtlString("banana"), // 2 UtlString("apple"), // 3 UtlString("banana"), // 4 UtlString("apple") // 5 }; int n = sizeof(fruitData) / sizeof(fruitData[0]); UtlSList fruit; for (int i = 0; i < n; i++) { fruit.append(&fruitData[i]); } // nonexistant items UtlSListIterator pineapples(fruit); UtlString pineapple("pineapple"); CPPUNIT_ASSERT_MESSAGE("Do not find item not in list", pineapples.findNext(&pineapple) == NULL); // test items at endpoints UtlSListIterator apples(fruit); UtlString apple("apple"); CPPUNIT_ASSERT_MESSAGE("Find first item", apples.findNext(&apple) == &fruitData[0]); CPPUNIT_ASSERT_MESSAGE("Find second item", apples.findNext(&apple) == &fruitData[3]); CPPUNIT_ASSERT_MESSAGE("Find third item", apples.findNext(&apple) == &fruitData[5]); CPPUNIT_ASSERT_MESSAGE("Find no more items", apples.findNext(&apple) == NULL); // test scattered items UtlSListIterator bananas(fruit); UtlString banana("banana"); CPPUNIT_ASSERT_MESSAGE("Find first item", bananas.findNext(&banana) == &fruitData[2]); CPPUNIT_ASSERT_MESSAGE("Find second item", bananas.findNext(&banana) == &fruitData[4]); CPPUNIT_ASSERT_MESSAGE("Find no more items", bananas.findNext(&banana) == NULL); // test adjustments in iterator UtlSListIterator picker(fruit); CPPUNIT_ASSERT_MESSAGE("Find first item", picker.findNext(&apple) == &fruitData[0]); picker.reset(); CPPUNIT_ASSERT_MESSAGE("Find first item again after reset", picker.findNext(&apple) == &fruitData[0]); CPPUNIT_ASSERT_MESSAGE("Find second item after initial reset", picker.findNext(&apple) == &fruitData[3]); }
/*!a Test case for the () operator. * * The test data for this test is :- * 1) The next entry is a UtlString * 2) The next entry is a UtlInt * 3) The next entry is the last entry * 4) All entries have been read */ void testAdvancingOperator() { struct TestAdvancingOperatorStruct { const char* testDescription ; const UtlContainable* expectedValue ; } ; const int testCount = 4 ; const char* prefix = "Verify the () operator for an iterator when " ; const char* suffix1 = " :- verify return value" ; const char* suffix2 = " :- verify number of entries in the list" ; UtlSList testList ; testList.append(&commonString1) ; testList.append(&commonInt1) ; testList.append(&commonString2) ; UtlSListIterator iter(testList) ; TestAdvancingOperatorStruct testData[] = { \ { "the first entry is a UtlString", &commonString1 }, \ { "the first entry is a UtlInt", &commonInt1 }, \ { "when the list has only one entry", &commonString2 }, \ { "when the list is empty", NULL } \ } ; int expectedEntries = 3 ; for (int i = 0 ; i < testCount ; i++) { string msg ; TestUtilities::createMessage(3, &msg, prefix, \ testData[i].testDescription, suffix1) ; CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), (void*)testData[i].expectedValue, \ (void*)iter()) ; TestUtilities::createMessage(3, &msg, prefix, testData[i].testDescription, \ suffix2); CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedEntries, \ (int)testList.entries()) ; } // Test the () operator for an empty list UtlSListIterator emptyIter(emptyList) ; CPPUNIT_ASSERT_EQUAL_MESSAGE("Test the () operator for an empty list iterator" , \ (void*)NULL, (void*)emptyIter()) ; } //testAdvancingOperator()
bool AlarmRpcGetAlarmCount::execute(const HttpRequestContext& requestContext, UtlSList& params, void* userData, XmlRpcResponse& response, ExecutionStatus& status) { bool result = false; status = XmlRpcMethod::FAILED; if (!params.at(0) || !params.at(0)->isInstanceOf(UtlString::TYPE)) { handleMissingExecuteParam(name(), PARAM_NAME_CALLING_HOST, response, status); } else { UtlString* pCallingHostname = dynamic_cast<UtlString*>(params.at(0)); if (1 != params.entries()) { handleExtraExecuteParam(name(), response, status); } else { SipxRpc* pSipxRpcImpl = ((SipxRpc *)userData); if(validCaller(requestContext, *pCallingHostname, response, *pSipxRpcImpl, name())) { OsSysLog::add(FAC_ALARM, PRI_INFO, "AlarmRpc::getAlarmCount: host %s requested alarm count", pCallingHostname->data() ); // Get the count of alarms since last restart UtlInt alarm_count; alarm_count = UtlInt(cAlarmServer::getInstance()->getAlarmCount()); // Construct and set the response. response.setResponse(&alarm_count); status = XmlRpcMethod::OK; result = true; } } } return result; }