test_results_t test1_8_Mutator::executeTest() { // Find the entry point to the procedure "test1_8_func1" const char *funcName = "test1_8_func1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point8_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point8_1 || ((*point8_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return FAILED; } BPatch_Vector<BPatch_snippet*> vect8_1; const char *globalVar = "test1_8_globalVariable1"; BPatch_variableExpr *expr8_1 = findVariable(appImage, globalVar, point8_1); if (!expr8_1) { logerror("**Failed** test #3 (passing variables)\n"); logerror(" Unable to locate variable %s\n", globalVar); return FAILED; } BPatch_arithExpr arith8_1 (BPatch_assign, *expr8_1, BPatch_arithExpr(BPatch_plus, BPatch_arithExpr(BPatch_plus, BPatch_arithExpr(BPatch_plus, BPatch_constExpr(81), BPatch_constExpr(82)), BPatch_arithExpr(BPatch_plus, BPatch_constExpr(83), BPatch_constExpr(84))), BPatch_arithExpr(BPatch_plus, BPatch_arithExpr(BPatch_plus, BPatch_constExpr(85), BPatch_constExpr(86)), BPatch_arithExpr(BPatch_plus, BPatch_constExpr(87), BPatch_constExpr(88))))); vect8_1.push_back(&arith8_1); checkCost(BPatch_sequence(vect8_1)); if(!appAddrSpace->insertSnippet( BPatch_sequence(vect8_1), *point8_1)) return FAILED; return PASSED; }
task main() { long red,green,blue; float jarakSementara = 0; // sensor sees light: resetTimer(timer1); int costWarna; while(true) { printLayar(red,green,blue); getColorRGB(colorSensor,red,green,blue); if(red < 20 && green < 20 && blue < 20) { // counter-steer left: motor[leftMotor] = 25; motor[rightMotor] = 15; } // sensor sees dark: else if (red > 70 && green > 70 && blue > 70) { //counter right motor[leftMotor] = 5; motor[rightMotor] = 25; } //sensor sees light else { //go straight motor[leftMotor] = 20; motor[rightMotor] = 20; sleep(200); costWarna = checkCost(red,green,blue); if (costWarna == 100) //intersection green { motor[leftMotor] = 0; motor[rightMotor] = 0; sleep(1000); displayTextLine(7,"detected intersection"); } else if (costWarna == 101) //intersection green { turnLeft(); turnLeft(); sleep(1000); displayTextLine(7,"detected stop turn around"); } displayTextLine(6,"costWarna = %d",costWarna); } jarakSementara = getTimer(timer1, seconds); printJarak(jarakSementara); } }
skillReturnType Skill::canCast(Creature &caster) { if (checkCost(caster) == false) { return SKILL_FAIL_COST; } else if (isUnlocked() == false) { return SKILL_NOT_UNLOCKED; } else { return SKILL_SUCCESS; } }
// // Start Test Case #1 - (zero arg function call) // test_results_t test1_1_Mutator::executeTest() { const char *funcName = "test1_1_func1_1"; const char* testName = "zero arg function call"; int testNo = 1; // Find the entry point to the procedure "func1_1" BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point1_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point1_1 || ((*point1_1).size() == 0)) { logerror("**Failed** test #%d (%s)\n", testNo,testName); logerror(" Unable to find entry point to \"%s.\"\n", funcName); return FAILED; } BPatch_Vector<BPatch_function *> bpfv; const char *fn = "test1_1_call1_1"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror("**Failed** test #%d (%s)\n", testNo, testName); logerror(" Unable to find function %s\n", fn); return FAILED; } BPatch_function *call1_func = bpfv[0]; BPatch_Vector<BPatch_snippet *> call1_args; BPatch_funcCallExpr call1Expr(*call1_func, call1_args); checkCost(call1Expr); if(!appAddrSpace->insertSnippet(call1Expr, *point1_1)) return FAILED; dprintf("Inserted snippet\n"); return PASSED; } // test1_1_Mutator::executeTest()
test_results_t test1_5_Mutator::executeTest() { // Find the entry point to the procedure "func5_2" const char *funcName = "test1_5_func2"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point5_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point5_1 || ((*point5_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return FAILED; } const char *funcName2 = "test1_5_func1"; BPatch_Vector<BPatch_function *> found_funcs2; if ((NULL == appImage->findFunction(funcName2, found_funcs2)) || !found_funcs2.size()) { logerror(" Unable to find function %s\n", funcName2); return FAILED; } if (1 < found_funcs2.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs2.size(), funcName2); } BPatch_Vector<BPatch_point *> *point5_2 = found_funcs2[0]->findPoint(BPatch_subroutine); if (!point5_2 || ((*point5_2).size() == 0)) { logerror("Unable to find subroutine call points in \"%s\".\n", funcName2); return FAILED; } const char *globalVar1 = "test1_5_globalVariable5_1"; const char *globalVar2 = "test1_5_globalVariable5_2"; BPatch_variableExpr *expr5_1 = findVariable (appImage, globalVar1, point5_1); BPatch_variableExpr *expr5_2 = findVariable (appImage, globalVar2, point5_1); if (!expr5_1 || !expr5_2) { logerror("**Failed** test #5 (1f w.o. else)\n"); logerror(" Unable to locate variable %s or ", globalVar1); logerror(" variable %s\n", globalVar2); return FAILED; } BPatch_Vector<BPatch_snippet*> vect5_1; // if (0 == 1) globalVariable5_1 = 52; BPatch_ifExpr expr5_3(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(0), BPatch_constExpr(1)), BPatch_arithExpr(BPatch_assign, *expr5_1, BPatch_constExpr(52))); // if (1 == 1) globalVariable5_2 = 53; BPatch_ifExpr expr5_4(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(1), BPatch_constExpr(1)), BPatch_arithExpr(BPatch_assign, *expr5_2, BPatch_constExpr(53))); vect5_1.push_back(&expr5_3); vect5_1.push_back(&expr5_4); BPatch_sequence expr5_5(vect5_1); checkCost(expr5_5); appAddrSpace->insertSnippet(expr5_5, *point5_1); return PASSED; }
// // Start Test Case #3 - (overload operator) // // static int mutatorTest(BPatch_thread *appThread, BPatch_image *appImage) test_results_t test5_3_Mutator::executeTest() { BPatch_Vector<BPatch_function *> bpfv; const char *fn = "overload_op_test::func_cpp"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror("**Failed** test #3 (overloaded operation)\n"); logerror(" Unable to find function %s\n", fn); return FAILED; } BPatch_function *f1 = bpfv[0]; BPatch_Vector<BPatch_point *> *point3_1 = f1->findPoint(BPatch_subroutine); assert(point3_1); if (point3_1->size() == 0) { logerror("**Failed test5_3 (overload operation)\n"); logerror(" Can't find overloaded operator call points\n"); return FAILED; } unsigned int index = 0; char fn3[256]; BPatch_function *func; while (index < point3_1->size()) { if ((func = (*point3_1)[index]->getCalledFunction()) != NULL && !strcmp("overload_op_test::operator++", func->getName(fn3, 256))) { break; } index ++; } if(!func) { logerror("**Failed** test #3 (overload operation)\n"); logerror(" Can't find the overload operator\n"); return FAILED; } if (0 != strcmp("overload_op_test::operator++", func->getName(fn3, 256))) { logerror("**Failed** test #3 (overload operation)\n"); logerror(" Can't find the overloaded operator\n"); return FAILED; } // FIXME It caught fprintf... BPatch_Vector<BPatch_point *> *point3_2 = func->findPoint(BPatch_exit); assert(point3_2); bpfv.clear(); const char *fn2 = "overload_op_test::call_cpp"; if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror("**Failed** test #3 (overloaded operation)\n"); logerror(" Unable to find function %s\n", fn2); return FAILED; } BPatch_function *call3_1 = bpfv[0]; BPatch_variableExpr *this2 = appImage->findVariable("test5_3_test3"); if (this2 == NULL) { logerror( "**Failed** test #3 (overloaded operation)\n"); logerror( "Unable to find variable \"test5_3_test3\"\n"); return FAILED; } BPatch_Vector<BPatch_snippet *> opArgs; BPatch_arithExpr expr2_0(BPatch_addr, *this2); opArgs.push_back(&expr2_0); opArgs.push_back(new BPatch_retExpr()); BPatch_funcCallExpr call3_1Expr(*call3_1, opArgs); checkCost(call3_1Expr); appAddrSpace->insertSnippet(call3_1Expr, *point3_2); // int tag = 1; // while (tag != 0) {} return PASSED; }
test_results_t test1_36_Mutator::executeTest() { const char *funcName = "test1_36_func1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *all_points36_1 = found_funcs[0]->findPoint(BPatch_subroutine); if (!all_points36_1 || (all_points36_1->size() < 1)) { logerror("Unable to find point %s - subroutines.\n", funcName); return FAILED; } const char *funcName2 = "test1_36_call1"; BPatch_point *point36_1 = NULL; for (unsigned i=0; i<(*all_points36_1).size(); i++) { BPatch_point *cur_point = (*all_points36_1)[i]; if (cur_point == NULL) continue; BPatch_function *func = cur_point->getCalledFunction(); char funcname[100]; if (!func) continue; if (func->getName(funcname, 99)) { if (strstr(funcname, funcName2)) point36_1 = cur_point; } } if (point36_1 == NULL) { logerror("Unable to find callsite %s\n", funcName2); return FAILED; } BPatch_variableExpr *expr36_1 = findVariable(appImage, "test1_36_globalVariable1", all_points36_1); BPatch_variableExpr *expr36_2 = findVariable(appImage, "test1_36_globalVariable2", all_points36_1); BPatch_variableExpr *expr36_3 = findVariable(appImage, "test1_36_globalVariable3", all_points36_1); BPatch_variableExpr *expr36_4 = findVariable(appImage, "test1_36_globalVariable4", all_points36_1); BPatch_variableExpr *expr36_5 = findVariable(appImage, "test1_36_globalVariable5", all_points36_1); BPatch_variableExpr *expr36_6 = findVariable(appImage, "test1_36_globalVariable6", all_points36_1); BPatch_variableExpr *expr36_7 = findVariable(appImage, "test1_36_globalVariable7", all_points36_1); BPatch_variableExpr *expr36_8 = findVariable(appImage, "test1_36_globalVariable8", all_points36_1); BPatch_variableExpr *expr36_9 = findVariable(appImage, "test1_36_globalVariable9", all_points36_1); BPatch_variableExpr *expr36_10 = findVariable(appImage, "test1_36_globalVariable10", all_points36_1); if (expr36_1 == NULL || expr36_2 == NULL || expr36_3 == NULL || expr36_4 == NULL || expr36_5 == NULL || expr36_6 == NULL || expr36_7 == NULL || expr36_8 == NULL || expr36_9 == NULL || expr36_10 == NULL) { logerror("**Failed** test #36 (callsite parameter referencing)\n"); logerror(" Unable to locate at least one of " "test1_36_globalVariable{1...10}\n"); return FAILED; } BPatch_Vector<BPatch_snippet *> snippet_seq; snippet_seq.push_back(makeTest36paramExpr(expr36_1, 0)); snippet_seq.push_back(makeTest36paramExpr(expr36_2, 1)); snippet_seq.push_back(makeTest36paramExpr(expr36_3, 2)); snippet_seq.push_back(makeTest36paramExpr(expr36_4, 3)); snippet_seq.push_back(makeTest36paramExpr(expr36_5, 4)); snippet_seq.push_back(makeTest36paramExpr(expr36_6, 5)); snippet_seq.push_back(makeTest36paramExpr(expr36_7, 6)); snippet_seq.push_back(makeTest36paramExpr(expr36_8, 7)); snippet_seq.push_back(makeTest36paramExpr(expr36_9, 8)); snippet_seq.push_back(makeTest36paramExpr(expr36_10, 9)); BPatch_sequence seqExpr(snippet_seq); checkCost(seqExpr); appAddrSpace->insertSnippet(seqExpr, *point36_1); return PASSED; }
test_results_t test1_19_Mutator::executeTest() { // Avoid a race condition in fast & loose mode while (!appProc->isStopped()) { BPatch::bpatch->waitForStatusChange(); } appProc->continueExecution(); if (waitUntilStopped(BPatch::bpatch, appProc, 19, "oneTimeCode") < 0) { return FAILED; } BPatch_Vector<BPatch_function *> bpfv; const char *fn = "test1_19_call1"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]) { logerror(" Unable to find function %s\n", fn); return FAILED; } BPatch_function *call19_1_func = bpfv[0]; BPatch_Vector<BPatch_snippet *> nullArgs; BPatch_funcCallExpr call19_1Expr(*call19_1_func, nullArgs); checkCost(call19_1Expr); appProc->oneTimeCode(call19_1Expr); // Let the mutatee run to check the result appProc->continueExecution(); // Wait for the next test if (waitUntilStopped(BPatch::bpatch, appProc, 19, "oneTimeCode") < 0) { return FAILED; } bpfv.clear(); const char *fn2 = "test1_19_call2"; if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size() || NULL == bpfv[0]) { logerror(" Unable to find function %s\n", fn2); return FAILED; } BPatch_function *call19_2_func = bpfv[0]; BPatch_funcCallExpr call19_2Expr(*call19_2_func, nullArgs); checkCost(call19_2Expr); int callbackFlag = 0; // Register a callback that will set the flag callbackFlag BPatchOneTimeCodeCallback oldCallback = BPatch::bpatch->registerOneTimeCodeCallback(test19_oneTimeCodeCallback); appProc->oneTimeCodeAsync(call19_2Expr, (void *)&callbackFlag); while (!appProc->isTerminated() && !appProc->isStopped() ) { BPatch::bpatch->waitForStatusChange(); } // Continue mutatee after one-time code runs appProc->continueExecution(); // Wait for the callback to be called while (!appProc->isTerminated() && !callbackFlag) { if( !BPatch::bpatch->waitForStatusChange() ) { logerror(" FAILED: could not wait for callback to be called\n"); return FAILED; } } if( !callbackFlag ) { logerror(" FAILED: process %d terminated while waiting for async oneTimeCode\n", appProc->getPid()); return FAILED; } // After the oneTimeCode is completed, there could be a crash due to bugs in // the RPC code, wait for termination while( !appProc->isTerminated() ) { if( !BPatch::bpatch->waitForStatusChange() ) { logerror(" FAILED: could not wait for process to terminate\n"); return FAILED; } } // Restore old callback (if there was one) BPatch::bpatch->registerOneTimeCodeCallback(oldCallback); return PASSED; } // test1_19_Mutator::executeTest()
test_results_t test1_3_Mutator::executeTest() { // Find the entry point to the procedure "func3_1" const char *funcName = "test1_3_func3_1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point3_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point3_1 || ((*point3_1).size() == 0)) { logerror("Unable to find entry point to \"%s.\"\n", funcName); return FAILED; } BPatch_Vector<BPatch_function *> bpfv; const char *fn = "test1_3_call3_1"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]) { logerror(" Unable to find function %s\n", fn); return FAILED; } if (1 < bpfv.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, bpfv.size(), fn); } BPatch_function *call3_func = bpfv[0]; BPatch_Vector<BPatch_snippet *> call3_args; BPatch_Vector<BPatch_point *> *call3_1 = call3_func->findPoint(BPatch_subroutine); if (!call3_1 || ((*call3_1).size() == 0)) { logerror(" Unable to find subroutine calls in \"call3_1.\"\n"); return FAILED; } const char *globalVar = "test1_3_globalVariable3_1"; BPatch_variableExpr *expr3_1 = findVariable(appImage, globalVar, call3_1); if (!expr3_1) { logerror("**Failed** test #3 (passing variables)\n"); logerror(" Unable to locate variable %s\n", globalVar); return FAILED; } // see if we can find the address if (expr3_1->getBaseAddr() <= 0) { logerror("*Error*: address %p for %s is not valid\n", expr3_1->getBaseAddr(), globalVar); } BPatch_variableExpr *expr3_2 = appAddrSpace->malloc(*appImage->findType("int")); if (!expr3_2) { logerror("**Failed** test #3 (passing variables)\n"); logerror(" Unable to create new int variable\n"); return FAILED; } BPatch_constExpr expr3_3 (expr3_1->getBaseAddr ()); BPatch_constExpr expr3_4 (expr3_2->getBaseAddr ()); int mutateeFortran = isMutateeFortran(appImage); if (mutateeFortran) { call3_args.push_back (&expr3_3); call3_args.push_back (&expr3_4); } else { call3_args.push_back(expr3_1); call3_args.push_back(expr3_2); } BPatch_funcCallExpr call3Expr(*call3_func, call3_args); checkCost(call3Expr); appAddrSpace->insertSnippet(call3Expr, *point3_1); BPatch_arithExpr expr3_5(BPatch_assign, *expr3_2, BPatch_constExpr(32)); checkCost(expr3_5); appAddrSpace->insertSnippet(expr3_5, *point3_1); dprintf("Inserted snippet3\n"); return PASSED; }
test_results_t test1_9_Mutator::executeTest() { // Find the entry point to the procedure "test1_9_func1" const char *funcName = "test1_9_func1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point9_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point9_1 || ((*point9_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return FAILED; } BPatch_Vector<BPatch_function *> bpfv; const char *fn = "test1_9_call1"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]) { logerror(" Unable to find function %s\n", fn); return FAILED; } BPatch_function *call9_func = bpfv[0]; BPatch_Vector<BPatch_snippet *> call9_args; BPatch_variableExpr *expr9_1 = appAddrSpace->malloc (*appImage->findType ("int")); BPatch_constExpr constExpr9_1 (0); BPatch_arithExpr arithexpr9_1 (BPatch_assign, *expr9_1, BPatch_constExpr (91)); appAddrSpace->insertSnippet (arithexpr9_1, *point9_1); int mutateeFortran = isMutateeFortran(appImage); if (mutateeFortran) { constExpr9_1 = expr9_1->getBaseAddr (); } else { constExpr9_1 = 91; } call9_args.push_back(&constExpr9_1); BPatch_variableExpr *expr9_2 = appAddrSpace->malloc (*appImage->findType ("int")); BPatch_constExpr constExpr9_2 (0); BPatch_arithExpr arithexpr9_2 (BPatch_assign, *expr9_2, BPatch_constExpr (92)); appAddrSpace->insertSnippet (arithexpr9_2, *point9_1); if (mutateeFortran) { constExpr9_2 = expr9_2->getBaseAddr (); } else { constExpr9_2 = 92; } call9_args.push_back(&constExpr9_2); BPatch_variableExpr *expr9_3 = appAddrSpace->malloc (*appImage->findType ("int")); BPatch_constExpr constExpr9_3 (0); BPatch_arithExpr arithexpr9_3 (BPatch_assign, *expr9_3, BPatch_constExpr (93)); appAddrSpace->insertSnippet (arithexpr9_3, *point9_1); if (mutateeFortran) { constExpr9_3 = expr9_3->getBaseAddr (); } else { constExpr9_3 = 93; } call9_args.push_back(&constExpr9_3); BPatch_variableExpr *expr9_4 = appAddrSpace->malloc (*appImage->findType ("int")); BPatch_constExpr constExpr9_4 (0); BPatch_arithExpr arithexpr9_4 (BPatch_assign, *expr9_4, BPatch_constExpr (94)); appAddrSpace->insertSnippet (arithexpr9_4, *point9_1); if (mutateeFortran) { constExpr9_4 = expr9_4->getBaseAddr (); } else { constExpr9_4 = 94; } call9_args.push_back(&constExpr9_4); BPatch_variableExpr *expr9_5 = appAddrSpace->malloc (*appImage->findType ("int")); BPatch_constExpr constExpr9_5 (0); BPatch_arithExpr arithexpr9_5 (BPatch_assign, *expr9_5, BPatch_constExpr (95)); appAddrSpace->insertSnippet (arithexpr9_5, *point9_1); if (mutateeFortran) { constExpr9_5 = expr9_5->getBaseAddr (); } else { constExpr9_5 = 95; } call9_args.push_back(&constExpr9_5); BPatch_funcCallExpr call9Expr(*call9_func, call9_args); checkCost(call9Expr); appAddrSpace->insertSnippet(call9Expr, *point9_1, BPatch_callBefore, BPatch_lastSnippet); return PASSED; }
test_results_t test1_7_Mutator::executeTest() { // Find the entry point to the procedure "func7_2" const char *funcName = "test1_7_func2"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point7_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point7_1 || ((*point7_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return FAILED; } BPatch_Vector<BPatch_snippet*> vect7_1; if ( genRelTest(appImage, vect7_1, BPatch_lt, 0, 1, "test1_7_globalVariable1") < 0) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_lt, 1, 0, "test1_7_globalVariable2") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_eq, 2, 2, "test1_7_globalVariable3") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_eq, 2, 3, "test1_7_globalVariable4") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_gt, 4, 3, "test1_7_globalVariable5") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_gt, 3, 4, "test1_7_globalVariable6") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_le, 3, 4, "test1_7_globalVariable7") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_le, 4, 3, "test1_7_globalVariable8") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ne, 5, 6, "test1_7_globalVariable9") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ne, 5, 5, "test1_7_globalVariable10") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ge, 9, 7, "test1_7_globalVariable11") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ge, 7, 9, "test1_7_globalVariable12") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_and, 1, 1, "test1_7_globalVariable13") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_and, 1, 0, "test1_7_globalVariable14") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_or, 1, 0, "test1_7_globalVariable15") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_or, 0, 0, "test1_7_globalVariable16") < 0 ) return FAILED; const char *funcName2 = "test1_7_func2"; BPatch_Vector<BPatch_function *> found_funcs2; if ((NULL == appImage->findFunction(funcName2, found_funcs2)) || !found_funcs2.size()) { logerror(" Unable to find function %s\n", funcName2); return FAILED; } if (1 < found_funcs2.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs2.size(), funcName2); } BPatch_Vector<BPatch_point *> *func7_1 = found_funcs2[0]->findPoint(BPatch_entry); if (!func7_1 || ((*func7_1).size() == 0)) { logerror("Unable to find entry points in \"%s\".\n", funcName2); return FAILED; } BPatch_variableExpr *constVar0, *constVar1, *constVar2, *constVar3, *constVar4, *constVar5, *constVar6, *constVar7, *constVar9; constVar0 = findVariable(appImage, "test1_7_constVar0", func7_1); constVar1 = findVariable(appImage, "test1_7_constVar1", func7_1); constVar2 = findVariable(appImage, "test1_7_constVar2", func7_1); constVar3 = findVariable(appImage, "test1_7_constVar3", func7_1); constVar4 = findVariable(appImage, "test1_7_constVar4", func7_1); constVar5 = findVariable(appImage, "test1_7_constVar5", func7_1); constVar6 = findVariable(appImage, "test1_7_constVar6", func7_1); constVar7 = findVariable(appImage, "test1_7_constVar7", func7_1); constVar9 = findVariable(appImage, "test1_7_constVar9", func7_1); if (!constVar0 || !constVar1 || !constVar2 || !constVar3 || !constVar4 || !constVar5 || !constVar6 || !constVar7 || !constVar9 ) { logerror("**Failed** test #7 (relational operators)\n"); logerror(" Unable to locate one of test1_7_constVar?\n"); return FAILED; } if ( genVRelTest(appImage, vect7_1, BPatch_lt, constVar0, constVar1, "test1_7_globalVariable1a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_lt, constVar1, constVar0, "test1_7_globalVariable2a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_eq, constVar2, constVar2, "test1_7_globalVariable3a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_eq, constVar2, constVar3, "test1_7_globalVariable4a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_gt, constVar4, constVar3, "test1_7_globalVariable5a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_gt, constVar3, constVar4, "test1_7_globalVariable6a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_le, constVar3, constVar4, "test1_7_globalVariable7a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_le, constVar4, constVar3, "test1_7_globalVariable8a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ne, constVar5, constVar6, "test1_7_globalVariable9a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ne, constVar5, constVar5, "test1_7_globalVariable10a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ge, constVar9, constVar7, "test1_7_globalVariable11a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ge, constVar7, constVar9, "test1_7_globalVariable12a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_and, constVar1, constVar1, "test1_7_globalVariable13a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_and, constVar1, constVar0, "test1_7_globalVariable14a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_or, constVar1, constVar0, "test1_7_globalVariable15a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_or, constVar0, constVar0, "test1_7_globalVariable16a") < 0 ) return FAILED; dprintf("relops test vector length is %d\n", vect7_1.size()); checkCost(BPatch_sequence(vect7_1)); if(!appAddrSpace->insertSnippet( BPatch_sequence(vect7_1), *point7_1)) return FAILED; return PASSED; }
// // Start Test Case #8 - (declaration) // test_results_t test5_8_Mutator::executeTest() { // Find the exit point to the procedure "func_cpp" BPatch_Vector<BPatch_function *> bpfv; const char *fn = "decl_test::func_cpp"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror( "**Failed** test #8 (declaration)\n"); logerror( " Unable to find function %s\n", fn); return FAILED; } BPatch_function *f1 = bpfv[0]; BPatch_Vector<BPatch_point *> *point8_1 = f1->findPoint(BPatch_exit); if (!point8_1 || (point8_1->size() < 1)) { logerror( "Unable to find point decl_test::func_cpp - exit.\n"); return FAILED; } bpfv.clear(); const char *fn2 = "main"; if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror( "**Failed** test #8 (declaration)\n"); logerror( " Unable to find function %s\n", fn2); return FAILED; } BPatch_function *f2 = bpfv[0]; BPatch_Vector<BPatch_point *> *point8_2 = f2->findPoint(BPatch_allLocations); if (!point8_2 || (point8_2->size() < 1)) { logerror( "Unable to find point in main.\n"); return FAILED; } bpfv.clear(); const char *fn3 = "decl_test::call_cpp"; if (NULL == appImage->findFunction(fn3, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror( "**Failed** test #8 (declaration)\n"); logerror( " Unable to find function %s\n", fn3); return FAILED; } BPatch_function *call8_func = bpfv[0]; BPatch_variableExpr *this8 = appImage->findVariable("test5_8_test8"); if (this8 == NULL) { logerror( "**Failed** test #8 (declaration)\n"); logerror( "Unable to find variable \"test5_8_test8\"\n"); return FAILED; } BPatch_Vector<BPatch_snippet *> call8_args; BPatch_arithExpr expr8_0(BPatch_addr, *this8); call8_args.push_back(&expr8_0); BPatch_constExpr expr8_1(8); call8_args.push_back(&expr8_1); BPatch_funcCallExpr call8Expr(*call8_func, call8_args); // find the variables of different scopes // What *exactly* are we testing here? Just finding variables of various // types with different point parameters to findVariable()? BPatch_variableExpr *expr8_2=appImage->findVariable("CPP_DEFLT_ARG"); BPatch_variableExpr *expr8_3=appImage->findVariable(*(*point8_2)[0], "test5_8_test8"); BPatch_variableExpr *expr8_4=appImage->findVariable(*(*point8_1)[0], "CPP_DEFLT_ARG"); if (!expr8_2 || !expr8_3 || !expr8_4) { logerror( "**Failed** test #8 (delcaration)\n"); logerror( " Unable to locate one of variables\n"); return FAILED; } BPatch_Vector<BPatch_variableExpr *> *fields = expr8_3->getComponents(); if (!fields || fields->size() == 0 ) { logerror( "**Failed** test #8 (declaration)\n"); logerror( " struct lacked correct number of elements\n"); return FAILED; } unsigned int index = 0; while ( index < fields->size() ) { char fieldName[100]; strcpy(fieldName, (*fields)[index]->getName()); if ( !strcmp("CPP_TEST_UTIL_VAR", (*fields)[index]->getName()) ) { dprintf("Inserted snippet2\n"); checkCost(call8Expr); BPatchSnippetHandle *handle; handle = appAddrSpace->insertSnippet(call8Expr, *point8_1); return PASSED; } index ++; } logerror( "**Failed** test #8 (declaration)\n"); logerror( " Can't find inherited class member variables\n"); return FAILED; }
// // Start Test Case #1 - (C++ argument pass) // // static int mutatorTest(BPatch_thread *appThread, BPatch_image *appImage) test_results_t test5_1_Mutator::executeTest() { BPatch_Vector<BPatch_function *> bpfv; const char *fn = "arg_test::call_cpp"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror("**Failed** test #1\n"); logerror(" Unable to find function %s\n", fn); return FAILED; } BPatch_function *f1 = bpfv[0]; BPatch_Vector<BPatch_point *> *point1_1 = f1->findPoint(BPatch_subroutine); assert(point1_1); assert((*point1_1)[0]); // check the paramter passing modes BPatch_variableExpr *arg0 = appImage->findVariable(*(*point1_1)[0], "reference"); BPatch_variableExpr *arg1 = appImage->findVariable(*(*point1_1)[0], "arg1"); BPatch_variableExpr *arg2 = appImage->findVariable(*(*point1_1)[0], "arg2"); BPatch_variableExpr *arg3 = appImage->findVariable(*(*point1_1)[0], "arg3"); BPatch_variableExpr *arg4 = appImage->findVariable(*(*point1_1)[0], "m"); if (!arg0 || !arg1 || !arg2 || !arg3 || !arg4) { logerror("**Failed** test #1 (argument passing)\n"); if ( !arg0 ) logerror(" can't find local variable 'reference'\n"); if ( !arg1 ) logerror(" can't find local variable 'arg1'\n"); if ( !arg2 ) logerror(" can't find local variable 'arg2'\n"); if ( !arg3 ) logerror(" can't find local variable 'arg3'\n"); if ( !arg4 ) logerror(" can't find local variable 'm'\n"); return FAILED; } BPatch_type *type1_0 = const_cast<BPatch_type *> (arg0->getType()); BPatch_type *type1_1 = const_cast<BPatch_type *> (arg1->getType()); BPatch_type *type1_2 = const_cast<BPatch_type *> (arg2->getType()); BPatch_type *type1_3 = const_cast<BPatch_type *> (arg4->getType()); assert(type1_0 && type1_1 && type1_2 && type1_3); if (!type1_1->isCompatible(type1_3)) { logerror("**Failed** test #1 (C++ argument pass)\n"); logerror(" type1_1 reported as incompatibile with type1_3\n"); return FAILED; } if (!type1_2->isCompatible(type1_0)) { logerror("**Failed** test #1 (C++ argument pass)\n"); logerror(" type1_2 reported as incompatibile with type1_0\n"); return FAILED; } BPatch_arithExpr expr1_1(BPatch_assign, *arg3, BPatch_constExpr(1)); checkCost(expr1_1); appAddrSpace->insertSnippet(expr1_1, *point1_1); // pass a paramter to a class member function bpfv.clear(); const char *fn2 = "arg_test::func_cpp"; if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size() || NULL == bpfv[0]){ logerror("**Failed** test #1 (C++ argument pass)\n"); logerror(" Unable to find function %s\n", fn2); return FAILED; } BPatch_function *f2 = bpfv[0]; BPatch_Vector<BPatch_point *> *point1_2 = f2->findPoint(BPatch_subroutine); if (!point1_2 || (point1_2->size() < 1)) { logerror("**Failed** test #1 (C++ argument pass)\n"); logerror("Unable to find point arg_test::func_cpp - exit.\n"); return FAILED; } bpfv.clear(); const char *fn3 = "arg_test::arg_pass"; if (NULL == appImage->findFunction(fn3, bpfv) || !bpfv.size() || NULL == bpfv[0]) { logerror("**Failed** test #1 (C++ argument pass)\n"); logerror(" Unable to find function %s\n", fn3); return FAILED; } BPatch_function *call1_func = bpfv[0]; BPatch_variableExpr *this1 = appImage->findVariable("test1"); if (this1 == NULL) { logerror("**Failed** test #1 (C++ argument pass)\n"); logerror("Unable to find variable \"test1\"\n"); return FAILED; } BPatch_Vector<BPatch_snippet *> call1_args; BPatch_arithExpr expr1_2(BPatch_addr, *this1); call1_args.push_back(&expr1_2); BPatch_constExpr expr1_3(1); call1_args.push_back(&expr1_3); BPatch_funcCallExpr call1Expr(*call1_func, call1_args); checkCost(call1Expr); appAddrSpace->insertSnippet(call1Expr, *point1_2); return PASSED; }