static void test_resize_null_codec(void) { assert(hp == NULL); CHECK_RES(retval, ARG, hpack_resize, NULL, 0); CHECK_RES(retval, ARG, hpack_resize, &hp, 0); }
static int dt_add_dt(void) { static const char str[] = "2012-03-28T23:55:55"; struct dt_dt_s d; struct dt_dt_s dur; int res = 0; fprintf(stderr, "testing %s +1d1h ...\n", str); d = dt_strpdt(str, NULL, NULL); /* we lack some lovely ctors for this */ dur = dt_dt_initialiser(); dt_make_sandwich(&dur, DT_DAISY, DT_TUNK); dur.dur = 1; dur.neg = 0; dur.d.daisy = 1; dur.t.dur = 1; dur.t.neg = 0; dur.t.sdur = 3600; /* the actual addition */ d = dt_dtadd(d, dur); CHECK(d.d.typ != DT_YMD, " DATE TYPE DIFFERS %u ... should be %u\n", (unsigned int)d.d.typ, (unsigned int)DT_YMD); CHECK(d.t.typ != DT_HMS, " TIME TYPE DIFFERS %u ... should be %u\n", (unsigned int)d.t.typ, (unsigned int)DT_HMS); CHECK(d.dur, " DURATION BIT SET\n"); CHECK(d.neg, " NEGATED BIT SET\n"); CHECK(d.t.dur, " TIME DURATION BIT SET\n"); CHECK(d.t.neg, " TIME NEGATED BIT SET\n"); CHECK_EQ((unsigned int)d.d.ymd.y, 2012U, " YEAR %u ... should be %u\n"); CHECK_EQ((unsigned int)d.d.ymd.m, 3U, " MONTH %u ... should be %u\n"); CHECK_EQ((unsigned int)d.d.ymd.d, 30U, " DAY %u ... should be %u\n"); CHECK_EQ((unsigned int)d.t.hms.h, 00U, " HOUR %u ... should be %u\n"); CHECK_EQ((unsigned int)d.t.hms.m, 55U, " MINUTE %u ... should be %u\n"); CHECK_EQ((unsigned int)d.t.hms.s, 55U, " SECOND %u ... should be %u\n"); /* make sure the padding leaves no garbage */ CHECK_RES(res, d.d.ymd.u & ~0x1fffff, " PADDING NOT NAUGHT %x\n", (unsigned int)(d.d.ymd.u & ~0x1fffff)); CHECK_RES(res, d.t.hms.u & ~0x1f3f3f3fffffff, " TIME PADDING NOT NAUGHT %x\n", (unsigned int)(d.t.hms.u & ~0x1f3f3f3fffffff)); return res; }
static void test_trim_null_codec(void) { assert(hp == NULL); CHECK_RES(retval, ARG, hpack_trim, NULL); CHECK_RES(retval, ARG, hpack_trim, &hp); }
int main(int argc, char* argv[]) { VCFAPIStatus res = VCFAPI_STATUS_SUCCESS; // // Create and initialize VCF run-time // VCFAPI myVCFAPI; res = myVCFAPI.Init(); CHECK_RES(res, "Failed to initialize VCF runtime. Missing RT DLL/so ???\n"); // // Load a VCF graph workload // VCFGraph* myGraph; res = myVCFAPI.LoadFile("vcf_transcode.graphml", &myGraph); CHECK_RES(res, "Failed to load graph\n"); // // Execute VCF graph // res = myGraph->Run(); CHECK_RES(res, "Failed to run graph\n"); // // Wait for VCF graph execution to complete // res = myVCFAPI.WaitForSingle(myGraph); printf("VCF Graph execution completed (result code = %d)\n", res); // Release VCF graph resources myGraph->Release(); return res; }
static void test_limit_null_encoder(void) { assert(hp == NULL); CHECK_RES(retval, ARG, hpack_limit, &hp, 0); CHECK_RES(retval, ARG, hpack_limit, NULL, 0); }
static int test_dt_no_fmt(void) { static const char str[] = "2012-03-28 12:34:56"; struct dt_dt_s d; int res = 0; fprintf(stderr, "testing %s ...\n", str); d = dt_strpdt(str, NULL, NULL); CHECK(!d.sandwich, " NOT A SANDWICH ... but should be\n"); CHECK(!dt_sandwich_p(d), " TYPE is not a sandwich\n"); CHECK(d.d.typ != DT_YMD, " TYPE DIFFERS %u ... should be %u\n", (unsigned int)d.d.typ, (unsigned int)DT_YMD); CHECK(d.t.typ != DT_HMS, " TIME TYPE DIFFERS %u ... should be %u\n", (unsigned int)d.t.typ, (unsigned int)DT_HMS); CHECK(d.dur, " DURATION BIT SET\n"); CHECK(d.neg, " NEGATED BIT SET\n"); CHECK(d.t.dur, " TIME DURATION BIT SET\n"); CHECK(d.t.neg, " TIME DURATION BIT SET\n"); CHECK(d.d.ymd.y != 2012, " YEAR %u ... should be 2012\n", (unsigned int)d.d.ymd.y); CHECK(d.d.ymd.m != 3, " MONTH %u ... should be 3\n", (unsigned int)d.d.ymd.m); CHECK(d.d.ymd.d != 28, " DAY %u ... should be 28\n", (unsigned int)d.d.ymd.d); CHECK(d.t.hms.h != 12, " HOUR %u ... should be 12\n", (unsigned int)d.t.hms.h); CHECK(d.t.hms.m != 34, " MINUTE %u ... should be 34\n", (unsigned int)d.t.hms.m); CHECK(d.t.hms.s != 56, " SECOND %u ... should be 56\n", (unsigned int)d.t.hms.s); CHECK(d.t.hms.ns != 0, " NANOSECOND %u ... should be 0\n", (unsigned int)d.t.hms.ns); /* make sure the padding leaves no garbage */ CHECK_RES(res, d.d.ymd.u & ~0x1fffff, " PADDING NOT NAUGHT %x\n", (unsigned int)(d.d.ymd.u & ~0x1fffff)); CHECK_RES(res, d.t.hms.u & ~0x1f3f3f3fffffff, " PADDING NOT NAUGHT %x\n", (unsigned int)(d.t.hms.u & ~0x1f3f3f3fffffff)); return res; }
static void test_limit_realloc_failure(void) { hp = make_encoder(4096, 2048, &oom_alloc); CHECK_RES(retval, OK, hpack_encode, hp, &basic_encoding, 0); CHECK_RES(retval, OOM, hpack_limit, &hp, 4096); hpack_free(&hp); }
static void test_trim_realloc_failure(void) { hp = make_decoder(4096, -1, &oom_alloc); CHECK_RES(retval, OK, hpack_resize, &hp, 0); CHECK_RES(retval, OK, hpack_decode, hp, &update_decoding, 0); CHECK_RES(retval, OOM, hpack_trim, &hp); hpack_free(&hp); }
static void test_limit_null_realloc(void) { hp = make_encoder(4096, 0, &static_alloc); CHECK_RES(retval, OK, hpack_encode, hp, &basic_encoding, 0); CHECK_RES(retval, ARG, hpack_limit, &hp, 4096); hpack_free(&hp); }
static void test_foreach(void) { hp = make_decoder(0, -1, &static_alloc); CHECK_RES(retval, OK, hpack_static, noop_cb, NULL); CHECK_RES(retval, OK, hpack_dynamic, hp, noop_cb, NULL); CHECK_RES(retval, OK, hpack_tables, hp, noop_cb, NULL); hpack_free(&hp); }
static void test_trim_to_limit(void) { hp = make_encoder(512, -1, hpack_default_alloc); CHECK_RES(retval, OK, hpack_limit, &hp, 256); CHECK_RES(retval, OK, hpack_encode, hp, &basic_encoding, 0); CHECK_RES(retval, OK, hpack_trim, &hp); hpack_free(&hp); }
static void test_use_busy_decoder(void) { hp = make_decoder(0, -1, hpack_default_alloc); CHECK_RES(retval, BLK, hpack_decode, hp, &double_decoding, 1); CHECK_RES(retval, BSY, hpack_resize, &hp, 0); CHECK_RES(retval, BSY, hpack_trim, &hp); CHECK_RES(retval, BSY, hpack_dynamic, hp, noop_cb, NULL); hpack_free(&hp); }
static void test_foreach_null_args(void) { hp = make_decoder(0, -1, hpack_default_alloc); CHECK_RES(retval, ARG, hpack_dynamic, NULL, NULL, NULL); CHECK_RES(retval, ARG, hpack_dynamic, hp, NULL, NULL); CHECK_RES(retval, ARG, hpack_static, NULL, NULL); CHECK_RES(retval, ARG, hpack_tables, NULL, NULL, NULL); hpack_free(&hp); }
static void test_limit_between_two_resizes(void) { hp = make_encoder(512, -1, &static_alloc); CHECK_RES(retval, OK, hpack_limit, &hp, 256); CHECK_RES(retval, OK, hpack_resize, &hp, 1024); CHECK_RES(retval, OK, hpack_encode, hp, &basic_encoding, 0); CHECK_RES(retval, OK, hpack_resize, &hp, 2048); hpack_free(&hp); }
static void test_use_defunct_decoder(void) { hp = make_decoder(0, -1, hpack_default_alloc); /* break the decoder */ CHECK_RES(retval, IDX, hpack_decode, hp, &junk_decoding, 0); /* try using it again */ CHECK_RES(retval, ARG, hpack_decode, hp, &junk_decoding, 0); hpack_free(&hp); }
int test_create_file(char *name) { spiffs_stat s; spiffs_file fd; int res = SPIFFS_creat(FS, name, 0); CHECK_RES(res); fd = SPIFFS_open(FS, name, SPIFFS_RDONLY, 0); CHECK(fd >= 0); res = SPIFFS_fstat(FS, fd, &s); CHECK_RES(res); CHECK(strcmp((char*)s.name, name) == 0); CHECK(s.size == 0); SPIFFS_close(FS, fd); return 0; }
int main(int argc, char* argv[]) { VCFAPIStatus res = VCFAPI_STATUS_SUCCESS; // // Create and initialize VCF run-time // VCFAPI myVCFAPI; res = myVCFAPI.Init(); CHECK_RES(res, "Failed to initialize VCF runtime. Missing RT DLL/so ???\n"); // // Subscribe for runtime level events // MyRTCallbacks rtCallbacks; res = myVCFAPI.SubscribeEvents(VCFAPI_EVENTMASK_STATUS_CORE_ERROR | VCFAPI_EVENTMASK_STATUS_CORE_INFO, &rtCallbacks); CHECK_RES(res, "Failed to subscribe to runtime events\n"); // // Load a VCF graph workload // VCFGraph* myGraph; res = myVCFAPI.LoadFile("vcf_transcode.graphml", &myGraph); CHECK_RES(res, "Failed to load graph\n"); // // Subscribe for graph level events // MyGraphCallbacks graphcallbacks; res = myGraph->SubscribeEvents(VCFGRAPH_EVENTMASK_STATUS_PROGRESS | VCFGRAPH_EVENTMASK_BENCHMARK_DATA, &graphcallbacks); CHECK_RES(res, "Failed to subscribe to graph events\n"); // // Execute VCF graph // res = myGraph->Run(); CHECK_RES(res, "Failed to run graph\n"); // // Wait for VCF graph execution to complete // res = myVCFAPI.WaitForSingle(myGraph); printf("VCF Graph execution completed (result code = %d)\n", res); // Release VCF graph resources myGraph->Release(); return res; }
ERL_NIF_TERM trans(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary in; cloner* ptr; const Transliterator* t; UnicodeString input; if (argc != 2) return enif_make_badarg(env); /* Second argument must be a binary */ if(!(enif_inspect_binary(env, argv[1], &in) && enif_get_resource(env, argv[0], trans_type, (void**) &ptr))) { return enif_make_badarg(env); } t = (Transliterator*) cloner_get(ptr); CHECK_RES(env, t); input = copy_binary_to_string(in); t->transliterate(input); return string_to_term(env, input); }
ERL_NIF_TERM date_get6(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { UErrorCode status = U_ZERO_ERROR; UCalendar* cal; cloner* ptr; int32_t year, month, day, hour, minute, second; if(!((argc == 7) && enif_get_resource(env, argv[0], calendar_type, (void**) &ptr) && enif_get_int(env, argv[1], &year) && enif_get_int(env, argv[2], &month) && enif_get_int(env, argv[3], &day) && enif_get_int(env, argv[4], &hour) && enif_get_int(env, argv[5], &minute) && enif_get_int(env, argv[6], &second))) { return enif_make_badarg(env); } month--; cal = (UCalendar*) cloner_get(ptr); CHECK_RES(env, cal); ucal_setDateTime(cal, year, month, day, hour, minute, second, &status); CHECK(env, status); return calendar_to_double(env, (const UCalendar*) cal); }
static void test_clean_indexed_field_with_indexed_name(void) { (void)memset(&fld, 0, sizeof fld); fld.flg = HPACK_FLG_TYP_IDX | HPACK_FLG_NAM_IDX; CHECK_RES(retval, ARG, hpack_clean_field, &fld); }
ERL_NIF_TERM date_get_field(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { UErrorCode status = U_ZERO_ERROR; UCalendar* cal; cloner* ptr; double date; ERL_NIF_TERM res; if(!((argc == 3) && enif_get_resource(env, argv[0], calendar_type, (void**) &ptr) && enif_get_double(env, argv[1], &date))) { return enif_make_badarg(env); } cal = (UCalendar*) cloner_get(ptr); CHECK_RES(env, cal); ucal_setMillis(cal, (UDate) date, &status); CHECK(env, status); res = do_date_get_field(env, cal, argv[2], status); CHECK(env, status); return res; }
extern void cyg_start(void) { //CYG_TEST_INIT(); //CYG_TEST_NA("Kernel C API layer disabled"); GL_Status_t res; diag_printf("GSL test beginning\n"); GL_Init(); res = GL_QueueCreate("queue1", 511, 10, 5, &queue_id1); CHECK_RES((res == GL_SUCCESS)) res = GL_TaskCreate("Task1", entry1, NULL, 12, 4 * 1024, true, &task1); CHECK_RES((res == GL_SUCCESS)) res = GL_TaskCreate("Task2", entry2, NULL, 12, 4 * 1024, true, &task2); CHECK_RES((res == GL_SUCCESS)) res = GL_TaskCreate("Task3", entry3, NULL, 12, 4 * 1024, true, &task3); CHECK_RES((res == GL_SUCCESS)) cyg_scheduler_start(); }
ERL_NIF_TERM split(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary in; cloner* ptr; UBreakIterator* iter; int len = -1, last, pos, is_valid; UErrorCode status = U_ZERO_ERROR; ERL_NIF_TERM head, tail; UChar* bin; UChar* text; if (argc != 2) return enif_make_badarg(env); /* Last argument must be a binary */ if (!(enif_inspect_binary(env, argv[1], &in) && enif_get_resource(env, argv[0], iterator_type, (void**) &ptr))) { return enif_make_badarg(env); } iter = (UBreakIterator*) cloner_get(ptr); CHECK_RES(env, iter); if (iter == NULL) { return enif_make_badarg(env); } text = (UChar*) in.data; ubrk_setText(iter, text, TO_ULEN(in.size), &status); CHECK(env, status); tail = enif_make_list(env, 0); pos = (int) ubrk_last(iter); while (pos) { last = pos; is_valid = is_valid_elem(ptr, iter); /* get the next elem. */ pos = (int) ubrk_previous(iter); if (pos == UBRK_DONE) pos = 0; if (is_valid) /* Is the old element valid? */ { len = FROM_ULEN(last - pos); bin = (UChar*) enif_make_new_binary(env, len, &head); memcpy(bin, (const char*) (text + pos), len); tail = enif_make_list_cell(env, head, tail); } }; return tail; }
static void test_resize_realloc_failure(void) { hp = make_decoder(0, -1, &oom_alloc); CHECK_RES(retval, OOM, hpack_resize, &hp, UINT16_MAX); hpack_free(&hp); }
static void test_resize_overflow(void) { hp = make_decoder(0, -1, &static_alloc); CHECK_RES(retval, LEN, hpack_resize, &hp, UINT16_MAX + 1); hpack_free(&hp); }
static void test_trim_null_realloc(void) { hp = make_decoder(0, -1, &static_alloc); CHECK_RES(retval, ARG, hpack_trim, &hp); hpack_free(&hp); }
static void test_limit_overflow_no_realloc(void) { hp = make_encoder(0, -1, &static_alloc); CHECK_RES(retval, LEN, hpack_limit, &hp, UINT16_MAX + 1); hpack_free(&hp); }
static void test_limit_decoder(void) { hp = make_decoder(4096, -1, hpack_default_alloc); CHECK_RES(retval, ARG, hpack_limit, &hp, 0); hpack_free(&hp); }
/*! * \internal * \brief Converts a pjsip_rx_data structure to an ast_msg structure. * * \details Attempts to fill in as much information as possible into the given * msg structure copied from the given request data. * * \param rdata The SIP request * \param msg The asterisk message structure to fill in. */ static enum pjsip_status_code rx_data_to_ast_msg(pjsip_rx_data *rdata, struct ast_msg *msg) { #define CHECK_RES(z_) do { if (z_) { ast_msg_destroy(msg); \ return PJSIP_SC_INTERNAL_SERVER_ERROR; } } while (0) int size; char buf[MAX_BODY_SIZE]; pjsip_name_addr *name_addr; const char *field; pjsip_status_code code; struct ast_sip_endpoint *endpt = ast_pjsip_rdata_get_endpoint(rdata); const char *context = S_OR(endpt->message_context, endpt->context); /* make sure there is an appropriate context and extension*/ if ((code = get_destination(rdata, context, buf)) != PJSIP_SC_OK) { return code; } CHECK_RES(ast_msg_set_context(msg, "%s", context)); CHECK_RES(ast_msg_set_exten(msg, "%s", buf)); /* to header */ name_addr = (pjsip_name_addr *)rdata->msg_info.to->uri; if ((size = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, name_addr, buf, sizeof(buf)-1)) > 0) { buf[size] = '\0'; /* prepend the tech */ CHECK_RES(ast_msg_set_to(msg, "%s", sip_to_pjsip(buf, ++size, sizeof(buf)-1))); } /* from header */ name_addr = (pjsip_name_addr *)rdata->msg_info.from->uri; if ((size = pjsip_uri_print(PJSIP_URI_IN_FROMTO_HDR, name_addr, buf, sizeof(buf)-1)) > 0) { buf[size] = '\0'; CHECK_RES(ast_msg_set_from(msg, "%s", buf)); } /* receive address */ field = pj_sockaddr_print(&rdata->pkt_info.src_addr, buf, sizeof(buf)-1, 1); CHECK_RES(ast_msg_set_var(msg, "PJSIP_RECVADDR", field)); /* body */ if (print_body(rdata, buf, sizeof(buf) - 1) > 0) { CHECK_RES(ast_msg_set_body(msg, "%s", buf)); } /* endpoint name */ if (endpt->id.self.name.valid) { CHECK_RES(ast_msg_set_var(msg, "PJSIP_PEERNAME", endpt->id.self.name.str)); } CHECK_RES(headers_to_vars(rdata, msg)); return PJSIP_SC_OK; }
ERL_NIF_TERM date_clear(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { UErrorCode status = U_ZERO_ERROR; UCalendar* cal; cloner* ptr; double date; UCalendarDateFields field; ERL_NIF_TERM head, tail; unsigned int count, i = 0; char value[ATOM_LEN]; int parsed_value; if(!((argc == 3) && enif_get_resource(env, argv[0], calendar_type, (void**) &ptr) && enif_get_double(env, argv[1], &date) && enif_get_list_length(env, argv[2], &count))) { return enif_make_badarg(env); } cal = (UCalendar*) cloner_get(ptr); CHECK_RES(env, cal); ucal_setMillis(cal, (UDate) date, &status); CHECK(env, status); tail = argv[2]; while (enif_get_list_cell(env, tail, &head, &tail)) { /* Set an attribute start */ if (!enif_get_atom(env, head, (char*) value, ATOM_LEN, ERL_NIF_LATIN1)) goto bad_elem; parsed_value = parseCalendarDateField(value); if ((parsed_value == -1)) goto bad_elem; field = (UCalendarDateFields) parsed_value; ucal_clearField(cal, field); if (U_FAILURE(status)) goto bad_elem; /* Set an attribute end */ } return calendar_to_double(env, (const UCalendar*) cal); bad_elem: return list_element_error(env, argv[2], i); }