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);
}
