int test_access_basic(void) {
/* After implementing credentials test should be extended. */
assert_ok(access("/bin/mandelbrot", R_OK));
assert_ok(access("/bin/mandelbrot", 0));
assert_ok(access("/bin/mandelbrot", R_OK | W_OK | X_OK));
assert_fail(access("/tests/ascii", X_OK), EACCES);
assert_fail(access("/bin/mandelbrot", (R_OK | W_OK | X_OK) + 1), EINVAL);
assert_fail(access("/dont/exist", X_OK), ENOENT);
assert_fail(access("dont/exist", X_OK), ENOENT);
return 0;
}
// This method calls the lambdas that were collected
// when the flags were registered. The lambda will decide
// if the extension is kept in the list or drops out.
// In a second pass the prerequisites are checked
// and an error message may be printed.
void ConversionJob::frontendExtensionInit() {
// reset extensions list in case extensions changed, we do not want duplicates
extensionList.clear();
// register all extensions that should be registered
for(auto it = extensions.begin(); it != extensions.end(); ++it) {
if(it->second(*this)) {
extensionList.push_back(it->first);
// collect the kidnapped headers and add them to the list
for(auto kidnappedHeader : it->first->getKidnappedHeaderList()) {
addSystemHeadersDirectory(kidnappedHeader);
}
// add additional include directories
for(auto includeDir : it->first->getIncludeDirList()) {
addIncludeDirectory(includeDir);
}
}
}
// check pre-requisites
for(auto ext : getExtensions()) {
auto isMissing = ext->isPrerequisiteMissing(*this);
if(isMissing) {
std::cerr << "Prerequisite for an extension is missing:\n" << *isMissing << std::endl;
assert_fail() << "Aborting due to frontend extension prerequisite error.";
}
}
}
int main()
{
struct cont cont;
struct dummy array[10];
int i, *pa;
if (i >= 0 && i < 9) {
cont.array = &array[i];
pa = &cont.array[0].b;
if (cont.array[0].b > 0) {
i = array[i].b - 10;
while (i < *pa) {
++i;
}
if (!check(&cont, i)) {
printf("ERROR!\n");
assert_fail();
goto ERROR;
}
}
}
return 0;
ERROR: __VERIFIER_error();
return 1;
}
TypePtr getRepeatedType(const TypePtr& cur) {
assert_true(isVariableSized(cur)) << "Only variable sized types contain repeated types.";
NodeType type = cur->getNodeType();
switch(type) {
case NT_ArrayType: return cur.as<ArrayTypePtr>()->getElementType();
case NT_StructType: {
StructTypePtr structType = cur.as<StructTypePtr>();
return getRepeatedType(structType.back()->getType());
}
case NT_TupleType: {
TupleTypePtr tupleType = cur.as<TupleTypePtr>();
return getRepeatedType(tupleType.back());
}
case NT_UnionType: {
UnionTypePtr unionType = cur.as<UnionTypePtr>();
for(auto cur : unionType) {
if (isVariableSized(cur->getType())) return getRepeatedType(cur->getType());
}
break;
}
default: break;
}
assert_fail() << "Invalid classification as a variable sized type!";
return TypePtr();
}
bool happensBefore(Context &context, const core::StatementAddress& a, const core::StatementAddress& b, bool debug)
{
assert_eq(a.getRootNode(), b.getRootNode());
// Instantiate analysis
auto &analysis = context.getAnalysis<souffle::Sf_happens_before_analysis>(a.getRootNode(), debug);
// Get ID of both statements
int targetStartID = context.getNodeID(a);
int targetEndID = context.getNodeID(b);
// Get result
auto &resultRel = analysis.rel_Result;
// Filter for first value in result set
auto tmp = resultRel.template equalRange<0>({{targetStartID,0}});
// Filter for second value in result set
for (auto it = tmp.begin(); it != tmp.end(); ++it) {
// Found target end
if ((*it)[1] == targetEndID) {
// Check result size
if (++it == tmp.end() || (*it)[1] != targetEndID)
return true; // Only value, good!
assert_fail() << "Happens-before analysis seems to be broken!";
return false;
}
}
return false;
}
static void
teardown (void *arg)
{
if (expect_message)
assert_fail ("message didn't get logged", expect_message);
free (user);
user = NULL;
}
void equal(int *a, int *b) {
if (a != b) {
printf("ERROR\n");
assert_fail();
goto ERROR;
}
return;
ERROR:
return;
}
void check(int *a, int *b) {
if (a != b) {
printf("ERROR\n");
assert_fail();
goto ERROR;
}
return;
ERROR: __VERIFIER_error();
return;
}
void
wait_for_bg(void)
{
int counter = 0;
while(bg_has_active_jobs())
{
usleep(5000);
if(++counter > 100)
{
assert_fail("Waiting for too long.");
break;
}
}
}
int main() {
int a, b;
assign(&a, &b);
if (a != b) {
printf("ERROR\n");
assert_fail();
goto ERROR;
}
return 0;
ERROR:
return 1;
}
int main() {
int a, b;
int *pa = &a, *pb = &b;
assign(&pa, &pb);
if (a != b) {
printf("ERROR\n");
assert_fail();
goto ERROR;
}
return 0;
ERROR: __VERIFIER_error();
return 1;
}
ExpressionPtr buildPtrOperation(BasicGenerator::Operator op, const ExpressionPtr& ptrExpr) {
assert_true(isReference(ptrExpr) && isPointer(core::analysis::getReferencedType(ptrExpr->getType())))
<< "Trying to build a unary pointer operation with non-ref<ptr>.";
IRBuilder builder(ptrExpr->getNodeManager());
auto& pExt = ptrExpr->getNodeManager().getLangExtension<PointerExtension>();
switch(op) {
case BasicGenerator::Operator::PostInc: return builder.callExpr(pExt.getPtrPostInc(), ptrExpr);
case BasicGenerator::Operator::PostDec: return builder.callExpr(pExt.getPtrPostDec(), ptrExpr);
case BasicGenerator::Operator::PreInc: return builder.callExpr(pExt.getPtrPreInc(), ptrExpr);
case BasicGenerator::Operator::PreDec: return builder.callExpr(pExt.getPtrPreDec(), ptrExpr);
default: break;
}
assert_fail() << "Unsupported unary pointer operation " << op;
return ExpressionPtr();
}
int main()
{
struct dummy *pd = &global;
assign2(&pd->a, &pd->b);
if (a != b) {
printf("ERROR!\n");
assert_fail();
goto ERROR;
}
return 0;
ERROR:
return 1;
}
int main() {
int result;
struct gameState s;
int k[10] = {smithy,adventurer,gardens,embargo,cutpurse,mine,ambassador,
outpost,baron,tribute};
initializeGame(2, k, 5, &s);
result = cardEffect(14, 1, 1, 1, &s, 3, 0);
assert_fail(result == -1);
assert_pass();
return 0;
}
int main() {
int a, b;
int *p1 = &a;
int *p2 = &b;
a = f(p1, p2);
if (*p1) {
printf("ERROR\n");
assert_fail();
goto ERROR;
}
return 0;
ERROR: __VERIFIER_error();
return 1;
}
int main(int argc, char **argv) {
printf("Starting Test - Means Village didn't segfault \n");
srand(time(NULL));
int result, seed, i, n;
int r = 0;
int count;
struct gameState g, orig;
int k[10] = {smithy,adventurer,gardens,embargo,cutpurse,mine,ambassador,
outpost,baron,village};
for (i = 0; i < 1; i++) {
initializeGame(genPlayer(), k, 42, &g);
result = cardEffect(village, 1, 1, 1, &g, 3, 0);
assert_fail(result);
}
assert_pass(result);
return 0;
}
static uint64_t
wait_for_size(const char path[])
{
uint64_t size, nitems;
int counter;
dcache_get_at(path, &size, &nitems);
counter = 0;
while(size == DCACHE_UNKNOWN)
{
usleep(200);
dcache_get_at(path, &size, &nitems);
if(++counter > 100)
{
assert_fail("Waiting for too long.");
break;
}
}
return size;
}
int main()
{
union dummy d1, d2;
int n;
union dummy *pd = n ? &d1 : &d2;
if (pd == &d1) {
pd->a = 0;
} else {
pd->b = 0;
}
if (pd == &d2 && d1.a != 0) {
printf("ERROR!\n");
assert_fail();
goto ERROR;
}
return 0;
ERROR: __VERIFIER_error();
return 1;
}
int main() {
int a, b;
q = 0;
int *p1 = &a;
int *p2 = &b;
a = f(p1, p2);
if (a) {
printf("ERROR\n");
assert_fail();
goto ERROR;
}
return 0;
ERROR:
return 1;
}
int main()
{
struct dummy *pd1 = get_dummy(), *pd2 = get_dummy();
int i, *pa;
if (pd1 != 0 && pd1 == pd2 && (*pd2).a > 0) {
pa = &pd1->a;
i = pd2->a - 10;
while (i < *pa) {
++i;
}
if (!check(pd2, i)) {
printf("ERROR!\n");
assert_fail();
goto ERROR;
}
}
return 0;
ERROR: __VERIFIER_error();
return 1;
}
int main()
{
struct dummy *pd1 = get_dummy(), *pd2 = get_dummy();
int i, *pa;
if (pd1 != 0 && pd1 == pd2 && i >= 0 && i < 10) {
pd2->array[i] = i;
pa = &pd1->array[i];
i = pd2->array[i] - 10;
while (i < *pa) {
++i;
}
if (!check(pd2, i)) {
printf("ERROR!\n");
assert_fail();
goto ERROR;
}
}
return 0;
ERROR:
return 1;
}
int main() {
p1 = &a;
p2 = &b;
b = 1;
a = 5;
a--;
a = f();
if (!a || p1 != p2) {
printf("ERROR\n");
assert_fail();
goto ERROR;
}
return 0;
ERROR: __VERIFIER_error();
return 1;
}
int main()
{
struct dummy ad1[10], *ad2;
int i, *pa;
if (i >= 0 && i < 10) {
ad2 = ad1;
ad1[i].a = i;
pa = &ad1[i].a;
i = ad2[i].a - 10;
while (i < *pa) {
++i;
}
if (!check(ad1, i)) {
printf("ERROR!\n");
assert_fail();
goto ERROR;
}
}
return 0;
ERROR: __VERIFIER_error();
return 1;
}
LambdaTransformation::LambdaTransformation(const parameter::Value& value)
: Transformation(LambdaTransformationType::getInstance(), parameter::emptyValue) {
assert_fail() << "Lambda Transformations can not be instantiated using parameters!";
throw InvalidParametersException("Parameter-based instantiation not supported by lambda transformation!");
};
int RemoteExecutor::run(const std::string& binary, const std::map<string, string>& env, const string& dir) const {
// extract name of file
boost::filesystem::path path = binary;
string binaryName = path.filename().string();
// extract directory name
string dirName = boost::filesystem::path(dir).filename().string();
boost::uuids::uuid u = uuidGen();
dirName += toString(u);
// create ssh-url
std::string url = hostname;
if (!username.empty()) {
url = username + "@" + hostname;
}
std::string remoteDir = workdir + "/_remote_" + dirName;
int res = 0;
// start by creating a remote working directory
if (res==0) res = runCommand("ssh " + url + " mkdir " + remoteDir);
// copy binary
if (res==0) res = runCommand("scp -q " + binary + " " + url + ":" + remoteDir);
// execute binary
switch(system) {
case SSH:
if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && " + setupEnv(env) + " ./" + binaryName + " && rm " + binaryName + "\"");
break;
case SGE:
if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && qsub -sync yes -b yes -cwd -o std.out -e std.err -pe openmp 1 " + binaryName + "\"");
if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && rm " + binaryName + "\"");
break;
case PBS:
assert_fail() << "Not tested!";
if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && qsub -l select=1:ncpus=4:mem=2gb -W block=true -- ./" + binaryName + "\"");
if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && rm " + binaryName + "\"");
break;
case LL:
std::string jobscript = "#!/bin/bash\n"
"#@ energy_policy_tag=my_energy_tag\n"
"#@ max_perf_decrease_allowed=1\n"
"#@ wall_clock_limit = 00:05:00\n"
"#@ job_name = insieme\n"
"#@ job_type = parallel\n"
"#@ class = test\n"
"#@ node = 1\n"
"#@ total_tasks = 1\n"
"#@ node_usage = not_shared\n"
"#@ initialdir = " + remoteDir + "\n"
"#@ output = job$(jobid).out\n"
"#@ error = job$(jobid).err\n"
"#@ notification=error\n"
"#@ [email protected]\n"
"#@ restart=no\n"
"#@ queue\n"
". /etc/profile\n"
". /etc/profile.d/modules.sh\n" +
setupEnv(env);
if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && echo \"" + jobscript + "\" | llsubmit -s -\"");
//std::cout << "ssh " + url + " \"cd " + remoteDir + " && echo \"" + jobscript + "\" | llsubmit -s -\"\n";
//if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && " + setupEnv(env) + " ./" + binaryName + " && rm " + binaryName + "\"");
//if (res==0) res = runCommand("ssh " + url + " \"cd " + remoteDir + " && rm " + binaryName + "\"");
break;
}
// copy back log files
if (res==0) res = runCommand("scp -q -r " + url + ":" + remoteDir + " .");
// move files locally
if (res==0) res = runCommand("mv -t " + dir + " _remote_" + dirName + "/*");
// delete local files
if (res==0) res = runCommand("rm -rf _remote_" + dirName);
// delete remote working directory
if (res==0) res = runCommand("ssh " + url + " rm -rf " + remoteDir);
return res;
}
ExpressionPtr buildPtrOperation(BasicGenerator::Operator op, const ExpressionPtr& lhs, const ExpressionPtr& rhs) {
auto& basic = lhs->getNodeManager().getLangBasic();
auto& pExt = lhs->getNodeManager().getLangExtension<PointerExtension>();
IRBuilder builder(lhs->getNodeManager());
auto assertPtr = [&](const ExpressionPtr& exp) {
assert_pred1(isPointer, exp) << "Trying to build a ptr operation from non-ptr:"
<< "\n lhs: " << *lhs << "\n - of type: " << *lhs->getType()
<< "\n rhs: " << *rhs << "\n - of type: " << *rhs->getType()
<< "\n op: " << op;
};
auto assertInt = [&](const ExpressionPtr& exp) {
assert_pred1(basic.isInt, exp->getType()) << "Trying to build a ptr add/sub with non-int"
<< "\n lhs: " << *lhs << "\n - of type: " << *lhs->getType()
<< "\n rhs: " << *rhs << "\n - of type: " << *rhs->getType()
<< "\n op: " << op;
};
auto buildInt8Cast = [&](const ExpressionPtr& exp) {
if(!core::types::isSubTypeOf(exp->getType(), basic.getInt8())) {
return builder.numericCast(exp, basic.getInt8());
}
return exp;
};
// arithmetic operations
switch(op) {
case BasicGenerator::Operator::Add: {
if(!isPointer(lhs)) {
assertPtr(rhs);
assertInt(lhs);
return builder.callExpr(pExt.getPtrAdd(), rhs, buildInt8Cast(lhs));
}
assertPtr(lhs);
assertInt(rhs);
return builder.callExpr(pExt.getPtrAdd(), lhs, buildInt8Cast(rhs));
}
case BasicGenerator::Operator::Sub: { // minus is only supported with ptr on the lhs
assertPtr(lhs);
if(!isPointer(rhs)) {
assertInt(rhs);
return builder.callExpr(pExt.getPtrSub(), lhs, buildInt8Cast(rhs));
} else {
return builder.callExpr(pExt.getPtrDiff(), lhs, rhs);
}
}
default: break;
}
// comparison operations
assertPtr(lhs);
assertPtr(rhs);
switch(op) {
case BasicGenerator::Operator::Eq: return builder.callExpr(pExt.getPtrEqual(), lhs, rhs);
case BasicGenerator::Operator::Ne: return builder.callExpr(pExt.getPtrNotEqual(), lhs, rhs);
case BasicGenerator::Operator::Le: return builder.callExpr(pExt.getPtrLessEqual(), lhs, rhs);
case BasicGenerator::Operator::Lt: return builder.callExpr(pExt.getPtrLessThan(), lhs, rhs);
case BasicGenerator::Operator::Ge: return builder.callExpr(pExt.getPtrGreaterEqual(), lhs, rhs);
case BasicGenerator::Operator::Gt: return builder.callExpr(pExt.getPtrGreaterThan(), lhs, rhs);
default: break;
}
assert_fail() << "Unsupported binary pointer operation " << op;
return ExpressionPtr();
}
int coro_test_3( co_t *co_p )
{
static int i = 1;
++inside_test_3;
if ( *co_p ) goto **co_p;
/* begin */
switch ( i ) {
case 1:
i = 2;
do {
/* yield */
*co_p = &&L__2;
--inside_test_3;
return CO_YIELD;
L__2:;
} while ( 0 );
assert_int_eq( 2, i );
i = 3;
do {
/* yield */
*co_p = &&L__3;
--inside_test_3;
return CO_YIELD;
L__3:;
} while ( 0 );
assert_int_eq( 3, i );
i = 4;
do {
/* yield */
*co_p = &&L__4;
--inside_test_3;
return CO_YIELD;
L__4:;
} while ( 0 );
assert_int_eq( 4, i );
do {
/* wait */
*co_p = &&L__5;
L__5:
if (!( ++i < 10)) { /* cond */
--inside_test_3;
return CO_WAIT;
}
} while ( 0 );
for ( ; i < 20; i++ ) {
do {
/* yield */
*co_p = &&L__6;
--inside_test_3;
return CO_YIELD;
L__6:;
} while ( 0 );
}
assert_int_eq( 20, i );
i = -1;
do {
/* restart */
*co_p = NULL;
--inside_test_3;
return CO_YIELD;
} while ( 0 );
default:
assert_fail( "unreachable instruction" );
break;
case -1:
i = 1;
--inside_test_3;
do {
/* quit */
*co_p = &&__label;
__label:
--inside_test_3;
return CO_END;
} while ( 0 );
}
assert_fail( "unreachable instruction" );
--inside_test_3;
/* end */
*co_p = &&L__END_test_3;
L__END_test_3:
--inside_test_3;
return CO_END;
}
