static void compareLayouts(UILayout* v0, UILayout* v1)
{
assert_int_equal(v0->layoutItemCount, v1->layoutItemCount);
assert_int_equal(v0->basePathCount, v1->basePathCount);
for (int i = 0; i < v0->basePathCount; ++i)
{
assert_non_null(v0->pluginBasePaths[i]);
assert_string_equal(v0->pluginBasePaths[i], v1->pluginBasePaths[i]);
}
for (int i = 0; i < v0->layoutItemCount; ++i)
{
const LayoutItem* a = &v0->layoutItems[i];
const LayoutItem* b = &v1->layoutItems[i];
assert_non_null(a->pluginFile);
assert_non_null(a->pluginName);
assert_non_null(b->pluginFile);
assert_non_null(b->pluginName);
assert_string_equal(a->pluginFile, b->pluginFile);
assert_string_equal(a->pluginName, b->pluginName);
assert_true(cmp_float(a->rect.x, b->rect.x));
assert_true(cmp_float(a->rect.y, b->rect.y));
assert_true(cmp_float(a->rect.width, b->rect.width));
assert_true(cmp_float(a->rect.height, b->rect.height));
}
}
static lisp_atom lp_cmp(slist_elem* next,
CMP_OP op)
{
lisp_atom* lval=ATOM_CAST(next);
lisp_atom* rval=ATOM_CAST(next->_next);
lisp_atom ret;
ret.type=LTNIL;
/***************************************
* evaluate all expressions *
***************************************/
next=next->_next;
while(1)
{
if(lval->type!=rval->type)
return ret;
switch(lval->type)
{
case LTSTR:
case LTID:
if(!cmp_str((char*)lval->data,(char*)rval->data,op))
return ret;
break;
case LTFLOAT:
if(!cmp_float(*(float*)lval->data,*(float*)rval->data,op))
return ret;
break;
case LTINT:
if(!cmp_int(*(int*)lval->data,*(int*)rval->data,op))
return ret;
break;
case LTLISPFN:
case LTLISPMACRO:
case LTLIST:
default:
return ret;
break;
}
lval=rval;
if(next->_next)
{
rval=ATOM_CAST(next->_next);
next=next->_next;
}else break;
}
ret.type=LTTRUE;
return ret;
}
oval_result_t oval_float_cmp(const double state_val, const double sys_val, oval_operation_t operation)
{
if (operation == OVAL_OPERATION_EQUALS) {
return ((cmp_float(sys_val, state_val) == 0) ? OVAL_RESULT_TRUE : OVAL_RESULT_FALSE);
} else if (operation == OVAL_OPERATION_NOT_EQUAL) {
return ((cmp_float(sys_val, state_val) != 0) ? OVAL_RESULT_TRUE : OVAL_RESULT_FALSE);
} else if (operation == OVAL_OPERATION_GREATER_THAN) {
return ((cmp_float(sys_val, state_val) == 1) ? OVAL_RESULT_TRUE : OVAL_RESULT_FALSE);
} else if (operation == OVAL_OPERATION_GREATER_THAN_OR_EQUAL) {
return ((cmp_float(sys_val, state_val) >= 0) ? OVAL_RESULT_TRUE : OVAL_RESULT_FALSE);
} else if (operation == OVAL_OPERATION_LESS_THAN) {
return ((cmp_float(sys_val, state_val) == -1) ? OVAL_RESULT_TRUE : OVAL_RESULT_FALSE);
} else if (operation == OVAL_OPERATION_LESS_THAN_OR_EQUAL) {
return ((cmp_float(sys_val, state_val) <= 0) ? OVAL_RESULT_TRUE : OVAL_RESULT_FALSE);
} else {
oscap_seterr(OSCAP_EFAMILY_OVAL, "Invalid type of operation in float evaluation: %s.", oval_operation_get_text(operation));
return OVAL_RESULT_ERROR;
}
}
static void cmp_eblocks(t_enxframe *fr1, t_enxframe *fr2, real ftol, real abstol)
{
int i, j, k;
char buf[64], bs[22];
cmp_int(stdout, "nblock", -1, fr1->nblock, fr2->nblock);
if ((fr1->nblock == fr2->nblock) && (fr1->nblock > 0))
{
for (j = 0; (j < fr1->nblock); j++)
{
t_enxblock *b1, *b2; /* convenience vars */
b1 = &(fr1->block[j]);
b2 = &(fr2->block[j]);
sprintf(buf, "step %s: block[%d]", gmx_step_str(fr1->step, bs), j);
cmp_int(stdout, buf, -1, b1->nsub, b2->nsub);
cmp_int(stdout, buf, -1, b1->id, b2->id);
if ( (b1->nsub == b2->nsub) && (b1->id == b2->id) )
{
for (i = 0; i < b1->nsub; i++)
{
t_enxsubblock *s1, *s2;
s1 = &(b1->sub[i]);
s2 = &(b2->sub[i]);
cmp_int(stdout, buf, -1, (int)s1->type, (int)s2->type);
cmp_int64(stdout, buf, s1->nr, s2->nr);
if ((s1->type == s2->type) && (s1->nr == s2->nr))
{
switch (s1->type)
{
case xdr_datatype_float:
for (k = 0; k < s1->nr; k++)
{
cmp_float(stdout, buf, i,
s1->fval[k], s2->fval[k],
ftol, abstol);
}
break;
case xdr_datatype_double:
for (k = 0; k < s1->nr; k++)
{
cmp_double(stdout, buf, i,
s1->dval[k], s2->dval[k],
ftol, abstol);
}
break;
case xdr_datatype_int:
for (k = 0; k < s1->nr; k++)
{
cmp_int(stdout, buf, i,
s1->ival[k], s2->ival[k]);
}
break;
case xdr_datatype_int64:
for (k = 0; k < s1->nr; k++)
{
cmp_int64(stdout, buf,
s1->lval[k], s2->lval[k]);
}
break;
case xdr_datatype_char:
for (k = 0; k < s1->nr; k++)
{
cmp_uc(stdout, buf, i,
s1->cval[k], s2->cval[k]);
}
break;
case xdr_datatype_string:
for (k = 0; k < s1->nr; k++)
{
cmp_str(stdout, buf, i,
s1->sval[k], s2->sval[k]);
}
break;
default:
gmx_incons("Unknown data type!!");
}
}
}
}
}
}
}
