static int
Test_verifierIsValidSubstitution(void)
{
struct verifier vrf;
struct substitution sub;
struct frame frm;
struct frame ctx;
verifierInit(&vrf);
struct reader r;
readerInitString(&r, "");
verifierBeginReadingFile(&vrf, &r);
size_tArrayAdd(&vrf.disjointScope, 0);
size_t v1 = verifierAddSymbol(&vrf, "v1", symType_variable);
size_t v2 = verifierAddSymbol(&vrf, "v2", symType_variable);
size_t v3 = verifierAddSymbol(&vrf, "v3", symType_variable);
frameInit(&frm);
frameInit(&ctx);
/* build the substitution */
struct symstring str1, str2, str3;
symstringInit(&str1);
symstringInit(&str2);
symstringInit(&str3);
symstringAdd(&str1, v1);
symstringAdd(&str2, v1);
symstringAdd(&str3, v3);
substitutionInit(&sub);
substitutionAdd(&sub, v1, &str1);
substitutionAdd(&sub, v2, &str2);
substitutionAdd(&sub, v3, &str3);
ut_assert(verifierIsValidSubstitution(&vrf, &ctx, &frm, &sub),
"invalid sub");
frameAddDisjoint(&frm, v2, v3);
ut_assert(!verifierIsValidSubstitution(&vrf, &ctx, &frm, &sub),
"sub should be invalid");
frameAddDisjoint(&ctx, v2, v3);
ut_assert(!verifierIsValidSubstitution(&vrf, &ctx, &frm, &sub),
"sub should be invalid");
frameAddDisjoint(&frm, v1, v3);
ut_assert(!verifierIsValidSubstitution(&vrf, &ctx, &frm, &sub),
"sub should be invalid");
frameAddDisjoint(&ctx, v1, v3);
ut_assert(verifierIsValidSubstitution(&vrf, &ctx, &frm, &sub),
"invalid sub");
substitutionClean(&sub);
frameClean(&ctx);
frameClean(&frm);
readerClean(&r);
verifierClean(&vrf);
return 0;
}
/*
void mainInit(char* className, Interpretador* interpretador, int paramsNumber, char** cmdLineParams) {
char* methodName = "main", methodDescriptor = "([Ljava/lang/String;)V";
ClassFile* cFile = loadClass(interpretador, className);
pushFrame(&(interpretador->topStackFrame));
frameInit(interpretador->initClass, *cFile, interpretador->topStackFrame, methodName, methodDescriptor);
}
*/
void methodInit(char* className, char* methodName, char* methodDescriptor, Interpretador* interpretador, int paramsNumber, int print) {
int i;
ClassFile* cFile = loadClass(interpretador, className);
printf("FEZ LOAD\n");
if (print)
printClass(cFile, className);
pushFrame(&(interpretador->topStackFrame));
printf("\n\nPUSHOUFRAME\n");
frameInit(interpretador->initClass, *cFile, interpretador->topStackFrame, methodName, methodDescriptor);
printf("\n\nINITIOUFRAME\n");
if (interpretador->topStackFrame->nextFrame != NULL) {
/*if (interpretador->topStackFrame->nextFrame != NULL) {*/
for (i = countSlots(interpretador->topStackFrame->nextFrame->frame->topOperand, paramsNumber) - 1; i >= 0; i--) {
if (interpretador->topStackFrame->nextFrame->frame->topOperand->operand.type32_64 == CAT2)
i--;
interpretador->topStackFrame->frame->localVarArray[i] = (int)&(interpretador->topStackFrame->nextFrame->frame->topOperand);
}
}
printf("\n\nSAIU DA METHOD INIT\n");
/*}*/
}
void init()
{
//static GLfloat pointParam[3] = {0.0, 1.0, 0.0};
static GLfloat pointParam[3] = {0.0, 0.0, 0.001};
glEnable(GL_FOG);
{
GLfloat fogColor[4] = {0.0, 0.2, 0.5,1.0};
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 0.008);
glHint(GL_FOG_HINT,GL_DONT_CARE);
glFogf(GL_FOG_START,1.0);
glFogf(GL_FOG_END,100.0);
glFogfv(GL_FOG_COLOR,fogColor);
}
glEnable(GL_POINT_SMOOTH);
glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION,pointParam);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0, 0.2, 0.5, 1.0);
initNeutrons(optInitNeutrons,optMaxNeutrons,optInitEnergy,optNumTrails,optNumGroups,optCrossSections,optNumBins);
frameInit(30.0);
}
static int
Test_frameInit(void)
{
struct frame frm;
frameInit(&frm);
ut_assert(frm.stmts.size == 0, "size == %lu, expected 0", frm.stmts.size);
frameClean(&frm);
return 0;
}
static int
Test_verifierParseProof(void)
{
enum {
file_size = 2
};
const char* file[file_size] = {
"$. ",
"p $. "
};
const size_t thms_len[file_size] = {
1, 2
};
const size_t thms_0[1] = {0};
const size_t thms_1[2] = {0, 1};
const size_t* thms_s[file_size] = {
thms_0,
thms_1
};
size_t i;
struct verifier vrf;
verifierInit(&vrf);
struct reader r[file_size];
struct symstring thms[file_size];
for (i = 0; i < file_size; i++) {
readerInitString(&r[i], file[i]);
symstringInit(&thms[i]);
size_tArrayAppend(&thms[i], thms_s[i], thms_len[i]);
}
struct frame ctx;
frameInit(&ctx);
#define test_file(f, error) \
do { \
verifierBeginReadingFile(&vrf, &r[f]); \
verifierParseProof(&vrf, &ctx); \
verifierCheckProof(&vrf, &thms[f]); \
check_err(vrf.err, error); \
readerClean(&r[f]); \
} while (0)
test_file(0, error_incorrectProof);
verifierAddConstant(&vrf, "type");
verifierAddVariable(&vrf, "var");
struct symstring stmt;
symstringInit(&stmt);
symstringAdd(&stmt, 0);
symstringAdd(&stmt, 1);
verifierAddFloating(&vrf, "p", &stmt);
test_file(1, error_none);
for (i = 0; i < file_size; i++) {
symstringClean(&thms[i]);
}
frameClean(&ctx);
verifierClean(&vrf);
return 0;
#undef test_file
}
static int
Test_verifierParseProofSymbol(void)
{
enum {
file_size = 4
};
const char* file[file_size] = {
"$. ",
"undefined ",
"defined_float ",
"defined_assert ",
};
size_t i;
int isEndOfProof;
struct verifier vrf;
verifierInit(&vrf);
struct reader r[file_size];
for (i = 0; i < file_size; i++) {
readerInitString(&r[i], file[i]);
}
struct frame ctx;
frameInit(&ctx);
#define test_file(f, error) \
do { \
verifierBeginReadingFile(&vrf, &r[f]); \
verifierParseProofSymbol(&vrf, &ctx, &isEndOfProof); \
check_err(vrf.err, error); \
readerClean(&r[f]); \
} while (0)
test_file(0, error_none);
test_file(1, error_undefinedSymbol);
size_t c = verifierAddConstant(&vrf, "c");
size_t v = verifierAddVariable(&vrf, "v");
struct symstring stmt1;
symstringInit(&stmt1);
symstringAdd(&stmt1, c);
symstringAdd(&stmt1, v);
verifierAddFloating(&vrf, "defined_float", &stmt1);
test_file(2, error_none);
struct symstring stmt2;
symstringInit(&stmt2);
verifierAddAssertion(&vrf, "defined_assert", &stmt2);
test_file(3, error_none);
ut_assert(vrf.stack.size == 2, "stack size == %lu, should be 2",
vrf.stack.size);
frameClean(&ctx);
verifierClean(&vrf);
return 0;
#undef test_file
}
static int
Test_verifierParseProvable(void)
{
enum {
file_size = 2
};
const char* file[file_size] = {
"type var $= $. ",
"type var $= flt $. "
};
const enum error errs[file_size] = {
error_incorrectProof,
error_none
};
size_t i;
struct verifier vrf;
verifierInit(&vrf);
struct reader r[file_size];
for (i = 0; i < file_size; i++) {
readerInitString(&r[i], file[i]);
check_err(vrf.err, error_none);
}
verifierBeginReadingFile(&vrf, &r[0]);
size_t type, var, flt;
type = verifierAddConstant(&vrf, "type");
var = verifierAddVariable(&vrf, "var");
struct symstring floating;
symstringInit(&floating);
symstringAdd(&floating, type);
symstringAdd(&floating, var);
flt = verifierAddFloating(&vrf, "flt", &floating);
check_err(vrf.err, error_none);
for (i = 0; i < file_size; i++) {
LOG_DEBUG("testing file %lu", i);
struct symstring stmt;
symstringInit(&stmt);
verifierBeginReadingFile(&vrf, &r[i]);
struct frame frm;
frameInit(&frm);
verifierParseProvable(&vrf, &stmt, &frm);
check_err(vrf.err, errs[i]);
frameClean(&frm);
symstringClean(&stmt);
readerClean(&r[i]);
}
verifierClean(&vrf);
return 0;
}
void init()
{
//static GLfloat pointParam[3] = {0.0, 1.0, 0.0};
static GLfloat pointParam[3] = {0.0, 0.0, 0.001};
glEnable(GL_FOG);
{
GLfloat fogColor[4] = {0.0, 0.2, 0.5,1.0};
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 0.008);
glHint(GL_FOG_HINT,GL_DONT_CARE);
glFogf(GL_FOG_START,1.0);
glFogf(GL_FOG_END,100.0);
glFogfv(GL_FOG_COLOR,fogColor);
}
glEnable(GL_POINT_SMOOTH);
glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION,pointParam);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0, 0.2, 0.5, 1.0);
texCyl=LoadTextureRAW("rc/plate.raw",256,512,1);
texBot=LoadTextureRAW("rc/plate2.raw",256,256,1);
texTop=LoadTextureRAW("rc/grate.raw",256,512,1);
initNeutrons(optInitNeutrons,optMaxNeutrons,optInitEnergy,optNumTrails,optNumGroups,optCrossSections,optNumBins);
frameInit(30.0);
wmInit(100,100);
wmAddWindow("Status",drawStatus,200,100,WM_WINDOW_LEFT,
WM_WINDOW_EXPANDED,WM_WINDOW_UNMOVEABLE,WM_WINDOW_UNCOLLAPSABLE);
wmAddWindow("Spectrum",drawSpectrum,400,200,WM_WINDOW_LEFT,
WM_WINDOW_COLLAPSED,WM_WINDOW_UNMOVEABLE,WM_WINDOW_COLLAPSABLE);
wmAddWindow("Cross Sections",drawCrossSections,400,200,WM_WINDOW_LEFT,
WM_WINDOW_COLLAPSED,WM_WINDOW_MOVEABLE,WM_WINDOW_COLLAPSABLE);
/*wmAddWindow("Menu",drawMenu,800,50,WM_WINDOW_BOTTOM,
WM_WINDOW_EXPANDED,WM_WINDOW_UNMOVEABLE,WM_WINDOW_UNCOLLAPSABLE);
*/
}
static int
Test_verifierApplyAssertion(void)
{
const size_t t = 1;
const size_t x = 2;
const size_t y = 3;
const size_t a = 4;
const size_t b = 5;
// const size_t tx = 6;
// const size_t ty = 7;
// const size_t txy = 8;
const size_t tyx = 9;
const size_t tx_f[2] = {t, x};
const size_t ty_f[2] = {t, y};
const size_t txy_e[3] = {t, x, y};
const size_t tyx_a[3] = {t, y, x};
// const size_t frame_a[3] = {tx, ty, txy};
const size_t stack1[2] = {t, a};
const size_t stack2[2] = {t, b};
const size_t stack3[3] = {t, a, b};
const size_t res[3] = {t, b, a};
struct verifier vrf;
verifierInit(&vrf);
struct reader r;
readerInitString(&r, "");
verifierBeginReadingFile(&vrf, &r);
struct symstring stmt;
LOG_DEBUG("add constant");
verifierAddConstant(&vrf, "t");
LOG_DEBUG("add variables");
verifierAddVariable(&vrf, "x");
verifierAddVariable(&vrf, "y");
verifierAddVariable(&vrf, "a");
verifierAddVariable(&vrf, "b");
LOG_DEBUG("add floatings");
symstringInit(&stmt);
size_tArrayAppend(&stmt, tx_f, 2);
verifierAddFloating(&vrf, "tx", &stmt);
symstringInit(&stmt);
size_tArrayAppend(&stmt, ty_f, 2);
verifierAddFloating(&vrf, "ty", &stmt);
LOG_DEBUG("add essential");
symstringInit(&stmt);
size_tArrayAppend(&stmt, txy_e, 3);
verifierAddEssential(&vrf, "txy", &stmt);
LOG_DEBUG("add assertion");
symstringInit(&stmt);
size_tArrayAppend(&stmt, tyx_a, 3);
verifierAddAssertion(&vrf, "tyx", &stmt);
LOG_DEBUG("prepare stack");
symstringInit(&stmt);
size_tArrayAppend(&stmt, stack1, 2);
symstringArrayAdd(&vrf.stack, stmt);
symstringInit(&stmt);
size_tArrayAppend(&stmt, stack2, 2);
symstringArrayAdd(&vrf.stack, stmt);
symstringInit(&stmt);
size_tArrayAppend(&stmt, stack3, 3);
symstringArrayAdd(&vrf.stack, stmt);
LOG_DEBUG("prepare context frame");
struct frame ctx;
frameInit(&ctx);
LOG_DEBUG("apply assertion");
verifierApplyAssertion(&vrf, &ctx, tyx);
ut_assert(!vrf.err, "assertion application failed");
symstringInit(&stmt);
size_tArrayAppend(&stmt, res, 3);
ut_assert(symstringIsEqual(&vrf.stack.vals[0], &stmt), "result of assertion "
"application is wrong");
LOG_DEBUG("clean up");
frameClean(&ctx);
symstringClean(&stmt);
readerClean(&r);
/* frm is cleaned here */
verifierClean(&vrf);
return 0;
}
static int
Test_verifierIsValidDisjointPairSubstitution(void)
{
struct verifier vrf;
struct frame frm;
struct substitution sub;
verifierInit(&vrf);
struct reader r;
readerInitString(&r, "");
verifierBeginReadingFile(&vrf, &r);
size_tArrayAdd(&vrf.disjointScope, 0);
LOG_DEBUG("adding symbols");
size_t v1 = verifierAddSymbol(&vrf, "v1", symType_variable);
size_t v2 = verifierAddSymbol(&vrf, "v2", symType_variable);
size_t v3 = verifierAddSymbol(&vrf, "v3", symType_variable);
LOG_DEBUG("adding disjoints");
frameInit(&frm);
frameAddDisjoint(&frm, v1, v2);
LOG_DEBUG("building the substitution manually");
struct symstring str1, str2;
symstringInit(&str1);
symstringInit(&str2);
symstringAdd(&str1, v3);
symstringAdd(&str2, v3);
substitutionInit(&sub);
substitutionAdd(&sub, v1, &str1);
substitutionAdd(&sub, v2, &str2);
struct frame ctx;
frameInit(&ctx);
frameAddDisjoint(&ctx, v1, v2);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameClean(&ctx);
/* str1 and str2 cleaned here */
substitutionClean(&sub);
frameClean(&frm);
frameInit(&frm);
frameAddDisjoint(&frm, v1, v2);
symstringInit(&str1);
symstringInit(&str2);
symstringAdd(&str1, v1);
symstringAdd(&str1, v2);
symstringAdd(&str2, v3);
substitutionInit(&sub);
substitutionAdd(&sub, v1, &str1);
substitutionAdd(&sub, v2, &str2);
frameInit(&ctx);
frameAddDisjoint(&ctx, v1, v2);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameAddDisjoint(&frm, v1, v3);
frameAddDisjoint(&ctx, v1, v3);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameAddDisjoint(&frm, v2, v3);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameAddDisjoint(&ctx, v2, v3);
ut_assert(verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be valid");
substitutionClean(&sub);
frameClean(&ctx);
frameClean(&frm);
readerClean(&r);
verifierClean(&vrf);
return 0;
}
static int
Test_verifierMakeFrame(void)
{
size_t i;
enum {
cst_size = 5,
var_size = 4,
flt_size = 4,
ess_size = 1
};
const char* cstSyms[cst_size] = {"|-", "wff", "0", "1", "+"};
size_t cstIds[cst_size];
const char* varSyms[var_size] = {"x", "y", "z", "w"};
size_t varIds[var_size];
const char* fltSyms[flt_size] = {"wff_x", "wff_y", "wff_z", "wff_w"};
size_t fltIds[flt_size];
size_t fltSS[flt_size][2];
const char* essSyms[ess_size] = {"plus"};
// size_t essIds[ess_size];
struct verifier vrf;
verifierInit(&vrf);
/* make a mock file because verifierAdd... requires vrf->rId to be valid */
LOG_DEBUG("making mock file because verifierAdd...() requires valid "
"vrf->rId");
struct reader file;
readerInitString(&file, "");
verifierBeginReadingFile(&vrf, &file);
size_tArrayAdd(&vrf.disjointScope, 0);
LOG_DEBUG("adding constants");
for (i = 0; i < cst_size; i++) {
cstIds[i] = verifierAddConstant(&vrf, cstSyms[i]);
}
LOG_DEBUG("adding variables");
for (i = 0; i < var_size; i++) {
varIds[i] = verifierAddVariable(&vrf, varSyms[i]);
}
ut_assert(vrf.symCount[symType_variable] == var_size,
"added %lu variables, expected %d", vrf.symCount[symType_variable],
var_size);
LOG_DEBUG("preparing floats");
struct symstring wff[flt_size];
for (i = 0; i < flt_size; i++) {
fltSS[i][0] = cstIds[1];
fltSS[i][1] = varIds[i];
symstringInit(&wff[i]);
size_tArrayAppend(&wff[i], fltSS[i], 2);
}
LOG_DEBUG("preparing essentials");
struct symstring plus;
size_t ssplus[4] = {cstIds[0], varIds[0], cstIds[4], varIds[1]};
symstringInit(&plus);
size_tArrayAppend(&plus, ssplus, 4);
LOG_DEBUG("adding floats and essentials");
fltIds[0] = verifierAddFloating(&vrf, fltSyms[0], &wff[0]);
check_err(vrf.err, error_none);
fltIds[1] = verifierAddFloating(&vrf, fltSyms[1], &wff[1]);
check_err(vrf.err, error_none);
verifierAddEssential(&vrf, essSyms[0], &plus);
check_err(vrf.err, error_none);
fltIds[2] = verifierAddFloating(&vrf, fltSyms[2], &wff[2]);
check_err(vrf.err, error_none);
fltIds[3] = verifierAddFloating(&vrf, fltSyms[3], &wff[3]);
check_err(vrf.err, error_none);
ut_assert(vrf.symCount[symType_floating] == 4, "added %lu floating, "
"expected 4", vrf.symCount[symType_floating]);
ut_assert(vrf.symCount[symType_essential] == 1, "added %lu essential, "
"expected 1", vrf.symCount[symType_essential]);
ut_assert(vrf.hypotheses.size == 5, "added %lu "
"hypotheses, expected 5", vrf.hypotheses.size);
LOG_DEBUG("preparing disjoint");
struct symstring disjoint;
symstringInit(&disjoint);
symstringAdd(&disjoint, varIds[0]);
symstringAdd(&disjoint, varIds[1]);
LOG_DEBUG("adding disjoint");
verifierAddDisjoint(&vrf, &disjoint);
ut_assert(vrf.disjoint1.size == 1, "added %lu disjoints, "
"expected 1", vrf.disjoint1.size);
LOG_DEBUG("preparing assertion");
struct symstring asr;
symstringInit(&asr);
size_t ssasr[6] =
{cstIds[0], varIds[0], cstIds[4], varIds[1], cstIds[4], varIds[2]};
size_tArrayAppend(&asr, ssasr, 6);
LOG_DEBUG("making the frame");
struct frame frm;
frameInit(&frm);
LOG_DEBUG("calling verifierMakeFrame()");
verifierMakeFrame(&vrf, &frm, &asr);
check_err(vrf.err, error_none);
ut_assert(frm.disjoint1.size == 1, "%lu disjoints in frame, expected 1",
frm.disjoint1.size);
LOG_DEBUG("make sure frame is the right size");
ut_assert(frm.stmts.size == 4, "frame has size %lu, expected 4",
frm.stmts.size);
LOG_DEBUG("make sure wff_w has not been added to the frame");
for (i = 0; i < frm.stmts.size; i++) {
ut_assert(frm.stmts.vals[i] != fltIds[3],
"wff_w should not be in the frame");
}
LOG_DEBUG("cleaning up");
frameClean(&frm);
symstringClean(&asr);
readerClean(&file);
verifierClean(&vrf);
return 0;
}
