int
main(int argc, char ** argv)
{
char buf[1024];
char cmd[1024];
char expect[1024];
int return_val;
char cmd_quote;
SXE_UNUSED_PARAMETER(argc);
plan_tests(10);
is(sxe_spawn_init(), SXE_RETURN_OK, "Initialized: sxe-spawn");
/* Test a basic command */
return_val = sxe_spawn_backticks("ls", buf, sizeof(buf));
ok(return_val > 0, "Ran a basic backtick command");
#ifdef WIN32
cmd_quote = '\"';
#else
cmd_quote = '\'';
#endif
/* Try a complex command */
snprintf(cmd, sizeof(cmd), "perl -e %c print qq{foo\nbar\nbaz} %c | grep bar", cmd_quote, cmd_quote);
is(sxe_spawn_backticks(cmd, buf, sizeof(buf)), 4, "Ran a perl command");
is_eq("bar\n", buf, "The strings match");
/* Do an 'ls' of this file */
snprintf(cmd, sizeof(cmd), "ls %s", argv[0]);
snprintf(expect, sizeof(expect), "%s\n", argv[0]);
is(sxe_spawn_backticks(cmd, buf, sizeof(buf)), strlen(expect), "Ran an ls of this file");
diag("Ran: >%s<\nGot: >%s<\nExpect: >%s<\n", cmd, buf, argv[0]);
is_eq(expect, buf, "Strings are the same");
buf[0] = 'X'; buf[1] = 'X'; buf[2] = 'X';
/* Note: sxe_spawn_backticks asserts if buffer is less than 2 */
/* buffer is 2 */
is(sxe_spawn_backticks(cmd, buf, 2), 1, "Ran a basic backtick command");
is(buf[0], expect[0], "length of 2 buffer[0]");
is(buf[1], '\0', "length of 2 buffer[1]");
is(buf[2], 'X', "length of 2 buffer[2]");
return exit_status();
}
void test_box(void)
{
printf("\nbox conversion\n");
LOOP {
size_t i, dim = 5;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_interval_t** pki,**ppli;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pki = ap_abstract0_to_box(pk,pka);
ppli = ap_abstract0_to_box(ppl,ppla);
pkr = ap_abstract0_of_box(pk,0,dim,(ap_interval_t**)pki);
pplr = ap_abstract0_of_box(ppl,0,dim,(ap_interval_t**)ppli);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
for (i=0;i<dim;i++) {
fprintf(stderr,"pki[%i]=",(int)i); ap_interval_fprint(stderr,pki[i]);
fprintf(stderr," ppli[%i]=",(int)i); ap_interval_fprint(stderr,ppli[i]);
fprintf(stderr,"\n");
}
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_interval_array_free(pki,dim); ap_interval_array_free(ppli,dim);
} ENDLOOP;
}
virtual action_result resolve(expr const & pr) const override {
try {
expr it = pr;
bool skip = true;
for (unsigned i = 0; i < m_num_new_eqs; i++) {
if (!is_lambda(it)) {
break;
skip = false;
}
it = binding_body(it);
}
if (skip && closed(it)) {
// new eq hypotheses were not used
return action_result::solved(it);
}
state & s = curr_state();
app_builder & b = get_app_builder();
hypothesis const & h = s.get_hypothesis_decl(href_index(m_eq_href));
expr type = h.get_type();
expr lhs, rhs;
lean_verify(is_eq(type, lhs, rhs));
name nc_name(m_I_name, "no_confusion");
expr new_pr = mk_app(b.mk_app(nc_name, {m_target, lhs, rhs, m_eq_href}), pr);
return action_result::solved(new_pr);
} catch (app_builder_exception &) {
return action_result::failed();
}
}
void test_add_lincons(void)
{
printf("\nadd lincons\n");
LOOP {
size_t i, dim = 5, nb = 4;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_lincons0_array_t ar = ap_lincons0_array_make(nb);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
for (i=0;i<nb;i++) {
ar.p[i] = ap_lincons0_make((rand()%100>=90)?AP_CONS_EQ:
(rand()%100>=90)?AP_CONS_SUP:AP_CONS_SUPEQ,
random_linexpr(dim),NULL);
}
pkr = ap_abstract0_meet_lincons_array(pk,false,pka,&ar);
pplr = ap_abstract0_meet_lincons_array(ppl,false,ppla,&ar);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_lincons0_array_fprint(stderr,&ar,NULL);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_lincons0_array_clear(&ar);
} ENDLOOP;
}
int
main(void)
{
SXE_LUA *sxel = sxe_lua_new();
snprintf(s_string, sizeof s_string, "Goodbye, cruel world");
sxe_lua_tie_field(sxel, "test", "bool", 'b', &s_bool);
sxe_lua_tie_field(sxel, "test", "int", 'i', &s_int);
sxe_lua_tie_field(sxel, "test", "uint", 'i', &s_uint);
sxe_lua_tie_field(sxel, "test", "long", 'l', &s_long);
sxe_lua_tie_field(sxel, "test", "ulong", 'l', &s_ulong);
sxe_lua_tie_field(sxel, "test", "str", 's', s_string, sizeof s_string);
SXEL10("sxelua: loading sxelua handlers");
sxe_lua_load(sxel, "../test/test-sxe-lua.lua");
sxe_init();
sxe_lua_init(sxel);
ev_loop(ev_default_loop(EVFLAG_AUTO), 0);
is_eq(s_string, "Hello, world", "tied string set to 'Hello, world'");
is(s_int, 10, "tied integer set to '10'");
is(s_uint, 128, "tied unsigned set to '128'");
is(s_long, 42L, "tied long set to '42'");
is(s_ulong, -2UL, "tied unsigned long set to '-2'");
is(s_bool, 1, "tied boolean set to '1'");
return exit_status();
}
void test_fold(void)
{
printf("\nfold dimensions\n");
LOOP {
size_t i, dim = 5;
ap_dim_t dd[3];
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
do {
dd[0] = rand() % dim;
if (dd[0]<d.intdim) dd[1] = rand() % (d.intdim-1);
else dd[1] = d.intdim + rand() % (d.realdim-1);
}
while (dd[0]>=dd[1]);
pkr = ap_abstract0_fold(pk,false,pka,dd,2);
pplr = ap_abstract0_fold(ppl,false,ppla,dd,2);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
fprintf(stderr,"fold %i,%i,%i\n",(int)dd[0],(int)dd[1],(int)dd[2]);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
void test_par_subst(void)
{
printf("\nparallel subst\n");
LOOP {
size_t i, dim = 5;
size_t p = rand() % dim;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dim_t d[NB];
ap_linexpr0_t *l[NB];
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
for (i=0;i<NB;i++) {
l[i] = random_linexpr(dim);
if (!i) d[i] = rand()%(dim-NB);
else d[i] = d[i-1] + 1 + (rand()%(dim-NB+i-d[i-1]));
}
pkr = ap_abstract0_substitute_linexpr_array(pk,false,pka,d,(ap_linexpr0_t**)l,NB,NULL);
pplr = ap_abstract0_substitute_linexpr_array(ppl,false,ppla,d,(ap_linexpr0_t**)l,NB,NULL);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
for (i=0;i<NB;i++) {
fprintf(stderr,"x%i -> ",d[i]);
ap_linexpr0_fprint(stderr,l[i],NULL);
fprintf(stderr,"\n");
}
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
for (i=0;i<NB;i++) ap_linexpr0_free(l[i]);
} ENDLOOP;
}
void test_permute(void)
{
printf("\npermute dimensions\n");
LOOP {
size_t i, dim = 5;
ap_dimperm_t* p = ap_dimperm_alloc(dim);
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
/* random permutation */
ap_dimperm_set_id(p);
for (i=0;i<p->size-1;i++) {
int a, j;
if (i<d.intdim) j = i + (rand() % (d.intdim-i));
else j = i + (rand() % (d.intdim+d.realdim-i));
a = p->dim[j]; p->dim[j] = p->dim[i]; p->dim[i] = a;
}
pkr = ap_abstract0_permute_dimensions(pk,false,pka,p);
pplr = ap_abstract0_permute_dimensions(ppl,false,ppla,p);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_dimperm_fprint(stderr,p);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_dimperm_free(p);
} ENDLOOP;
}
void test_forget(void)
{
printf("\nforget\n");
LOOP {
size_t i, dim = 5;
ap_dimchange_t* a = ap_dimchange_alloc(0,2);
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
int proj = rand()%2;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
for (i=0;i<a->intdim+a->realdim;i++) {
a->dim[i] = rand()%2 + 1;
if (i) a->dim[i] += a->dim[i-1];
if (a->dim[i]<d.intdim) { a->intdim++; a->realdim--; }
assert(a->dim[i]<dim);
}
pkr = ap_abstract0_forget_array(pk,false,pka,a->dim,a->realdim,proj);
pplr = ap_abstract0_forget_array(ppl,false,ppla,a->dim,a->realdim,proj);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_dimchange_fprint(stderr,a);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_dimchange_free(a);
} ENDLOOP;
}
int
main(void)
{
char * str;
struct timeval timeval_first;
struct timeval timeval_next;
unsigned long diff;
plan_tests(4);
ok(test_vasprintf(&str, "hello, %s.", "world") >= 0, "vasprintf succeeded: %s", strerror(errno));
is_eq(str, "hello, world.", "vasprintf formatted 'hello, world.' into the buffer");
ok(gettimeofday(&timeval_first, NULL) >= 0, "gettimeofday got the first time: %s", strerror(errno));
for (;;) {
if (gettimeofday(&timeval_next, NULL) < 0) {
fail("gettimeofday failed the next time: %s", strerror(errno));
return exit_status();
}
if ((timeval_first.tv_sec != timeval_next.tv_sec) || (timeval_first.tv_usec != timeval_next.tv_usec)) {
break;
}
}
diff = (timeval_next.tv_sec - timeval_first.tv_sec) * 1000000 + timeval_next.tv_usec - timeval_first.tv_usec;
ok(diff <= 50000, "gettimeofday: Clock period %ld is less than 0.05 seconds", diff);
return exit_status();
}
rational pb_util::get_coeff(func_decl* a, unsigned index) const {
if (is_at_most_k(a) || is_at_least_k(a)) {
return rational::one();
}
SASSERT(is_le(a) || is_ge(a) || is_eq(a));
SASSERT(1 + index < a->get_num_parameters());
return to_rational(a->get_parameter(index + 1));
}
bool pb_util::is_eq(expr* a, rational& k) const {
if (is_eq(a)) {
k = get_k(a);
return true;
}
else {
return false;
}
}
char* find(char *haystack, char needle) {
int i = 0;
for(; i < strlen(haystack); i++) {
if(is_eq(haystack[i], needle)) {
return &haystack[i];
}
}
return NULL;
}
void test_conv(void)
{
int dim = 5;
printf("\nconversions\n");
LOOP {
ap_abstract0_t* pk0 = random_poly(pk,dim);
ap_abstract0_t* ppl0 = convert(ppl,pk0);
ap_abstract0_t* pk1 = convert(pk,ppl0);
ap_abstract0_t* ppl1 = convert(ppl,pk1);
RESULT('*');
if (!is_eq(pk0,pk1) || !is_eq(ppl0,ppl1)) {
ERROR("different results");
print_poly("pk0",pk0); print_poly("ppl0",ppl0);
print_poly("pk1",pk1); print_poly("ppl1",ppl1);
}
ap_abstract0_free(pk,pk0); ap_abstract0_free(pk,pk1);
ap_abstract0_free(ppl,ppl0); ap_abstract0_free(ppl,ppl1);
} ENDLOOP;
}
rational pb_util::get_k(func_decl *a) const {
parameter const& p = a->get_parameter(0);
if (is_at_most_k(a) || is_at_least_k(a)) {
return to_rational(p);
}
else {
SASSERT(is_le(a) || is_ge(a) || is_eq(a));
return to_rational(p);
}
}
int main()
{
plan(1);
int i;
scanf("%d", &i);
is_eq(i, 7);
done_testing();
}
Cell define(Cell var, Cell val, Cell env) {
Cell l = lookup(var, env);
if (is_atom(l) && !is_eq(l, atom("#<unbound>"))) {
fprintf(stderr, "can't redefine\n");
}
//Cell binding = cons(var, val);
Cell frame = car(env);
set_car(frame, cons(var, car(frame)));
set_cdr(frame, cons(val, cdr(frame)));
return atom("#<void>");
}
action_result no_confusion_action(hypothesis_idx hidx) {
try {
state & s = curr_state();
app_builder & b = get_app_builder();
hypothesis const & h = s.get_hypothesis_decl(hidx);
expr type = h.get_type();
expr lhs, rhs;
if (!is_eq(type, lhs, rhs))
return action_result::failed();
lhs = whnf(lhs);
rhs = whnf(rhs);
optional<name> c1 = is_constructor_app(env(), lhs);
optional<name> c2 = is_constructor_app(env(), rhs);
if (!c1 || !c2)
return action_result::failed();
expr A = whnf(infer_type(lhs));
expr I = get_app_fn(A);
if (!is_constant(I) || !inductive::is_inductive_decl(env(), const_name(I)))
return action_result::failed();
name nct_name(const_name(I), "no_confusion_type");
if (!env().find(nct_name))
return action_result::failed();
expr target = s.get_target();
expr nct = whnf(b.mk_app(nct_name, target, lhs, rhs));
if (c1 == c2) {
if (!is_pi(nct))
return action_result::failed();
if (s.has_target_forward_deps(hidx)) {
// TODO(Leo): we currently do not handle this case.
// To avoid non-termination we remove the given hypothesis, if there
// forward dependencies, we would also have to remove them.
// Remark: this is a low priority refinement since it will not happen
// very often in practice.
return action_result::failed();
}
unsigned num_params = *inductive::get_num_params(env(), const_name(I));
unsigned cnstr_arity = get_arity(env().get(*c1).get_type());
lean_assert(cnstr_arity >= num_params);
unsigned num_new_eqs = cnstr_arity - num_params;
s.push_proof_step(new no_confusion_proof_step_cell(const_name(I), target, h.get_self(), num_new_eqs));
s.set_target(binding_domain(nct));
s.del_hypothesis(hidx);
trace_action("no_confusion");
return action_result::new_branch();
} else {
name nc_name(const_name(I), "no_confusion");
expr pr = b.mk_app(nc_name, {target, lhs, rhs, h.get_self()});
trace_action("no_confusion");
return action_result::solved(pr);
}
} catch (app_builder_exception &) {
return action_result::failed();
}
}
Cell lookup(Cell var, Cell env) {
while (!is_null(env)) {
Cell frame = car(env);
Cell vars = car(frame);
Cell vals = cdr(frame);
while (!is_null(vars)) {
if (is_eq(car(vars), var)) {
return car(vals);
}
vars = cdr(vars);
vals = cdr(vals);
}
env = cdr(env);
}
return atom("#<unbound>");
}
Cell set(Cell var, Cell val, Cell env) {
while (!is_null(env)) {
Cell frame = car(env);
Cell vars = car(frame);
Cell vals = cdr(frame);
while (!is_null(vars)) {
if (is_eq(car(vars), var)) {
set_car(vals, val);
return atom("#<void>");
}
vars = cdr(vars);
vals = cdr(vals);
}
env = cdr(env);
}
fprintf(stderr, "unbound variable\n");
}
int main(int ac, char** av)
{
#define DEFINE_HANDLER(__s) { #__s, sizeof(#__s) - 1, do_ ## __s }
static struct
{
const char* s;
uint8_t len;
void (*f)(const char*, uint8_t);
} h[] =
{
DEFINE_HANDLER(addr),
DEFINE_HANDLER(rmem),
DEFINE_HANDLER(wmem),
DEFINE_HANDLER(rrom),
DEFINE_HANDLER(llen)
};
static const uint8_t n = sizeof(h) / sizeof(h[0]);
uint8_t i;
uint8_t len;
uart_setup();
ds2433_setup();
while (1)
{
len = read_line(line_buf, sizeof(line_buf));
if (len == 0) continue ;
for (i = 0; i != n; ++i)
{
if (len < h[i].len) continue ;
if (is_eq(line_buf, h[i].s, h[i].len)) break ;
}
if (i != n) h[i].f(line_buf + h[i].len, len - h[i].len);
else write_ko();
}
return 0;
}
void test_meet(void)
{
int dim = 4;
printf("\nbinary meet\n");
LOOP {
ap_abstract0_t* pk0 = random_poly(pk,dim);
ap_abstract0_t* pk1 = random_poly(pk,dim);
ap_abstract0_t* pkr = ap_abstract0_meet(pk,false,pk0,pk1);
ap_abstract0_t* ppl0 = convert(ppl,pk0);
ap_abstract0_t* ppl1 = convert(ppl,pk1);
ap_abstract0_t* pplr = ap_abstract0_meet(ppl,false,ppl0,ppl1);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
print_poly("pk0",pk0); print_poly("pk1",pk1);
print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pk0); ap_abstract0_free(pk,pk1); ap_abstract0_free(pk,pkr);
ap_abstract0_free(ppl,ppl0); ap_abstract0_free(ppl,ppl1); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
void test_meet_array(void)
{
int i,dim = 3;
printf("\narray meet\n");
LOOP {
ap_abstract0_t* pka[NB], *pkr;
ap_abstract0_t* ppla[NB], *pplr;
for (i=0;i<NB;i++) {
pka[i] = random_poly(pk,dim);
ppla[i] = convert(ppl,pka[i]);
}
pkr = ap_abstract0_meet_array(pk,(ap_abstract0_t**)pka,NB);
pplr = ap_abstract0_meet_array(ppl,(ap_abstract0_t**)ppla,NB);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
print_poly("pkr",pkr); print_poly("pplr",pplr);
}
for (i=0;i<NB;i++) { ap_abstract0_free(pk,pka[i]); ap_abstract0_free(ppl,ppla[i]); }
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
void test_subst(void)
{
printf("\nsubst\n");
LOOP {
size_t i, dim = 5;
size_t p = rand() % dim;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_linexpr0_t* l = random_linexpr(dim);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pkr = ap_abstract0_substitute_linexpr(pk,false,pka,p,l,NULL);
pplr = ap_abstract0_substitute_linexpr(ppl,false,ppla,p,l,NULL);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
fprintf(stderr,"x%i -> ",(int)p); ap_linexpr0_fprint(stderr,l,NULL); fprintf(stderr,"\n");
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_linexpr0_free(l);
} ENDLOOP;
}
Cell eval(Cell exp, Cell env) {
if (is_self_evaluating(exp)) {
return exp;
} else if (is_atom(exp)) {
return lookup(exp, env);
} else if (is_tagged(exp, atom("define"))) {
return define(car(cdr(exp)), eval(car(cdr(cdr(exp))), env), env);
} else if (is_tagged(exp, atom("set!"))) {
return set(car(cdr(exp)), eval(car(cdr(cdr(exp))), env), env);
} else if (is_tagged(exp, atom("if"))) {
Cell cond = eval(car(cdr(exp)), env);
if (is_atom(cond) && is_eq(cond, atom("#f"))) {
exp = car(cdr(cdr(cdr(exp))));
} else {
exp = car(cdr(cdr(exp)));
}
return eval(exp, env);
} else if (is_tagged(exp, atom("vau"))) {
return procedure(exp, env);
} else if (is_pair(exp)) {
Cell proc = eval(car(exp), env);
if (is_primitive(proc)) {
return (proc->primitive)(eval_operands(cdr(exp), env));
} else if (is_procedure(proc)) {
Cell src = car(proc);
Cell e = car(cdr(cdr(src)));
Cell para = cons(e, cons(car(cdr(src)), null));
Cell args = cons(env, cons(cdr(exp), null));
Cell body = car(cdr(cdr(cdr(src))));
return eval(body, extend_env(para, args, cdr(proc)));
}
}
fprintf(stderr, "eval illegal state\n");
return atom("#<void>");
}
void test_expand(void)
{
printf("\nexpand dimensions\n");
LOOP {
size_t i, dim = 5;
ap_dim_t dd = rand() % dim;
size_t n = (rand() % 2) + 1;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
pkr = ap_abstract0_expand(pk,false,pka,dd,n);
pplr = ap_abstract0_expand(ppl,false,ppla,dd,n);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
fprintf(stderr,"dim %i expanded %i times\n",(int)dd,(int)n);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
void test_add_ray(void)
{
printf("\nadd rays\n");
LOOP {
size_t i, dim = 4, nb = 4;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_generator0_array_t ar = ap_generator0_array_make(nb);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
for (i=0;i<nb;i++)
ar.p[i] = random_generator(dim,(rand()%100>=80)?AP_GEN_LINE:AP_GEN_RAY);
pkr = ap_abstract0_add_ray_array(pk,false,pka,&ar);
pplr = ap_abstract0_add_ray_array(ppl,false,ppla,&ar);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_generator0_array_fprint(stderr,&ar,NULL);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_generator0_array_clear(&ar);
} ENDLOOP;
}
void test_widen(void)
{
int dim = 5;
printf("\nwidening\n");
LOOP {
ap_abstract0_t* pk0, *pk1, *pkr;
ap_abstract0_t* ppl0, *ppl1, *pplr;
pk0 = random_poly(pk,dim);
pk1 = random_poly(pk,dim);
pk1 = ap_abstract0_join(pk,true,pk1,pk0);
pkr = ap_abstract0_widening(pk,pk0,pk1);
ppl0 = convert(ppl,pk0);
ppl1 = convert(ppl,pk1);
pplr = ap_abstract0_widening(ppl,ppl0,ppl1);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
print_poly("pk0",pk0); print_poly("pk1",pk1);
print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pk0); ap_abstract0_free(pk,pk1); ap_abstract0_free(pk,pkr);
ap_abstract0_free(ppl,ppl0); ap_abstract0_free(ppl,ppl1); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
static void
test_case(const char * tapname, const char * request, unsigned count)
{
SXE * client;
tap_ev event;
tap_test_case_name(tapname);
SXEA1((client = test_new_tcp(NULL, "0.0.0.0", 0, client_connect, client_read, client_close)) != NULL,
"Failed to allocate client SXE");
SXEA1(sxe_connect(client, "127.0.0.1", SXE_LOCAL_PORT(listener)) == SXE_RETURN_OK, "Failed to connect to HTTPD");
#ifdef _WIN32
usleep(10000); /* Copied from test-errors.c and which is a TODO item */
#endif
is_eq(test_tap_ev_queue_identifier_wait(q_client, TEST_WAIT, &event), "client_connect", "Got a client connected event");
is(tap_ev_arg(event, "this"), client, "It's the client");
is_eq(test_tap_ev_queue_identifier_wait(q_httpd, TEST_WAIT, &event), "h_connect", "Got a server connected event");
test_sxe_send(client, request, strlen(request), client_sent, "client_sent", q_client, TEST_WAIT, &event);
if (count == 2) {
is_eq(test_tap_ev_queue_identifier_wait(q_httpd , TEST_WAIT, &event), "h_header", "HTTPD: header event (a)" );
is_strncmp(tap_ev_arg(event, "key" ), "Good" , SXE_LITERAL_LENGTH( "Good" ), "HTTPD: header was 'Good'" );
is_strncmp(tap_ev_arg(event, "value"), "Header" , SXE_LITERAL_LENGTH( "Header" ), "HTTPD: header value was 'Header'");
is_eq(test_tap_ev_queue_identifier_wait(q_httpd , TEST_WAIT, &event), "h_header", "HTTPD: header event (b)" );
is_strncmp(tap_ev_arg(event, "key" ), "Another", SXE_LITERAL_LENGTH( "Another"), "HTTPD: header was 'Another'" );
is_strncmp(tap_ev_arg(event, "value"), "Foo" , SXE_LITERAL_LENGTH( "Foo" ), "HTTPD: header value was 'Foo'" );
}
is_eq(test_tap_ev_queue_identifier_wait(q_httpd, TEST_WAIT, &event), "h_respond", "HTTPD: respond event");
sxe_close(client);
is_eq(test_tap_ev_queue_identifier_wait(q_httpd, TEST_WAIT, &event), "h_close", "HTTPD: close event");
}
int main(int argc, char *argv[])
{
int p[2];
int stdoutfd;
struct obj exp;
(void)argc;
(void)argv;
printf("1..1\n");
fflush(stdout);
stderrfd = dup(STDERR_FILENO);
if (stderrfd < 0)
err(1, "dup of stderr failed");
stdoutfd = dup(STDOUT_FILENO);
if (stdoutfd < 0)
err(1, "dup of stdout failed");
if (pipe(p) != 0)
failmsg("pipe failed");
if (dup2(p[1], STDERR_FILENO) < 0 || dup2(p[1], STDOUT_FILENO) < 0)
failmsg("Duplicating file descriptor");
plan_tests(10);
expect(p[0], "1..10\n");
ok(1, "msg1");
expect(p[0], "ok 1 - msg1\n");
ok(0, "msg2");
expect(p[0], "not ok 2 - msg2\n"
"# Failed test (*test.1.tap.c:main() at line 199)\n");
ok1(true);
expect(p[0], "ok 3 - true\n");
ok1(false);
expect(p[0], "not ok 4 - false\n"
"# Failed test (*test.1.tap.c:main() at line 206)\n");
pass("passed");
expect(p[0], "ok 5 - passed\n");
fail("failed");
expect(p[0], "not ok 6 - failed\n"
"# Failed test (*test.1.tap.c:main() at line 213)\n");
skip(2, "skipping %s", "test");
expect(p[0], "ok 7 # skip skipping test\n"
"ok 8 # skip skipping test\n");
todo_start("todo");
ok1(false);
expect(p[0], "not ok 9 - false # TODO todo\n"
"# Failed (TODO) test (*test.1.tap.c:main() at line 222)\n");
ok1(true);
expect(p[0], "ok 10 - true # TODO todo\n");
todo_end();
if (exit_status() != 3)
failmsg("Expected exit status 3, not %i", exit_status());
is(one_int(), 1, "one_int() returns 1");
expect(p[0], "ok 11 - one_int() returns 1\n");
is(one_int(), 2, "one_int() returns 2");
expect(p[0], "not ok 12 - one_int() returns 2\n"
"# Failed test (*test.1.tap.c:main() at line 234)\n"
"# got: 1\n"
"# expected: 2\n");
is_eq(one_str(), "one", "one_str() returns 'one'");
expect(p[0], "ok 13 - one_str() returns 'one'\n");
is_eq(one_str(), "two", "one_str() returns 'two'");
expect(p[0], "not ok 14 - one_str() returns 'two'\n"
"# Failed test (*test.1.tap.c:main() at line 242)\n"
"# got: \"one\"\n"
"# expected: \"two\"\n");
exp.id = 1;
is_cmp(one_obj(), &exp, obj_cmp, obj_to_str, "one_obj() has id 1");
expect(p[0], "ok 15 - one_obj() has id 1\n");
exp.id = 2;
is_cmp(one_obj(), &exp, obj_cmp, obj_to_str, "one_obj() has id 2");
expect(p[0], "not ok 16 - one_obj() has id 2\n"
"# Failed test (*test.1.tap.c:main() at line 252)\n"
"# got: {id=1}\n"
"# expected: {id=2}\n");
is_strstr(one_str(), "n", "one_str() contains 'n'");
expect(p[0], "ok 17 - one_str() contains 'n'\n");
is_strstr(one_str(), "w", "one_str() contains 'w'");
expect(p[0], "not ok 18 - one_str() contains 'w'\n"
"# Failed test (*test.1.tap.c:main() at line 260)\n"
"# got: \"one\"\n"
"# expected to contain: \"w\"\n");
#if 0
/* Manually run the atexit command. */
_cleanup();
expect(p[0], "# Looks like you failed 2 tests of 9.\n");
#endif
write_all(stdoutfd, "ok 1 - All passed\n",
strlen("ok 1 - All passed\n"));
_exit(0);
}
