void HH_Runtime::VerifyUnitTestResults( const std::string& batchBuildId ) { m_notifier.ReportProgressMessage( "Verifing unit test results..." ); if ( _access( m_dotKnownGoodFileName.c_str(), 00 ) != 0 ) { throw HH_CantOpenKnownGoodFile( m_dotKnownGoodFileName ); } // Compare the .out and .good files HH_File dotOutputFile( m_dotOutputFileName ); HH_File dotKnownGoodFile( m_dotKnownGoodFileName ); if ( !dotOutputFile.Compare( dotKnownGoodFile ) ) { m_notifier.ReportTestResult( false ); if ( batchBuildId.length() > 0 && m_externalResult.length() > 0 ) { // Report failure to external system ReportResult( "FAILED", batchBuildId ); } } else { m_notifier.ReportTestResult( true ); if ( batchBuildId.length() > 0 && m_externalResult.length() > 0 ) { // Report success to external system ReportResult( "PASSED", batchBuildId ); } } }
ASSERTDATA //+---------------------------------------------------------------------------- // // Member: // CDataAdviseCache::CreateDataAdviseCache, static public // // Synopsis: // Creates an instance of the CDataAdviseCache // // Arguments: // [pp] -- pointer to a location to where to return the // newly created CDataAdviseCache // // Returns: // E_OUTOFMEMORY, S_OK // // Notes: // // History: // 11/02/93 - ChrisWe - file cleanup and inspection // //----------------------------------------------------------------------------- #pragma SEG(CreateDataAdviseCache) FARINTERNAL CDataAdviseCache::CreateDataAdviseCache(LPDATAADVCACHE FAR* pp) { VDATEHEAP(); VDATEPTRIN(pp, LPDATAADVCACHE); // try to allocate the CDataAdviseCache if(NULL == (*pp = new DATAADVCACHE)) return ReportResult(0, E_OUTOFMEMORY, 0, 0); // initialize the DataAdviseHolder member if(CreateDataAdviseHolder(&((*pp)->m_pDAH)) != NOERROR) { // free the DataAdviseCache delete *pp; *pp = NULL; return ReportResult(0, E_OUTOFMEMORY, 0, 0); } return(NOERROR); }
STDMETHODIMP COAHolder::QueryInterface(REFIID iid, LPVOID FAR* ppv) { VDATEHEAP(); M_PROLOG(this); VDATEPTROUT(ppv, LPVOID FAR *); LEDebugOut((DEB_ITRACE, "%p _IN COAHolder::QueryInterface ( %p , %p )" "\n", this, iid, ppv)); HRESULT hr = ReportResult(0, E_NOINTERFACE, 0, 0); if (IsEqualIID(iid, IID_IUnknown) || IsEqualIID(iid, IID_IOleAdviseHolder)) { *ppv = (IOleAdviseHolder FAR *)this; AddRef(); hr = NOERROR; } else { *ppv = NULL; } LEDebugOut((DEB_ITRACE, "%p OUT COAHolder::QueryInterface ( %lx )" " [ %p ]\n", this, hr, *ppv)); return hr; }
void WapacheProtocol::ProcessConnection(void) { // this function runs inside the worker thread apr_socket_t *sock; long thread_num = 1; ap_sb_handle_t *sbh; apr_bucket_alloc_t *ba; bool redirected; // create a fake socket sock = (apr_socket_t *) apr_pcalloc(Pool, sizeof(apr_socket_t)); sock->pool = Pool; sock->local_port_unknown = 1; sock->local_interface_unknown = 1; sock->remote_addr_unknown = 1; sock->userdata = (sock_userdata_t *) this; ba = apr_bucket_alloc_create(Pool); ap_create_sb_handle(&sbh, Pool, 0, thread_num); Connection = ap_run_create_connection(Pool, Application.ServerConf, sock, thread_num, sbh, ba); if(Connection) { do { redirected = Redirecting; Redirecting = false; if(!Terminated) { ap_process_connection(Connection, sock); } } while(Redirecting); } else { // can't create the connection object for some reason HttpStatusCode = 500; } if(!HttpStatusCode || HttpStatusCode >= 400 || HttpStatusCode == 204) { ReportResult(E_ABORT, ERROR_CANCELLED); } else { ReportResult(S_OK, 0); } }
void ReplicationTest::tryResultData() { QString sql; QSqlQuery *q; repl_ticks++; // // Read Value // sql=QString("select VALUE from ")+repl_config->pingTablename(Am::This); q=new QSqlQuery(sql,QSqlDatabase::database("repl_db")); if(!q->first()) { syslog(LOG_ERR,"cannot select from mysql at %s [%s]", (const char *)repl_config->address(Am::That,repl_addr).toString(). toAscii(), (const char *)q->lastError().text().toAscii()); delete q; ReportResult(false,0); return; } if(q->value(0).toInt()==repl_value) { delete q; ReportResult(true,repl_ticks); return; } delete q; // // Check for Timeout // if(repl_ticks>=repl_config->globalMysqlReplicationTimeout()) { ReportResult(false,0); return; } // // Restart for Another Attempt // repl_timer->start(AM_REPLICATION_TICK_INTERVAL); }
HRESULT CDataAdviseCache::ClientToDelegate(DWORD dwClient, DWORD FAR* pdwDelegate) { VDATEHEAP(); VDATEPTRIN(pdwDelegate, DWORD); DWORD dwDelegate = *pdwDelegate = 0; if (FALSE == m_mapClientToDelegate.Lookup(dwClient, dwDelegate)) return(ReportResult(0, OLE_E_NOCONNECTION, 0, 0)); *pdwDelegate = dwDelegate; return NOERROR; }
int joinBucket() { // cerr << "---------------------------------------------------" << endl; int pairs = 0; bool selfjoin = stop.join_cardinality ==1 ? true : false ; int idx1 = SID_1 ; int idx2 = selfjoin ? SID_1 : SID_2 ; double low[2], high[2]; // for each tile (key) in the input stream try { std::vector<Geometry*> & poly_set_one = polydata[idx1]; std::vector<Geometry*> & poly_set_two = polydata[idx2]; int len1 = poly_set_one.size(); int len2 = poly_set_two.size(); if (len1 <= 0 || len2 <= 0) { return 0; } map<int,Geometry*> geom_polygons2; for (int j = 0; j < len2; j++) { geom_polygons2[j] = poly_set_two[j]; } // build spatial index for input polygons from idx2 bool ret = buildIndex(geom_polygons2); if (ret == false) { return -1; } // cerr << "len1 = " << len1 << endl; // cerr << "len2 = " << len2 << endl; for (int i = 0; i < len1; i++) { const Geometry* geom1 = poly_set_one[i]; const Envelope * env1 = geom1->getEnvelopeInternal(); low[0] = env1->getMinX(); low[1] = env1->getMinY(); high[0] = env1->getMaxX(); high[1] = env1->getMaxY(); /* Handle the buffer expansion for R-tree */ if (stop.JOIN_PREDICATE == ST_DWITHIN) { low[0] -= stop.expansion_distance; low[1] -= stop.expansion_distance; high[0] += stop.expansion_distance; high[1] += stop.expansion_distance; } Region r(low, high, 2); hits.clear(); MyVisitor vis; spidx->intersectsWithQuery(r, vis); //cerr << "j = " << j << " hits: " << hits.size() << endl; for (uint32_t j = 0 ; j < hits.size(); j++ ) { if (hits[j] == i && selfjoin) { continue; } const Geometry* geom2 = poly_set_two[hits[j]]; const Envelope * env2 = geom2->getEnvelopeInternal(); if (join_with_predicate(geom1, geom2, env1, env2, stop.JOIN_PREDICATE)) { ReportResult(i,hits[j]); pairs++; } } } } // end of try //catch (Tools::Exception& e) { catch (...) { std::cerr << "******ERROR******" << std::endl; //std::string s = e.what(); //std::cerr << s << std::endl; return -1; } // end of catch return pairs ; }
STDMETHODIMP COAHolder::Advise(IAdviseSink FAR* pAdvSink, DWORD FAR* pdwConnection) { VDATEHEAP(); int iAdv; // records the first free entry found, or (-1) int iAdvScan; // counts across array entries IAdviseSink FAR *FAR *ppIAS; // points at the array entry being examined IAdviseSink FAR *pIAS; // the actual entry at *ppIAS M_PROLOG(this); VDATEIFACE(pAdvSink); HRESULT hr = NOERROR; LEDebugOut((DEB_ITRACE, "%p _IN COAHolder::Advise ( %p , %p )" "\n", this, pAdvSink, pdwConnection)); // Validate where to return the connection. if (pdwConnection) { VDATEPTRIN(pdwConnection, DWORD); // Default to error case *pdwConnection = 0; } // check our zombie state and stabilize. If we are in a zombie // state, we do not want to be adding new advise sinks. CStabilize stabilize((CSafeRefCount *)this); if( IsZombie() ) { hr = ResultFromScode(CO_E_RELEASED); goto errRtn; } // find an empty slot and clean up disconnected handlers for (iAdv = (-1), ppIAS = m_ppIAS, iAdvScan = 0; iAdvScan < m_iSize; ++ppIAS, ++iAdvScan) { if ((pIAS = *ppIAS) == NULL) { // NULL entries are handled below, to catch // any of the below cases creating new NULL values ; } else if (!IsValidInterface(pIAS)) { // not valid; don't try to release *ppIAS = NULL; } else if (!CoIsHandlerConnected(pIAS)) { // advise sink not connected to server anymore; release // REVIEW, why do we have to constantly poll these // to see if they are ok? pIAS->Release(); *ppIAS = NULL; } // if first NULL, save rather than extend array if ((*ppIAS == NULL) && (iAdv == (-1))) iAdv = iAdvScan; } // if we didn't find an empty slot, we have to add space if (iAdv == (-1)) { ppIAS = (IAdviseSink FAR * FAR *)PubMemRealloc(m_ppIAS, sizeof(IAdviseSink FAR *)*(m_iSize + COAHOLDER_GROWBY)); if (ppIAS != NULL) { // zero out new space _xmemset((void FAR *) (ppIAS + m_iSize), 0, sizeof(IAdviseSink *) * COAHOLDER_GROWBY); // this is the index of the new element to use iAdv = m_iSize; // replace the old array m_ppIAS = ppIAS; m_iSize += COAHOLDER_GROWBY; } else { // quit if there was an error hr = ReportResult(0, E_OUTOFMEMORY, 0, 0); } }
OLETRACEIN((API_CreateOleAdviseHolder, PARAMFMT("ppOAHolder= %p"), ppOAHolder)); VDATEHEAP(); HRESULT hr; VDATEPTROUT_LABEL(ppOAHolder, IOleAdviseHolder FAR* FAR*, errRtn, hr); LEDebugOut((DEB_ITRACE, "%p _IN CreateOleAdviseHolder ( %p )" "\n", NULL, ppOAHolder)); *ppOAHolder = new FAR COAHolder(); // task memory; hard coded below hr = *ppOAHolder ? NOERROR : ReportResult(0, E_OUTOFMEMORY, 0, 0); LEDebugOut((DEB_ITRACE, "%p OUT CreateOleAdviseHolder ( %lx )\n", "[ %p ]\n", NULL, hr, *ppOAHolder)); CALLHOOKOBJECTCREATE(hr, CLSID_NULL, IID_IOleAdviseHolder, (IUnknown **)ppOAHolder); errRtn: OLETRACEOUT((API_CreateOleAdviseHolder, hr)); return hr; } //+----------------------------------------------------------------------------
void URLLoaderHandler::ReportResultAndDie(const std::string& fname, const std::string& text, bool success) { ReportResult(fname, text, success); delete this; }
HRESULT CDataAdviseCache::Advise(LPDATAOBJECT pDataObject, FORMATETC FAR* pFetc, DWORD advf, LPADVISESINK pAdvise, DWORD FAR* pdwClient) // first 4 parms are as in DataObject::Advise { VDATEHEAP(); DWORD dwDelegate = 0; // the delegate connection number HRESULT hr; // if there is a data object, ask to be advised of changes if(pDataObject != NULL) RetErr(pDataObject->DAdvise(pFetc, advf, pAdvise, &dwDelegate)); // if there is no data object, (i.e. the object is not active, // dwDelegate is zero // Here we are using the data advise holder only to hold advise // connections. We are not going to use it to send OnDataChange to // sinks. // REVIEW, handling of ADVF_ONLYONCE seems broken... // it's clear that we can't cope with this flag properly; we have // no way of knowing when the notification takes place, and therefore // we can't remove the entry from m_pDAH. The notification may have // taken place above, and it may not have. If the data object wasn't // around, then the advise request here is lost, and the sink will // never be notified. Or, if the request isn't PRIMEFIRST, and the // data object is deactivated, then the data object loses the request, // and on subsequent activation, we won't readvise it on EnumAndAdvise. // So, what good are we for ONLYONCE sinks? What does this break? if(advf & ADVF_ONLYONCE) return NOERROR; // keep a local copy of the advise hr = m_pDAH->Advise(NULL, pFetc, advf, pAdvise, pdwClient); // if we failed to keep a local reference to the advise sink, // we won't be able to maintain this mapping, so remove the // advise on the data object, if there is one if (hr != NOERROR) { Exit1: if (pDataObject != NULL) pDataObject->DUnadvise(dwDelegate); return(hr); } // create a map entry from *pdwClient -> dwDelegate // if the map entry creation failed, undo all work if (m_mapClientToDelegate.SetAt(*pdwClient, dwDelegate) != TRUE) { // map failed to allocate memory, undo advise since we won't // be able to find this one again m_pDAH->Unadvise(*pdwClient); // map entry creation must have failed from lack of allocation hr = ReportResult(0, E_OUTOFMEMORY, 0, 0); // undo the advise on the data object goto Exit1; } return(NOERROR); }
STDAPI CreateDataAdviseHolder(IDataAdviseHolder FAR* FAR* ppDAHolder) { VDATEHEAP(); OLETRACEIN((API_CreateDataAdviseHolder, PARAMFMT("ppDAHolder= %p"), ppDAHolder)); *ppDAHolder = new FAR CDAHolder(); // task memory; use MEMCTX_TASK below CALLHOOKOBJECTCREATE(*ppDAHolder ? NOERROR : E_OUTOFMEMORY, CLSID_NULL, IID_IDataAdviseHolder, (IUnknown **)ppDAHolder); HRESULT hr; hr = *ppDAHolder ? NOERROR : ReportResult(0, E_OUTOFMEMORY, 0, 0); OLETRACEOUT((API_CreateDataAdviseHolder, hr)); return hr; } //+---------------------------------------------------------------------------- // // Member: // CDAHolder::CDAHolder, public // // Synopsis: // constructor