int getCurrentSourceIndex (bool input) const { OSType currentSourceID = 0; UInt32 size = sizeof (currentSourceID); int result = -1; AudioObjectPropertyAddress pa; pa.mSelector = kAudioDevicePropertyDataSource; pa.mScope = input ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput; pa.mElement = kAudioObjectPropertyElementMaster; if (deviceID != 0) { if (OK (AudioObjectGetPropertyData (deviceID, &pa, 0, 0, &size, ¤tSourceID))) { HeapBlock <OSType> types; const int num = getAllDataSourcesForDevice (deviceID, types); for (int i = 0; i < num; ++i) { if (types[num] == currentSourceID) { result = i; break; } } } } return result; }
TEST_F(MesosSchedulerDriverTest, MetricsEndpoint) { Try<Owned<cluster::Master>> master = StartMaster(); ASSERT_SOME(master); MockScheduler sched; MesosSchedulerDriver driver( &sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL); Future<Nothing> registered; EXPECT_CALL(sched, registered(&driver, _, _)) .WillOnce(FutureSatisfy(®istered)); ASSERT_EQ(DRIVER_RUNNING, driver.start()); AWAIT_READY(registered); Future<process::http::Response> response = process::http::get(process::metrics::internal::metrics, "snapshot"); AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response); AWAIT_EXPECT_RESPONSE_HEADER_EQ(APPLICATION_JSON, "Content-Type", response); Try<JSON::Object> parse = JSON::parse<JSON::Object>(response->body); ASSERT_SOME(parse); JSON::Object metrics = parse.get(); EXPECT_EQ(1u, metrics.values.count("scheduler/event_queue_messages")); EXPECT_EQ(1u, metrics.values.count("scheduler/event_queue_dispatches")); driver.stop(); driver.join(); }
//============================================================================== StringArray getSources (bool input) { StringArray s; HeapBlock <OSType> types; const int num = getAllDataSourcesForDevice (deviceID, types); for (int i = 0; i < num; ++i) { AudioValueTranslation avt; char buffer[256]; avt.mInputData = &(types[i]); avt.mInputDataSize = sizeof (UInt32); avt.mOutputData = buffer; avt.mOutputDataSize = 256; UInt32 transSize = sizeof (avt); AudioObjectPropertyAddress pa; pa.mSelector = kAudioDevicePropertyDataSourceNameForID; pa.mScope = input ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput; pa.mElement = kAudioObjectPropertyElementMaster; if (OK (AudioObjectGetPropertyData (deviceID, &pa, 0, 0, &transSize, &avt))) { DBG (buffer); s.add (buffer); } } return s; }
static void cxn_msg_rx(indigo_cxn_id_t cxn_id, of_object_t *obj) { printf("Got msg from %d: type %d\n", cxn_id, obj->object_id); /* Just respond to echo request */ if (obj->object_id == OF_ECHO_REQUEST) { of_echo_request_t *echo; of_echo_reply_t *reply; of_octets_t data; uint32_t xid; echo = (of_echo_request_t *)obj; of_echo_request_xid_get(echo, &xid); printf("Respond to echo with xid 0x%x\n", xid); if ((reply = of_echo_reply_new(echo->version)) == NULL) { printf("Could not allocate echo response obj\n"); goto done; } of_echo_request_data_get(echo, &data); if (data.bytes) { OK(of_echo_reply_data_set(reply, &data)); } of_echo_reply_xid_set(reply, xid); indigo_cxn_send_controller_message(cxn_id, reply); } done: of_object_delete(obj); got_cxn_msg = 1; }
double cOneTestLSQ::Correl(const Pt2dr & aDec) const { if (! OK(aDec)) return -1; double aSom2= 0; double aSom22= 0; double aSom12= 0; int aCpt=0; for(int aKx=-mNbW; aKx<=mNbW; aKx++) { for(int aKy=-mNbW; aKy<=mNbW; aKy++) { Pt2dr aP2 = aDec+mIm2->PVois(aKx,aKy); double aV2 = mIm2->GetVal(aP2); double aV1 = mValsIm1[aCpt]; aSom2 += aV2; aSom12 += aV1*aV2; aSom22 += ElSquare(aV2); aCpt++; } } aSom2 /= mSomP; aSom12 /= mSomP; aSom22 /= mSomP; aSom12 -= mSom1 * aSom2; aSom22 -= ElSquare(aSom2); return aSom12 * sqrt(std::max(1e-5,aSom22*mSom11)); }
bool CShaderProgram::Enable() { if (OK()) { glUseProgram(m_shaderProgram); if (OnEnabled()) { if (!m_validated) { // validate the program GLint params[4]; glValidateProgram(m_shaderProgram); glGetProgramiv(m_shaderProgram, GL_VALIDATE_STATUS, params); if (params[0] != GL_TRUE) { GLchar log[LOG_SIZE]; kodi::Log(ADDON_LOG_ERROR, "GL: Error validating shader"); glGetProgramInfoLog(m_shaderProgram, LOG_SIZE, nullptr, log); kodi::Log(ADDON_LOG_ERROR, "%s", log); } m_validated = true; } return true; } else { glUseProgram(0); return false; } return true; } return false; }
cRamp::cRamp( const char* fileName,bool declaredScansOnly ) : m_filename(fileName), m_declaredScansOnly(declaredScansOnly), m_runInfo() { m_handle = rampOpenFile(fileName); m_scanOffsets = NULL; m_runInfo = NULL; m_lastScan = 0; if (!OK()) { // HENRY -- I would prefer this to be silent, and let the caller deals with it // cout << "Error: Could not open file " << fileName << ": " << strerror(errno) << endl; // END HENRY } else { m_runInfo = getRunInfo(); // HENRY -- always read index to set scan count, since scan count // declared at the top of the mzXML file is unreliable now that // there are missing scans. // This will also set the structs m_scanOffsets, and the value m_lastScan // if (m_runInfo->m_data.scanCount < 0) { // undeclared scan count // this will provoke reading of index, which sets scan count rampScanInfo* tmp = getScanHeaderInfo ( 1 ); free(tmp); // } // END HENRY } }
static void do_load() { input_stop(); conf_load(); OK(); input_calibrate(CHANNELS); input_start(); }
/* **++ ** ROUTINE: netlib___alloc_ctx ** ** FUNCTIONAL DESCRIPTION: ** ** Allocates some memory. ** ** RETURNS: cond_value ** ** PROTOTYPE: ** ** netlib___alloc_ctx(unsigned int size, void *ptr) ** ** IMPLICIT INPUTS: None. ** ** IMPLICIT OUTPUTS: None. ** ** COMPLETION CODES: None. ** ** SIDE EFFECTS: None. ** **-- */ unsigned int netlib___alloc_ctx (struct CTX **ctxp, unsigned int specsize) { struct CTX *ctx; unsigned int status, fullsize, aststat; BLOCK_ASTS(aststat); if (netlib_synch_efn == 0xffffffff) { status = lib$get_ef(&netlib_synch_efn); if (!OK(status)) { UNBLOCK_ASTS(aststat); return status; } } if (netlib_asynch_efn == 0xffffffff) { status = lib$get_ef(&netlib_asynch_efn); if (!OK(status)) { UNBLOCK_ASTS(aststat); return status; } } fullsize = specsize + CTX_S_CTXDEF; if (ctxzone == 0) { unsigned int algorithm=LIB$K_VM_FIXED; unsigned int flags=LIB$M_VM_GET_FILL0|LIB$M_VM_EXTEND_AREA; status = lib$create_vm_zone(&ctxzone, &algorithm, &fullsize, &flags); if (!OK(status)) { UNBLOCK_ASTS(aststat); return status; } } status = lib$get_vm(&fullsize, &ctx, &ctxzone); if (OK(status)) { ctx->specctx = ctx + 1; ctx->specctx_size = specsize; if (!OK(status)) lib$free_vm(&fullsize, &ctx, &ctxzone); *ctxp = ctx; } UNBLOCK_ASTS(aststat); return status; } /* netlib___alloc_ctx */
struct CFCClass* CFCTest_parse_class(CFCTest *test, CFCParser *parser, const char *src) { CFCBase *result = CFCParser_parse(parser, src); OK(test, result != NULL, "parse class"); STR_EQ(test, CFCBase_get_cfc_class(result), "Clownfish::CFC::Model::Class", "result class"); return (struct CFCClass*)result; }
struct CFCMethod* CFCTest_parse_method(CFCTest *test, CFCParser *parser, const char *src) { CFCBase *result = CFCParser_parse(parser, src); OK(test, result != NULL, "parse '%s'", src); STR_EQ(test, CFCBase_get_cfc_class(result), "Clownfish::CFC::Model::Method", "result class of '%s'", src); return (struct CFCMethod*)result; }
bool open (const double newSampleRate, const BitArray& newChannels) { reservoirSize = 0; reservoirCapacity = 16384; reservoir.setSize (actualNumChannels * reservoirCapacity * sizeof (float)); return openClient (newSampleRate, newChannels) && (numChannels == 0 || OK (client->GetService (__uuidof (IAudioCaptureClient), (void**) &captureClient))); }
void CShaderProgram::Disable() { if (OK()) { glUseProgram(0); OnDisabled(); } }
int GameMapSet::setLevel(int l) { if (l != m_level && OK(l)) { m_level = l; emit levelChanged(); } return m_level; }
static void test_inside (int * test) { int cell; int direction; cell = 0; direction = 4; OK (inside (cell, direction), (*test), "%d %d is inside", cell, direction); cell = 0; direction = 0; OK (! inside (cell, direction), (*test), "%d %d is not inside", cell, direction); cell = 80; direction = 0; OK (inside (cell, direction), (*test), "%d %d is inside", cell, direction); cell = 80; direction = 7; OK (! inside (cell, direction), (*test), "%d %d is not inside", cell, direction); }
bool Data_Buffer::Size (size_t num) { if (num > 0 && (num > max_size || !OK ())) { if (!Max_Size (num)) return (false); } size = num; get_ptr = buffer; return (true); }
/* Called after every test to clean up */ static int teardown(void **state) { uc_engine *uc = *state; OK(uc_close(uc)); *state = NULL; return 0; }
/* Called before every test to set up a new instance */ static int setup32(void **state) { uc_engine *uc; OK(uc_open(UC_ARCH_X86, UC_MODE_32, &uc)); *state = uc; return 0; }
/* **++ ** ROUTINE: netlib_bind ** ** FUNCTIONAL DESCRIPTION: ** ** tbs ** ** RETURNS: cond_value, longword (unsigned), write only, by value ** ** PROTOTYPE: ** ** tbs ** ** IMPLICIT INPUTS: None. ** ** IMPLICIT OUTPUTS: None. ** ** COMPLETION CODES: ** ** ** SIDE EFFECTS: None. ** **-- */ unsigned int netlib_bind (struct CTX **xctx, struct SINDEF *sa, unsigned int *salen, struct NETLIBIOSBDEF *iosb, void (*astadr)(), void *astprm) { struct CTX *ctx; unsigned int status; ITMLST2 sockdsc; int argc; static unsigned int one = 1; VERIFY_CTX(xctx, ctx); SETARGCOUNT(argc); if (argc < 3) return SS$_INSFARG; if (sa == 0 || salen == 0) return SS$_BADPARAM; if (*salen < sizeof(struct SINDEF)) return SS$_BADPARAM; if (!(ctx->flags & CTX_M_USER_SET_REUSEADDR)) { ITMLST2 rulst, sockopt; ITMLST2_INIT(rulst, UCX$C_SOCKOPT, sizeof(sockopt), &sockopt); ITMLST2_INIT(sockopt, NETLIB_K_OPTION_REUSEADDR, sizeof(one), &one); sys$qiow(netlib_synch_efn, ctx->chan, IO$_SETMODE, 0, 0, 0, 0, 0, 0, 0, &rulst, 0); } ITMLST2_INIT(sockdsc, 0, *salen, sa); if (argc > 4 && astadr != 0) { struct IOR *ior; GET_IOR(ior, ctx, iosb, astadr, (argc > 5) ? astprm : 0); status = sys$qio(netlib_asynch_efn, ctx->chan, IO$_SETMODE, &ior->iosb, io_completion, ior, 0, 0, &sockdsc, 0, 0, 0); if (!OK(status)) FREE_IOR(ior); } else { struct NETLIBIOSBDEF myiosb; status = sys$qiow(netlib_synch_efn, ctx->chan, IO$_SETMODE, &myiosb, 0, 0, 0, 0, &sockdsc, 0, 0, 0); if (OK(status)) status = netlib___cvt_status(&myiosb); if (argc > 3 && iosb != 0) netlib___cvt_iosb(iosb, &myiosb); } return status; } /* netlib_bind */
int cubeb_init(cubeb ** context, char const * context_name) { int (* init[])(cubeb **, char const *) = { #if defined(USE_JACK) jack_init, #endif #if defined(USE_PULSE) pulse_init, #endif #if defined(USE_ALSA) alsa_init, #endif #if defined(USE_AUDIOUNIT) audiounit_init, #endif #if defined(USE_WASAPI) wasapi_init, #endif #if defined(USE_WINMM) winmm_init, #endif #if defined(USE_SNDIO) sndio_init, #endif #if defined(USE_OPENSL) opensl_init, #endif #if defined(USE_AUDIOTRACK) audiotrack_init, #endif #if defined(USE_KAI) kai_init, #endif }; int i; if (!context) { return CUBEB_ERROR_INVALID_PARAMETER; } for (i = 0; i < NELEMS(init); ++i) { if (init[i](context, context_name) == CUBEB_OK) { /* Assert that the minimal API is implemented. */ #define OK(fn) assert((* context)->ops->fn) OK(get_backend_id); OK(destroy); OK(stream_init); OK(stream_destroy); OK(stream_start); OK(stream_stop); OK(stream_get_position); return CUBEB_OK; } } return CUBEB_ERROR; }
/* **++ ** ROUTINE: sp_receive ** ** FUNCTIONAL DESCRIPTION: ** ** Get some output from the subprocess, if any. Uses IO$M_NOW modifier ** so that if there isn't anything available, we return an error status ** rather than blocking until something comes up. ** ** RETURNS: cond_value, longword (unsigned), write only, by value ** ** PROTOTYPE: ** ** sp_receive(SPHANDLE *ctxpp, struct dsc$descriptor *rcvstr, ** int *rcvlen) ** ** IMPLICIT INPUTS: None. ** ** IMPLICIT OUTPUTS: None. ** ** COMPLETION CODES: ** SS$_NORMAL: normal successful completion ** SS$_NONEXPR: subprocess doesn't exist any more ** ** SIDE EFFECTS: None. ** **-- */ unsigned int sp_receive (SPHANDLE *ctxpp, void *rcvstr, int *rcvlen) { SPHANDLE ctx; unsigned int status, efstate; ctx = *ctxpp; if (sys$readef(ctx->termefn, &efstate) != SS$_WASCLR) return SS$_NONEXPR; status = sys$qiow(0, ctx->outchn, IO$_READVBLK|IO$M_NOW, ctx->iosb, 0, 0, ctx->bufptr, ctx->bufsiz, 0, 0, 0, 0); if (OK(status)) status = ctx->iosb[0]; if (OK(status)) { str$copy_r(rcvstr, &ctx->iosb[1], ctx->bufptr); if (rcvlen) *rcvlen = ctx->iosb[1]; } return status; } /* sp_receive */
/** * Base class implementation of one-time dictionary initialization * * @param _this This instance * @return O_K if successful, an error code otherwise */ INT16 CDlpObject_AutoRegisterWords(CDlpObject* _this) { INT16 nErr = O_K; DEBUGMSG(-1,"CDlpObject_AutoRegisterWords for '%s'",_this->m_lpInstanceName,0,0); nErr = CDlpObject_UnregisterAllWords(_this); if (!OK(nErr)) return nErr; REGISTER_FIELD("check","",LPMV(m_nCheck),NULL,"Verbose level",0,T_SHORT,1,"",0) return O_K; }
int main() { int i,j,now,cur,max; FILE *fin = fopen ("ariprog.in", "r"); FILE *fout = fopen ("ariprog.out", "w"); fscanf(fin,"%d %d",&n,&m); for(i=0;i<=m;i++) exist[i]=i*i; for(i=0;i<=m;i++) { for(j=i;j<=m;j++) Is[exist[i]+exist[j]]=1; } max=m*m<<1; for(i=0,cur=1;i<=max;i++) { if(Is[i]) exist[cur++]=i; } cur--; for(st=1;(now=i*(n-1))<=max;st++) { for(j=1;now+exist[j]<=max;j++) { if(OK(exist[j],i,n)) break; } if(now+exist[j]<=max) break; } for(i=st;(now=i*(n-1))<=max;i+=st) { for(j=1;now+exist[j]<=max;j++) { if(OK(exist[j],i,n)) fprintf(fout,"%d %d\n",exist[j],i); } } if(!yep) fprintf(fout,"NONE\n"); return 0; }
static void test_ether_aton_bad(void) { struct ether_addr *ep; testnum++; ep = ether_aton(ether_aton_bad_string); if (ep != NULL) NOTOK("returned success"); OK(); }
static void test_ether_line_bad_2(void) { struct ether_addr e; char hostname[256]; testnum++; if (ether_line(ether_line_bad_2_string, &e, hostname) == 0) NOTOK("returned success"); OK(); }
/* **++ ** ROUTINE: netlib_server_setup ** ** FUNCTIONAL DESCRIPTION: ** ** Create a "server_setup". ** ** RETURNS: cond_value, longword (unsigned), write only, by value ** ** PROTOTYPE: ** ** tbs ** ** IMPLICIT INPUTS: None. ** ** IMPLICIT OUTPUTS: None. ** ** COMPLETION CODES: ** ** ** SIDE EFFECTS: None. ** **-- */ unsigned int netlib_server_setup (struct CTX **xctx, struct SINDEF *sa, unsigned int *salen) { struct CTX *ctx; struct NETLIBIOSBDEF myiosb; struct { unsigned short protocol; unsigned char type; unsigned char domain; } sockdef; unsigned int status; static $DESCRIPTOR(device, "SYS$NET"); status = netlib___alloc_ctx(&ctx, SPECCTX_SIZE); if (!OK(status)) return status; status = sys$assign(&device, &ctx->chan, 0, 0); if (!OK(status)) { netlib___free_ctx(ctx); return status; } sockdef.protocol = UCX$C_TCP; sockdef.type = INET_PROTYP$C_STREAM; sockdef.domain = UCX$C_AUXS; status = sys$qiow(netlib_synch_efn, ctx->chan, IO$_SETMODE, &myiosb, 0, 0, &sockdef, 0, 0, 0, 0, 0); if (OK(status)) status = netlib___cvt_status(&myiosb); if (!OK(status)) { sys$dassgn(ctx->chan); netlib___free_ctx(ctx); return status; } *xctx = ctx; return SS$_NORMAL; } /* netlib_server_setup */
/************************************************************************* * FUNCTION : RPMTransaction_Set::Problems * * ARGUMENTS : interp * * RETURNS : TCL_OK or TCL_ERROR * * EXCEPTIONS : none * * PURPOSE : Return current problem set as TCL list * *************************************************************************/ int RPMTransaction_Set::Problems(Tcl_Interp *interp,int , Tcl_Obj *const []) { rpmps problems = rpmtsProblems(transaction); int num_probs = rpmpsNumProblems(problems); Tcl_Obj *rv = 0; for (int i = 0; i < num_probs; ++i) { rpmProblem what = &problems->probs[i]; rv = Grow_list(rv,RPMPRoblem_Obj::Create_from_problem(*what)); } return OK(rv); }
void key_GetPassword(void) { if (bKey == bKEY_ENTER) { if (enKeyboard == KBD_ENTER) { enKeyboard = KBD_INPUT2; ShowHi(szPassword); ShowLo(szMaskPass); ClearPassTwo(); ibX = 3; } else if (enKeyboard == KBD_INPUT2) { if ((memcmp(mpbPassOne, mpbPassTwo, 10) == 0) || SuperUser()) { enKeyboard = KBD_BEGIN; OK(); boSetPassword = true; SaveCache(&chSetPassword); enGlobal = GLB_REPROGRAM; Setting(); // AddSysRecord(EVE_PASSWORD); } else { enKeyboard = KBD_ENTER; LongBeep(); Error(); } } } else if (bKey < 10) { if (enKeyboard == KBD_INPUT2) { if (ibX < 13) { mpbPassTwo[ibX-3] = bKey; szLo[ibX++] = '*'; } } } else Beep(); }
static void test_connect(struct sockaddr_un *sun) { int s; ANN(); NEW_SOCKET(s); if (connect(s, (struct sockaddr *)sun, sizeof(*sun)) < 0) FAILERR("connect"); (void)close(s); OK(); }
void ObTabletJoinTest::SetUp() { tablet_join_info_.left_table_id_ = LEFT_TABLE_ID; tablet_join_info_.right_table_id_ = RIGHT_TABLE_ID; ObTabletJoin::JoinInfo join_info; OK(tablet_join_info_.join_condition_.push_back(1)); join_info.left_column_id_ = 4; join_info.right_column_id_ = 2; OK(tablet_join_info_.join_column_.push_back(join_info)); join_info.left_column_id_ = 5; join_info.right_column_id_ = 3; OK(tablet_join_info_.join_column_.push_back(join_info)); join_info.left_column_id_ = 6; join_info.right_column_id_ = 4; OK(tablet_join_info_.join_column_.push_back(join_info)); }