int tc_against_gold_v(struct ut_suite *suite, struct ut_tcase *tcase) { size_t i; for (i = 0; i < ARRAY_SIZE(out1); i++) { ut_assert_msg(check_data(test_out1[i], out1[i], MAX_REL_DIFF) == OK, "p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n", i, out1[i], test_out1[i], test_out1[i]/out1[i]); } for (i = 0; i < ARRAY_SIZE(out2); i++) { ut_assert_msg(check_data(test_out2[i], out2[i], MAX_REL_DIFF) == OK, "p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n", i, out2[i], test_out2[i], test_out2[i]/out2[i]); } #if 0 // This test is not used, since the code today requires nx >= ny for (i = 0; i < ARRAY_SIZE(out3); i++) { ut_assert_msg(check_data(test_out3[i], out3[i], MAX_REL_DIFF) == OK, "p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n", i, out3[i], test_out3[i], test_out3[i]/out3[i]); } #endif return 0; }
int main(int argc, char *argv[]) { // Stack variables float test_out[500]; int testFail = 0; int i; printf("Running test program p_xcorr_test...\n"); // Execution setup // Run test 1 on Arm p_xcorr_f32(in11, in12, test_out, in11_size, in12_size); // Check data for ( i = 0; i < out_size1; i++ ) { if (check_data(test_out[i],out1[i], MAX_REL_DIFF) == NOK ) { testFail = 1; printf("Test 1: Large diff for index %d, ref:%f test: %f rel:%f \n",i,out1[i],test_out[i], test_out[i]/out1[i]); } } // Run test 2 on Arm p_xcorr_f32(in21, in22, test_out, in21_size, in22_size); // Check data for ( i = 0; i < out_size2; i++ ) { if (check_data(test_out[i],out2[i], MAX_REL_DIFF) == NOK ) { testFail = 1; printf("Test 2: Large diff for index %d, ref:%f test: %f rel:%f \n",i,out2[i],test_out[i], test_out[i]/out2[i]); } } /* // This test is not used, since the code today requires nx >= ny // Run test 3 on Arm p_xcorr_f32(in31, in32, test_out, in31_size, in32_size, 1, team0); // Check data for ( i = 0; i < out_size3; i++ ) { if (check_data(test_out[i],out3[i], MAX_REL_DIFF) == NOK ) { testOK = 0; printf("Test 3: Large diff for index %d, ref:%f test: %f rel:%f \n",i,out3[i],test_out[i], test_out[i]/out3[i]); } } */ if (testFail) { printf("Xcorr ARM test FAILED!!\n"); } else { printf("Xcorr ARM test OK\n"); } return testFail; }
static int remote_read(apacket *p, atransport *t) { if(readx(t->sfd, &p->msg, sizeof(amessage))){ D("remote local: read terminated (message)\n"); return -1; } fix_endians(p); #if 0 && defined __ppc__ D("read remote packet: %04x arg0=%0x arg1=%0x data_length=%0x data_check=%0x magic=%0x\n", p->msg.command, p->msg.arg0, p->msg.arg1, p->msg.data_length, p->msg.data_check, p->msg.magic); #endif if(check_header(p)) { D("bad header: terminated (data)\n"); return -1; } if(readx(t->sfd, p->data, p->msg.data_length)){ D("remote local: terminated (data)\n"); return -1; } if(check_data(p)) { D("bad data: terminated (data)\n"); return -1; } return 0; }
int get_map(t_glob *g) { t_temp_list *node; node = g->data; while (node->next != NULL) { ft_putstr(node->str); ft_putchar('\n'); test_alpha(node->str); ((g->lines == 0) && (test_digit(node->str) == 0)) ? g->ant_flag = 1 : 0; ((ft_strcmp("##start", node->str)) == 0) ? g->start_flag = 1 : 0; ((ft_strcmp("##end", node->str)) == 0) ? g->end_flag = 1 : 0; if ((ft_strncmp("#", node->str, 1)) == 0) { node = node->next; continue; } if (node->str == NULL) error(); check_data(g, node->str); node = node->next; } if (validate(g)) return (1); free(node); return (0); }
int main(int argc, char *argv[]) { // Stack variables int i; float test_out[out_size]; int testOK = 1; // Run the test on Arm p_rgb2grayscale_f32(in, test_out, in_rows, in_cols); // Check data for ( i = 0; i < out_size; i++ ) { if (check_data(test_out[i],out[i], MAX_REL_DIFF) == NOK ) { testOK = 0; printf("Large diff for index %d, ref:%f test: %f rel:%f \n",i,out[i],test_out[i], test_out[i]/out[i]); } } if ( testOK ){ printf("RGB2Grayscale ARM test OK\n"); } else { printf("RGB2Grayscale ARM test FAILED!!\n"); } }
// Implement response to initiator tlm::tlm_sync_enum initiator::nb_transport_bw( PAYLOAD_TYPE& trans, tlm::tlm_phase& phase, sc_time& delay ) { cout << "[SC "<<sc_time_stamp()<<"] Starting nb_transport_bw of " << this->name() << endl; sc_assert(check_data(trans_count,&trans)==true); trans_count++; cout << "[SC "<<sc_time_stamp()<<"] End of nb_transport_bw of " << this->name() << endl; return tlm::TLM_ACCEPTED; }
static int remote_read(apacket *p, atransport *t) { if(usb_read(t->usb, &p->msg, sizeof(amessage))){ D("remote usb: read terminated (message)\n"); return -1; } fix_endians(p); if(check_header(p)) { D("remote usb: check_header failed\n"); return -1; } if(p->msg.data_length) { if(usb_read(t->usb, p->data, p->msg.data_length)){ D("remote usb: terminated (data)\n"); return -1; } } if(check_data(p)) { D("remote usb: check_data failed\n"); return -1; } return 0; }
static void do_write_wait(int len) { uint64_t old_w_cnt, new_w_cnt; uint64_t old_r_cnt, new_r_cnt; ssize_t sz; const int iters = 100; int i; init_data(source, len, 0xab); init_data(target, len, 0); old_w_cnt = fi_cntr_read(write_cntr); old_r_cnt = fi_cntr_read(read_cntr); for (i = 0; i < iters; i++) { sz = fi_write(ep[0], source, len, loc_mr, gni_addr[1], (uint64_t)target, mr_key, target); cr_assert_eq(sz, 0); } fi_cntr_wait(write_cntr, old_w_cnt+iters, -1); new_w_cnt = fi_cntr_read(write_cntr); cr_assert(old_w_cnt + iters == new_w_cnt); cr_assert(check_data(source, target, len), "Data mismatch"); new_r_cnt = fi_cntr_read(read_cntr); /* * no fi_read called so old and new read cnts should be equal */ cr_assert(new_r_cnt == old_r_cnt); }
void do_writedata(int len) { int ret; ssize_t sz; struct fi_cq_tagged_entry cqe, dcqe; #define WRITE_DATA 0x5123da1a145 init_data(source, len, 0x23); init_data(target, len, 0); sz = fi_writedata(ep[0], source, len, loc_mr, WRITE_DATA, gni_addr[1], (uint64_t)target, mr_key, target); cr_assert_eq(sz, 0); while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) { pthread_yield(); } cr_assert_eq(ret, 1); rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0); rdm_rma_check_cntrs(1, 0, 0, 0); dbg_printf("got write context event!\n"); cr_assert(check_data(source, target, len), "Data mismatch"); while ((ret = fi_cq_read(recv_cq, &dcqe, 1)) == -FI_EAGAIN) { pthread_yield(); } cr_assert(ret != FI_SUCCESS, "Missing remote data"); rdm_rma_check_tcqe(&dcqe, NULL, (FI_RMA | FI_REMOTE_WRITE | FI_REMOTE_CQ_DATA), WRITE_DATA); }
static void do_read(int len) { ssize_t sz; uint64_t old_w_cnt, new_w_cnt; uint64_t old_r_cnt, new_r_cnt; #define READ_CTX 0x4e3dda1aULL init_data(source, len, 0); init_data(target, len, 0xad); old_w_cnt = fi_cntr_read(write_cntr); old_r_cnt = fi_cntr_read(read_cntr); sz = fi_read(ep[0], source, len, loc_mr, gni_addr[1], (uint64_t)target, mr_key, (void *)READ_CTX); cr_assert_eq(sz, 0); do { new_r_cnt = fi_cntr_read(read_cntr); if (new_r_cnt == (old_r_cnt + 1)) break; pthread_yield(); } while (1); cr_assert(check_data(source, target, len), "Data mismatch"); new_w_cnt = fi_cntr_read(write_cntr); /* * no fi_read called so old and new read cnts should be equal */ cr_assert(new_w_cnt == old_w_cnt); }
static int zynqmp_validate_bitstream(xilinx_desc *desc, const void *buf, size_t bsize, u32 blocksize, u32 *swap) { ulong *buf_start; ulong diff; buf_start = check_data((u8 *)buf, blocksize, swap); if (!buf_start) return FPGA_FAIL; /* Check if data is postpone from start */ diff = (ulong)buf_start - (ulong)buf; if (diff) { printf("%s: Bitstream is not validated yet (diff %lx)\n", __func__, diff); return FPGA_FAIL; } if ((ulong)buf < SZ_1M) { printf("%s: Bitstream has to be placed up to 1MB (%px)\n", __func__, buf); return FPGA_FAIL; } return 0; }
void do_readv(int len) { int ret; ssize_t sz; struct fi_cq_tagged_entry cqe; struct iovec iov; iov.iov_base = source; iov.iov_len = len; init_data(target, len, 0x25); init_data(source, len, 0); sz = fi_readv(ep[0], &iov, (void **)&loc_mr, 1, gni_addr[1], (uint64_t)target, mr_key, target); cr_assert_eq(sz, 0); while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) { pthread_yield(); } cr_assert_eq(ret, 1); rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_READ, 0); rdm_rma_check_cntrs(0, 1, 0, 0); dbg_printf("got write context event!\n"); cr_assert(check_data(source, target, len), "Data mismatch"); }
void do_write_autoreg_uncached(int len) { int ret; ssize_t sz; struct fi_cq_tagged_entry cqe; init_data(uc_source, len, 0xab); init_data(target, len, 0); sz = fi_write(ep[0], uc_source, len, NULL, gni_addr[1], (uint64_t)target, mr_key, target); cr_assert_eq(sz, 0); while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) { pthread_yield(); } cr_assert_eq(ret, 1); rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0); rdm_rma_check_cntrs(1, 0, 0, 0); dbg_printf("got write context event!\n"); cr_assert(check_data(uc_source, target, len), "Data mismatch"); }
int main(int argc, char **argv) { if(sizeof(int) != 4) { fprintf(stderr, "Your machine's ints are not 4 bytes. " "You need to adjust generate_data() and check_data().\n"); exit(2); } process_args(argc, argv); init_genrand(opt_seed); if(opt_check) { check_data(0, opt_size); } else { generate_data(1, opt_size); } /* int i; printf("1000 outputs of genrand_int32()\n"); for (i=0; i<1000; i++) { printf("%10lu ", genrand_int32()); if (i%5==4) printf("\n"); } */ return 0; }
void do_read(int len) { int ret; ssize_t sz; struct fi_cq_tagged_entry cqe; #define READ_CTX 0x4e3dda1aULL init_data(source, len, 0); init_data(target, len, 0xad); sz = fi_read(ep[0], source, len, loc_mr, gni_addr[1], (uint64_t)target, mr_key, (void *)READ_CTX); cr_assert_eq(sz, 0); while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) { pthread_yield(); } cr_assert_eq(ret, 1); rdm_rma_check_tcqe(&cqe, (void *)READ_CTX, FI_RMA | FI_READ, 0); rdm_rma_check_cntrs(0, 1, 0, 0); dbg_printf("got read context event!\n"); cr_assert(check_data(source, target, len), "Data mismatch"); }
static void do_read_wait(int len) { int i, iters = 100; ssize_t sz; uint64_t old_w_cnt, new_w_cnt; uint64_t old_r_cnt; #define READ_CTX 0x4e3dda1aULL init_data(source, len, 0); init_data(target, len, 0xad); old_w_cnt = fi_cntr_read(write_cntr); old_r_cnt = fi_cntr_read(read_cntr); for (i = 0; i < iters; i++) { sz = fi_read(ep[0], source, len, loc_mr, gni_addr[1], (uint64_t)target, mr_key, (void *)READ_CTX); cr_assert_eq(sz, 0); } fi_cntr_wait(read_cntr, old_r_cnt + iters, -1); cr_assert(check_data(source, target, len), "Data mismatch"); new_w_cnt = fi_cntr_read(write_cntr); /* * no fi_read called so old and new read cnts should be equal */ cr_assert(new_w_cnt == old_w_cnt); }
int main(int argc, char *argv[]) { const int n = 1000000, nr_steps = 1000; int num_threads = 1, step; int *data; #pragma omp parallel { #ifdef _OPENMP #pragma omp master num_threads = omp_get_num_threads(); if (n % num_threads != 0) { errx(EXIT_FAILURE, "number of threads should divide %d", n); } #endif init_data(&data, n); } printf("initialized with %d threads\n", num_threads); printf("processing...\n"); #pragma omp parallel private(step) { { for (step = 0; step < nr_steps; step++) { process_data(data, n); } } } printf("processed with %d threads\n", num_threads); printf("testing...\n"); check_data(data, n, num_threads, 1 + nr_steps); printf("tested\n"); return EXIT_SUCCESS; }
int example_main(int argc, char **argv) { int rc = EXIT_FAILURE; db_t hdb; // db to create and insert rows trans_stat_t stat = { 0, 0 }; hdb = create_database( EXAMPLE_DATABASE, &db_schema, NULL ); if (!hdb) { goto exit; } // Start transactions generation. Part of transactions commit with DB_LAZY_COMPLETION flag to make them to be deferred rc = perform_transactions( hdb, &stat ); db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL); if( rc != EXIT_SUCCESS ) {goto exit; } rc = EXIT_FAILURE; // Reopen DB and check if all transactions are really there hdb = db_open_file_storage(EXAMPLE_DATABASE, NULL); if (!hdb) { goto exit; } rc = check_data( hdb, &stat ); exit: return rc; }
static int test_truncate(int len) { const char *data = testdata; int datalen = testdatalen; int res; start_test("truncate(%u)", (int) len); res = create_file(testfile, data, datalen); if (res == -1) return -1; res = truncate(testfile, len); if (res == -1) { PERROR("truncate"); return -1; } res = check_size(testfile, len); if (res == -1) return -1; if (len > 0) { if (len <= datalen) { res = check_data(testfile, data, 0, len); if (res == -1) return -1; } else { res = check_data(testfile, data, 0, datalen); if (res == -1) return -1; res = check_data(testfile, zerodata, datalen, len - datalen); if (res == -1) return -1; } } res = unlink(testfile); if (res == -1) { PERROR("unlink"); return -1; } res = check_nonexist(testfile); if (res == -1) return -1; success(); return 0; }
static int test_link2(void) { const char *data = testdata; int datalen = testdatalen; int err = 0; int res; start_test("link-unlink-link"); res = create_file(testfile, data, datalen); if (res == -1) return -1; unlink(testfile2); res = link(testfile, testfile2); if (res == -1) { PERROR("link"); return -1; } res = unlink(testfile); if (res == -1) { PERROR("unlink"); return -1; } res = check_nonexist(testfile); if (res == -1) return -1; res = link(testfile2, testfile); if (res == -1) { PERROR("link"); } res = check_type(testfile, S_IFREG); if (res == -1) return -1; err += check_mode(testfile, 0644); err += check_nlink(testfile, 2); err += check_size(testfile, datalen); err += check_data(testfile, data, 0, datalen); res = unlink(testfile2); if (res == -1) { PERROR("unlink"); return -1; } err += check_nlink(testfile, 1); res = unlink(testfile); if (res == -1) { PERROR("unlink"); return -1; } res = check_nonexist(testfile); if (res == -1) return -1; if (err) return -1; success(); return 0; }
void do_write_fence(int len) { int ret; ssize_t sz; struct fi_cq_tagged_entry cqe; struct iovec iov; struct fi_msg_rma msg; struct fi_rma_iov rma_iov; iov.iov_base = source; iov.iov_len = len; rma_iov.addr = (uint64_t)target; rma_iov.len = sizeof(target); rma_iov.key = mr_key; msg.msg_iov = &iov; msg.desc = (void **)&loc_mr; msg.iov_count = 1; msg.addr = gni_addr[1]; msg.rma_iov = &rma_iov; msg.rma_iov_count = 1; msg.context = target; msg.data = (uint64_t)target; init_data(source, len, 0xef); init_data(target, len, 0); /* write A */ sz = fi_writemsg(ep[0], &msg, 0); cr_assert_eq(sz, 0); /* write B */ sz = fi_writemsg(ep[0], &msg, FI_FENCE); cr_assert_eq(sz, 0); /* event A */ while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) { pthread_yield(); } cr_assert_eq(ret, 1); rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0); /* event B */ while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) { pthread_yield(); } cr_assert_eq(ret, 1); rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0); rdm_rma_check_cntrs(2, 0, 0, 0); dbg_printf("got write context event!\n"); cr_assert(check_data(source, target, len), "Data mismatch"); }
/** check if tree of data in zone is valid */ static void checkzonetree(struct val_neg_zone* zone) { struct val_neg_data* d; /* check all data in tree */ RBTREE_FOR(d, struct val_neg_data*, &zone->tree) { check_data(zone, d); } }
void testmain (int argc, char *argv[]) { check_data (); check_onebits (); check_low_z_one (); check_one_2exp (); check_infinity (); }
/****************************************************************************** * @fn modbus_uart_data_process * * @brief Process the message from UART * * @param uint8 - the pointer the buffer that to be process * uint8 - length * * @return none */ void modbus_uart_data_process( uint8 *data_buffer, uint8 len) { P2_1 = 0; if( TRUE == check_data( data_buffer, len)) { initCRC16(); modbus_process_msg( data_buffer, len); } P2_1 = 1; }
int main (void) { tests_start (); check_data (); tests_end (); exit (0); }
int main (int argc, char *argv[]) { tests_start (); check_data (); tests_end (); exit (0); }
int main (void) { tests_start (); mp_trace_base = -16; check_data (); tests_end (); exit (0); }
int main (void) { tests_start (); check_data (); unlink (FILENAME); tests_end (); exit (0); }
int main (int argc, char **argv) { tests_start (); check_data (); check_rand (argc, argv); tests_end (); exit (0); }
int main(int argc, char **argv) { char* shmname = NULL; void* shmptr; int rcnt = -1, wcnt = -1; #ifndef _WIN32 struct timeval tv; #endif unsigned long long start_ms, end_ms; if(argc==4) { shmname = argv[1]; rcnt = atol(argv[2]); wcnt = atol(argv[3]); } if(rcnt<0 || wcnt<0) { fprintf(stderr, "usage: %s <shmname> <readers> <writers>\n", argv[0]); exit(1); } shmptr=wg_attach_database(shmname,DBSIZE); if (shmptr==NULL) exit(2); if(prepare_data(shmptr)) { wg_delete_database(shmname); exit(3); } #ifdef _WIN32 start_ms = (unsigned long long) GetTickCount(); #else gettimeofday(&tv, NULL); start_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000; #endif run_workers(shmptr, rcnt, wcnt); #ifdef _WIN32 end_ms = (unsigned long long) GetTickCount(); #else gettimeofday(&tv, NULL); end_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000; #endif check_data(shmptr, wcnt); fprintf(stdout, "elapsed: %d ms\n", (int) (end_ms - start_ms)); wg_delete_database(shmname); exit(0); }