int main(int argc, char *argv[]) { Bool addexit; char *label, *cmd; int i, xr, yr, bitm; unsigned int wr, hr; addexit = True; if (argc < 2) usage(argv[0]); i = 1; for (; argv[i]; i++) { if (argv[i][0] != '-') break; if (argv[i][1] == '-') { i++; break; } switch (argv[i][1]) { case 'g': if (i >= argc - 1) break; bitm = XParseGeometry(argv[i+1], &xr, &yr, &wr, &hr); if (bitm & XValue) wx = xr; if (bitm & YValue) wy = yr; if (bitm & WidthValue) ww = (int)wr; if (bitm & HeightValue) wh = (int)hr; if (bitm & XNegative && wx == 0) wx = -1; if (bitm & YNegative && wy == 0) wy = -1; i++; break; case 'h': switch ((i >= argc - 1)? 0 : argv[i][2]) { case 's': heightscaling = atof(argv[i+1]); i++; break; default: usage(argv[0]); } break; case 'o': horizontal = True; break; case 's': oneshot = 0; break; case 'w': switch ((i >= argc - 1)? 0 : argv[i][2]) { case 's': widthscaling = atof(argv[i+1]); i++; break; default: usage(argv[0]); } break; case 'x': addexit = False; break; default: usage(argv[0]); } } for (; argv[i]; i++) { label = argv[i]; if (!argv[i+1]) break; i++; cmd = argv[i]; entries = realloc(entries, sizeof(entries[0])*(++nentries)); entries[nentries-1] = malloc(sizeof(*entries[0])); memset(entries[nentries-1], 0, sizeof(*entries[0])); entries[nentries-1]->label = strdup(label); if (entries[nentries-1]->label == NULL) die("strdup returned NULL\n"); entries[nentries-1]->cmd = strdup(cmd); if (entries[nentries-1]->cmd == NULL) die("strdup returned NULL\n"); } if (nentries < 1) usage(argv[0]); if (addexit) { entries = realloc(entries, sizeof(entries[0])*(++nentries)); entries[nentries-1] = malloc(sizeof(*entries[0])); memset(entries[nentries-1], 0, sizeof(*entries[0])); entries[nentries-1]->label = strdup("cancel"); entries[nentries-1]->cmd = "exit"; entries[nentries-1]->forceexit = True; } if(!setlocale(LC_CTYPE, "") || !XSupportsLocale()) fprintf(stderr, "warning: no locale support\n"); if(!(dpy = XOpenDisplay(0))) die("thingmenu: cannot open display\n"); setup(); run(); cleanup(); XCloseDisplay(dpy); for (i = 0; i < nentries; i++) free(entries[i]); free(entries); return 0; }
/** Handle tab completion. * User interface uses a dual model, first tab completes upto the * longest common (case insensitiv) match, further tabbing cycles through all * possible completions. When doing a tab completion without something to complete * possibly offers a special guess first. */ void TabCompletion::tryComplete() { switch (typingStatus_) { case TypingStatus::Normal: typingStatus_ = TypingStatus::TabPressed; break; case TypingStatus::TabPressed: typingStatus_ = TypingStatus::TabbingCompletions; break; default: break; } QString newText; bool replaced = false; if (typingStatus_ == TypingStatus::MultipleSuggestions) { if (!suggestedCompletion_.isEmpty()) { suggestedIndex_++; if (suggestedIndex_ >= (int)suggestedCompletion_.count()) { suggestedIndex_ = 0; } newText = suggestedCompletion_[suggestedIndex_]; replaced = true; } } else { QTextCursor cursor = textEdit_->textCursor(); QString wholeText = textEdit_->toPlainText(); int begin, end; setup(wholeText, cursor.position(), begin, end); replacementCursor_ = QTextCursor(textEdit_->document()); moveCursorToOffset(replacementCursor_, begin); moveCursorToOffset(replacementCursor_, end, QTextCursor::KeepAnchor); if (toComplete_.isEmpty() && typingStatus_ == TypingStatus::TabbingCompletions) { typingStatus_ = TypingStatus::MultipleSuggestions; QString guess; suggestedCompletion_ = allChoices(guess); if ( !guess.isEmpty() ) { suggestedIndex_ = -1; newText = guess; replaced = true; } else if (!suggestedCompletion_.isEmpty()) { suggestedIndex_ = 0; newText = suggestedCompletion_.first(); replaced = true; } } else { newText = suggestCompletion(&replaced); } } if (replaced) { textEdit_->setUpdatesEnabled(false); int start = qMin(replacementCursor_.anchor(), replacementCursor_.position()); replacementCursor_.beginEditBlock(); replacementCursor_.insertText(newText); replacementCursor_.endEditBlock(); QTextCursor newPos(replacementCursor_); moveCursorToOffset(replacementCursor_, start, QTextCursor::KeepAnchor); newPos.clearSelection(); textEdit_->setTextCursor(newPos); textEdit_->setUpdatesEnabled(true); textEdit_->viewport()->update(); } highlight(typingStatus_ == TypingStatus::MultipleSuggestions); }
ofxGuiGroup::ofxGuiGroup(const ofParameterGroup & parameters, string filename, float x, float y){ minimized = false; parent = NULL; setup(parameters, filename, x, y); }
int AXWindow::run(){ if(setup){ setup(); } if(activeScene){ activeScene->start(); } SDL_Event event; bool inFocus = true; while(go == 1){ AXWindow::frameCount++; AXWindow::deltaTime = SDL_GetPerformanceCounter() - AXWindow::previousDeltaTime; AXWindow::previousDeltaTime = SDL_GetPerformanceCounter(); while(SDL_PollEvent(&event) != 0 ){ //User requests quit if(event.type == SDL_QUIT){ go = 0; break; }else if( event.type == SDL_KEYDOWN){ const std::string& temp = AXInput::setKeyDown(event.key.keysym.scancode); if(activeScene){ activeScene->inputChange(temp, 1); } }else if(event.type == SDL_KEYUP){ const std::string& temp = AXInput::setKeyUp(event.key.keysym.scancode); if(activeScene){ activeScene->inputChange(temp, 0); } }else if(event.type == SDL_MOUSEMOTION){ AXInput::mouseX = event.motion.x; AXInput::mouseY = event.motion.y; }else if(event.type == SDL_MOUSEBUTTONDOWN){ const std::string& temp = AXInput::mousePressed(event.button.button); if(activeScene){ activeScene->inputChange(temp, 1); } }else if(event.type == SDL_MOUSEBUTTONUP){ const std::string& temp = AXInput::mouseReleased(event.button.button); if(activeScene){ activeScene->inputChange(temp, 0); } }else if(event.type == SDL_CONTROLLERBUTTONDOWN){ const std::string& temp = AXInput::setKeyDown((SDL_GameControllerButton)event.cbutton.button+(AX_INPUT_CONTROLLER_OFFSET*(event.cdevice.which+1))); if(activeScene){ activeScene->inputChange(temp, 1); } }else if(event.type == SDL_CONTROLLERBUTTONUP){ const std::string& temp = AXInput::setKeyUp((SDL_GameControllerButton)event.cbutton.button+(AX_INPUT_CONTROLLER_OFFSET*(event.cdevice.which+1))); if(activeScene){ activeScene->inputChange(temp, 0); } }else if(event.type == SDL_CONTROLLERDEVICEADDED){ AXInput::controllers[event.cdevice.which] = SDL_GameControllerOpen(event.cdevice.which); }else if(event.type == SDL_CONTROLLERDEVICEREMOVED){ SDL_GameControllerClose(AXInput::controllers[event.cdevice.which]); AXInput::controllers[event.cdevice.which] = 0; }else if(event.type == SDL_CONTROLLERAXISMOTION){ AXInput::setAxisValue(AX_INPUT_CONTROLLER_AXIS_OFFSET+event.caxis.axis+AX_INPUT_CONTROLLER_OFFSET*(event.caxis.which+1), event.caxis.value); }else if(event.type == SDL_WINDOWEVENT){ if(event.window.event == SDL_WINDOWEVENT_FOCUS_GAINED){ inFocus = true; }else if(event.window.event == SDL_WINDOWEVENT_FOCUS_LOST){ inFocus = false; } } } if(inFocus){ if(update){ update(); } if(activeScene) { activeScene->update(); } } //Fill the surface wshite SDL_SetRenderDrawColor(AXWindow::renderer, backgroundColour.getR(), backgroundColour.getG(), backgroundColour.getB(), backgroundColour.getA()); SDL_RenderClear(AXWindow::renderer); if(inFocus){ SDL_SetRenderDrawColor(AXWindow::renderer, renderColour.getR(), renderColour.getG(), renderColour.getB(), renderColour.getA()); if(draw){ draw(); } if(activeScene) { activeScene->draw(); } } SDL_RenderPresent(AXWindow::renderer); } SDL_DestroyWindow(window); SDL_DestroyRenderer(renderer); //quit the SDLMix if(audioStatus){ while(Mix_Init(0)){ Mix_Quit(); } Mix_CloseAudio(); } //Quit SDL subsystems SDL_Quit(); return 0; }
int main(int argc, char *argv[]) { int status; struct semid_ds buf_ds; union semun arg; setup(); arg.buf = &buf_ds; if ((status = semctl(semid, 0, IPC_STAT, arg)) == -1) { tst_resm(TFAIL, "semctl() failed errno = %d", errno); semctl(semid, 1, IPC_RMID, arg); } /* * Check contents of semid_ds structure. */ if (arg.buf->sem_nsems != nsems) { tst_resm(TFAIL, "error: unexpected number of sems %lu", arg.buf->sem_nsems); } if (arg.buf->sem_perm.uid != getuid()) { tst_resm(TFAIL, "error: unexpected uid %d", arg.buf->sem_perm.uid); } if (arg.buf->sem_perm.gid != getgid()) { tst_resm(TFAIL, "error: unexpected gid %d", arg.buf->sem_perm.gid); } if (arg.buf->sem_perm.cuid != getuid()) { tst_resm(TFAIL, "error: unexpected cuid %d", arg.buf->sem_perm.cuid); } if (arg.buf->sem_perm.cgid != getgid()) { tst_resm(TFAIL, "error: unexpected cgid %d", arg.buf->sem_perm.cgid); } if ((status = semctl(semid, 0, GETVAL, arg)) == -1) { tst_resm(TFAIL, "semctl(GETVAL) failed errno = %d", errno); } arg.val = 1; if ((status = semctl(semid, 0, SETVAL, arg)) == -1) { tst_resm(TFAIL, "SEMCTL(SETVAL) failed errno = %d", errno); } if ((status = semctl(semid, 0, GETVAL, arg)) == -1) { tst_resm(TFAIL, "semctl(GETVAL) failed errno = %d", errno); } if (status != arg.val) { tst_resm(TFAIL, "error: unexpected value %d", status); } if ((status = semctl(semid, 0, GETPID, arg)) == -1) { tst_resm(TFAIL, "semctl(GETPID) failed errno = %d", errno); } status = getpid(); if (status == 0) { tst_resm(TFAIL, "error: unexpected pid %d", status); } if ((status = semctl(semid, 0, GETNCNT, arg)) == -1) { tst_resm(TFAIL, "semctl(GETNCNT) failed errno = %d", errno); } if (status != 0) { tst_resm(TFAIL, "error: unexpected semncnt %d", status); } if ((status = semctl(semid, 0, GETZCNT, arg)) == -1) { tst_resm(TFAIL, "semctl(GETZCNT) failed errno = %d", errno); } if (status != 0) { tst_resm(TFAIL, "error: unexpected semzcnt %d", status); } tst_resm(TPASS, "semctl07 ran successfully!"); cleanup(); tst_exit(); }
void BitVector_Test::Test_bitVectorPopulationCount() { { const u32 SIZE = 0; BitVector<SIZE> bits; assert(bits.PopulationCount() == 0); for (u32 i = 0; i < SIZE; ++i) { bits.SetBit(i); assert(bits.PopulationCount() == i + 1); } } { const u32 SIZE = 1; BitVector<SIZE> bits; assert(bits.PopulationCount() == 0); for (u32 i = 0; i < SIZE; ++i) { bits.SetBit(i); assert(bits.PopulationCount() == i + 1); } } { const u32 SIZE = 31; BitVector<SIZE> bits; assert(bits.PopulationCount() == 0); for (u32 i = 0; i < SIZE; ++i) { bits.SetBit(i); assert(bits.PopulationCount() == i + 1); } } { const u32 SIZE = 32; BitVector<SIZE> bits; assert(bits.PopulationCount() == 0); for (u32 i = 0; i < SIZE; ++i) { bits.SetBit(i); assert(bits.PopulationCount() == i + 1); } } { const u32 SIZE = 35; BitVector<SIZE> bits; assert(bits.PopulationCount() == 0); for (u32 i = 0; i < SIZE; ++i) { bits.SetBit(i); assert(bits.PopulationCount() == i + 1); } } { const u32 SIZE = 67; BitVector<SIZE> bits; assert(bits.PopulationCount() == 0); for (u32 i = 0; i < SIZE; ++i) { bits.SetBit(i); assert(bits.PopulationCount() == i + 1); } // all combinations of start and len.. BitVector<SIZE> zbits; for (u32 start = 0; start < SIZE; ++start) { for (u32 end = start; end < SIZE; ++end) { u32 len = end - start + 1; assert(bits.PopulationCount(start, len) == len); assert(zbits.PopulationCount(start, len) == 0); } } } { const u32 SIZE = 258; BitVector<SIZE> bits; assert(bits.PopulationCount() == 0); for (u32 i = 0; i < SIZE; ++i) { bits.SetBit(SIZE - i - 1); assert(bits.PopulationCount() == i + 1); } assert(bits.PopulationCount() == SIZE); for (u32 i = 0; i < SIZE; ++i) { bits.ClearBit(i); assert(bits.PopulationCount() == SIZE - (i + 1)); } } { BitVector<256>* bits = setup(); assert(bits->PopulationCount() == 115); assert(bits->PopulationCount(64,96) == 51); assert(bits->PopulationCount(5,250) == 113); } }
//------------------------------------------- blobTracker::blobTracker() { setup(500); }
/* FIXME: this is only used by solver code since matrix solvers are started in * post_start. */ void device_t::connect_post_start(detail::core_terminal_t &t1, detail::core_terminal_t &t2) { if (!setup().connect(t1, t2)) log().fatal(MF_ERROR_CONNECTING_1_TO_2(t1.name(), t2.name())); }
Menu::Menu(sf::RenderWindow* window){ this->menuWindow = window; this->menuOptions = play; setup(); }
void device_t::connect(detail::core_terminal_t &t1, detail::core_terminal_t &t2) { setup().register_link_fqn(t1.name(), t2.name()); }
void device_t::connect(const pstring &t1, const pstring &t2) { setup().register_link_fqn(name() + "." + t1, name() + "." + t2); }
int main(int argc, char **argv) { register int i, pid; int count, child, status, nwait; #ifdef UCLINUX const char *msg; if ((msg = parse_opts(argc, argv, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); argv0 = argv[0]; maybe_run_child(&do_child, "dS", &id_uclinux, &maxsemstring); #endif prog = argv[0]; nwait = 0; setup(); tid = -1; for (i = 0; i < NPROCS; i++) keyarray[i] = getipckey(); if ((signal(SIGTERM, term)) == SIG_ERR) { tst_resm(TFAIL, "\tsignal failed. errno = %d", errno); } for (i = 0; i < NPROCS; i++) { if ((pid = FORK_OR_VFORK()) < 0) { tst_resm(TFAIL, "\tFork failed (may be OK if under stress)"); } if (pid == 0) { procstat = 1; dotest(keyarray[i]); exit(0); } pidarray[i] = pid; nwait++; } /* * Wait for children to finish. */ count = 0; while ((child = wait(&status)) > 0) { if (status) { tst_resm(TFAIL, "%s[%d] Test failed. exit=0x%x", prog, child, status); local_flag = FAILED; } ++count; } /* * Should have collected all children. */ if (count != nwait) { tst_resm(TFAIL, "\tWrong # children waited on, count = %d", count); local_flag = FAILED; } if (local_flag != FAILED) tst_resm(TPASS, "semctl06 ran successfully!"); else tst_resm(TFAIL, "semctl06 failed"); cleanup(); tst_exit(); }
int main(int ac, char **av) { int lc; char *msg; struct stat buf, buf1; pid_t pid, pid1; struct passwd *ltpuser1; struct passwd *ltpuser2; int rval, status; /* * parse standard options */ if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); } /* * perform global setup for test */ setup(); /* * check looping state if -i option given */ for (lc = 0; TEST_LOOPING(lc); lc++) { tst_count = 0; /* check the inherited group ID */ /* * first, fork the first child, set to ltpuser1's uid and gid, * create a directory, with S_ISGID bit set */ ltpuser1 = my_getpwnam(user1name); sprintf(tstdir1, "tstdir1.%d", getpid()); if ((pid = FORK_OR_VFORK()) < 0) { tst_brkm(TFAIL, cleanup, "fork() failed"); } if (pid == 0) { /* first child */ rval = setregid(ltpuser1->pw_gid, ltpuser1->pw_gid); if (rval < 0) { perror("setregid"); tst_resm(TFAIL, "setregid failed to " "to set the real gid to %d and " "effective gid to %d", ltpuser1->pw_gid, ltpuser1->pw_gid); exit(1); } /* being ltupuser1 */ rval = setreuid(ltpuser1->pw_uid, ltpuser1->pw_uid); if (rval < 0) { perror("setreuid"); tst_resm(TFAIL, "setreuid failed to " "to set the real uid to %d and " "effective uid to %d", ltpuser1->pw_uid, ltpuser1->pw_uid); exit(1); } /* * create a direcoty with S_ISGID bit set * and the group ID is ltpuser1 */ if (mkdir(tstdir1, PERMS) != 0) { perror("mkdir"); tst_resm(TFAIL, "mkdir() failed to create" " a directory with Set " " group ID turn on "); exit(1); } if (stat(tstdir1, &buf1) == -1) { perror("stat"); tst_resm(TFAIL, "failed to stat the new directory" "in mkdir()"); exit(1); } if (chmod(tstdir1, buf1.st_mode | S_ISGID) != 0) { perror("chmod"); tst_resm(TFAIL, "failed to set S_ISGID bit"); exit(1); } /* Successfully create the parent directory */ exit(0); } wait(&status); if (WEXITSTATUS(status) != 0) { tst_brkm(TFAIL, cleanup, "Test to attempt to make a directory" " inherits group ID FAILED "); } /* * fork the second child process, set to ltpuser2's uid and gid * create a sub directory under the directory * just created by child process 1 * check the group ID of the sub directory * should inherit from parent directory */ ltpuser2 = my_getpwnam(user2name); sprintf(tstdir2, "%s/tstdir2.%d", tstdir1, getpid()); if ((pid1 = FORK_OR_VFORK()) < 0) { perror("fork failed"); tst_brkm(TFAIL, cleanup, "fork() failed"); } else if (pid1 == 0) { /* second child */ /* being user ltpuser2 */ rval = setregid(ltpuser2->pw_gid, ltpuser2->pw_gid); if (rval < 0) { tst_resm(TFAIL, "setregid failed to " "to set the real gid to %d and " "effective gid to %d", ltpuser2->pw_gid, ltpuser2->pw_gid); perror("setregid"); exit(1); } rval = setreuid(ltpuser2->pw_uid, ltpuser2->pw_uid); if (rval < 0) { tst_resm(TFAIL, "setreuid failed to " "to set the real uid to %d and " "effective uid to %d", ltpuser2->pw_uid, ltpuser2->pw_uid); perror("setreuid"); exit(1); } /* * create a sub direcoty * under the directory just created * by ltpuser1 */ if (mkdir(tstdir2, PERMS) != 0) { tst_resm(TFAIL, "mkdir() failed to create" " a directory %s under %s ", tstdir2, tstdir1); exit(1); } /* * check the group ID * should not be the same as the current processs's * since parent directory is set with S_ISGID bit */ if (stat(tstdir2, &buf) == -1) { tst_resm(TFAIL, "failed to stat the new directory" "in mkdir()"); exit(1); } if (stat(tstdir1, &buf1) == -1) { tst_resm(TFAIL, "failed to stat the new directory" "in mkdir()"); exit(1); } if (buf.st_gid != buf1.st_gid) { tst_resm(TFAIL, "mkdir() FAILED to inherit " " the group ID %d from parent " " directory %d", buf.st_gid, buf1.st_gid); exit(1); } /* check the S_ISGID bit */ if (!(buf.st_mode & S_ISGID)) { tst_resm(TFAIL, "mkdir() FAILED to inherit " " the S_ISGID bit from parent " " directory"); exit(1); } /* PASS */ exit(0); } waitpid(pid1, &status, 0); if (WEXITSTATUS(status) == 0) { tst_resm(TPASS, "Test to attempt to make a directory" " inherits group ID SUCCEEDED "); } else { tst_resm(TFAIL, "Test to attempt to make a directory" " inherits group ID FAILED"); cleanup(); } } /* * cleanup and exit */ cleanup(); tst_exit(); }
int main(int ac, char **av) { int lc; char *msg; int ind; int offset; /*************************************************************** * parse standard options ***************************************************************/ if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); } /*************************************************************** * perform global setup for test ***************************************************************/ setup(); /* set the expected errnos... */ TEST_EXP_ENOS(exp_enos); /*************************************************************** * check looping state if -c option given ***************************************************************/ for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; offset = (lc % 100) * 4096; /* max size is 100 blocks */ for (ind = 0; Whence[ind] >= 0; ind++) { /* * Call lseek(2) */ TEST(lseek(Fd, (long)offset, Whence[ind])); /* check return code */ if (TEST_RETURN == -1) { TEST_ERROR_LOG(TEST_ERRNO); tst_resm(TFAIL, "lseek(%s, %d, 0) Failed, errno=%d : %s", Fname, offset, TEST_ERRNO, strerror(TEST_ERRNO)); } else { /*************************************************************** * only perform functional verification if flag set (-f not given) ***************************************************************/ if (STD_FUNCTIONAL_TEST) { /* No Verification test, yet... */ tst_resm(TPASS, "lseek(%s, %d, %d) returned %ld", Fname, offset, Whence[ind], TEST_RETURN); } else Tst_count++; } } } /*************************************************************** * cleanup and exit ***************************************************************/ cleanup(); tst_exit(); }
int main(int ac, char *av[]) { int ret; struct stat buf; struct group *group; struct passwd *user1; char DIR_A[MSGSIZE], DIR_B[MSGSIZE]; char setgid_A[MSGSIZE], nosetgid_A[MSGSIZE]; char setgid_B[MSGSIZE], nosetgid_B[MSGSIZE], root_setgid_B[MSGSIZE]; gid_t group1_gid, group2_gid, mygid; uid_t save_myuid, user1_uid; pid_t mypid; int lc; int fail_count = 0; tst_parse_opts(ac, av, NULL, NULL); setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { local_flag = PASSED; save_myuid = getuid(); mypid = getpid(); sprintf(DIR_A, DIR_A_TEMP, mypid); sprintf(DIR_B, DIR_B_TEMP, mypid); sprintf(setgid_A, "%s/%s", DIR_A, SETGID); sprintf(nosetgid_A, "%s/%s", DIR_A, NOSETGID); sprintf(setgid_B, "%s/%s", DIR_B, SETGID); sprintf(nosetgid_B, "%s/%s", DIR_B, NOSETGID); sprintf(root_setgid_B, "%s/%s", DIR_B, ROOT_SETGID); /* Get the uid of user1 */ user1 = getpwnam("nobody"); if (user1 == NULL) tst_brkm(TBROK, cleanup, "nobody not in /etc/passwd"); user1_uid = user1->pw_uid; /* * Get the group IDs of group1 and group2. */ group = getgrnam("nobody"); if (group == NULL) { group = getgrnam("nogroup"); if (group == NULL) { tst_brkm(TBROK, cleanup, "nobody/nogroup not in /etc/group"); } } group1_gid = group->gr_gid; group = getgrnam("bin"); if (group == NULL) tst_brkm(TBROK, cleanup, "bin not in /etc/group"); group2_gid = group->gr_gid; /* * Create a directory with group id the same as this process * and with no setgid bit. */ if (mkdir(DIR_A, MODE_RWX) < 0) { tst_resm(TFAIL | TERRNO, "mkdir(%s) failed", DIR_A); local_flag = FAILED; } if (chown(DIR_A, user1_uid, group2_gid) < 0) { tst_resm(TFAIL | TERRNO, "chown(%s) failed", DIR_A); local_flag = FAILED; } if (stat(DIR_A, &buf) < 0) { tst_resm(TFAIL | TERRNO, "stat(%s) failed", DIR_A); local_flag = FAILED; } /* Verify modes */ if (buf.st_mode & S_ISGID) { tst_resm(TFAIL, "%s: Incorrect modes, setgid bit set", DIR_A); local_flag = FAILED; } /* Verify group ID */ if (buf.st_gid != group2_gid) { tst_resm(TFAIL, "%s: Incorrect group (got %d and %d)", DIR_A, buf.st_gid, group2_gid); local_flag = FAILED; } /* * Create a directory with group id different from that of * this process and with the setgid bit set. */ if (mkdir(DIR_B, MODE_RWX) < 0) { tst_resm(TFAIL | TERRNO, "mkdir(%s) failed", DIR_B); local_flag = FAILED; } if (chown(DIR_B, user1_uid, group2_gid) < 0) { tst_resm(TFAIL | TERRNO, "chown(%s) failed", DIR_B); local_flag = FAILED; } if (chmod(DIR_B, MODE_SGID) < 0) { tst_resm(TFAIL | TERRNO, "chmod(%s) failed", DIR_B); local_flag = FAILED; } if (stat(DIR_B, &buf) < 0) { tst_resm(TFAIL | TERRNO, "stat(%s) failed", DIR_B); local_flag = FAILED; } /* Verify modes */ if (!(buf.st_mode & S_ISGID)) { tst_resm(TFAIL, "%s: Incorrect modes, setgid bit not set", DIR_B); local_flag = FAILED; } /* Verify group ID */ if (buf.st_gid != group2_gid) { tst_resm(TFAIL, "%s: Incorrect group (got %d and %d)", DIR_B, buf.st_gid, group2_gid); local_flag = FAILED; } if (local_flag == PASSED) { tst_resm(TPASS, "Test passed in block0."); } else { tst_resm(TFAIL, "Test failed in block0."); fail_count++; } local_flag = PASSED; /* * Create two files in testdir.A, one with the setgid * bit set in the creation modes and the other without. * Both should inherit the group ID of the process and * maintain the setgid bit as specified in the creation * modes. */ if (setgid(group1_gid) < 0) { tst_resm(TINFO, "Unable to set process group ID to group1"); } if (setreuid(-1, user1_uid) < 0) tst_resm(TINFO, "Unable to set process uid to user1"); mygid = getgid(); /* * Create the file with setgid not set */ ret = open(nosetgid_A, O_CREAT | O_EXCL | O_RDWR, MODE_RWX); if (ret < 0) { tst_resm(TFAIL | TERRNO, "open(%s) failed", nosetgid_A); local_flag = FAILED; } close(ret); if (stat(nosetgid_A, &buf) < 0) { tst_resm(TFAIL | TERRNO, "stat(%s) failed", nosetgid_A); local_flag = FAILED; } /* Verify modes */ if (buf.st_mode & S_ISGID) { tst_resm(TFAIL, "%s: Incorrect modes, setgid bit set", nosetgid_A); local_flag = FAILED; } /* Verify group ID */ if (buf.st_gid != mygid) { tst_resm(TFAIL, "%s: Incorrect group (got %d and %d)", nosetgid_A, buf.st_gid, mygid); local_flag = FAILED; } /* * Create the file with setgid set */ ret = open(setgid_A, O_CREAT | O_EXCL | O_RDWR, MODE_SGID); if (ret < 0) { tst_resm(TFAIL | TERRNO, "open(%s) failed", setgid_A); local_flag = FAILED; } close(ret); if (stat(setgid_A, &buf) < 0) { tst_resm(TFAIL | TERRNO, "stat(%s) failed", setgid_A); local_flag = FAILED; } /* Verify modes */ if (!(buf.st_mode & S_ISGID)) { tst_resm(TFAIL, "%s: Incorrect modes, setgid bit not set", setgid_A); local_flag = FAILED; } /* Verify group ID */ if (buf.st_gid != mygid) { tst_resm(TFAIL, "%s: Incorrect group (%d and %d)", setgid_A, buf.st_gid, mygid); local_flag = FAILED; } if (local_flag == PASSED) { tst_resm(TPASS, "Test passed in block1."); } else { tst_resm(TFAIL, "Test failed in block1."); fail_count++; } local_flag = PASSED; /* * Create two files in testdir.B, one with the setgid * bit set in the creation modes and the other without. * Both should inherit the group ID of the parent * directory, group2. Either file should have the segid * bit set in the modes. */ /* * Create the file with setgid not set */ ret = open(nosetgid_B, O_CREAT | O_EXCL | O_RDWR, MODE_RWX); if (ret < 0) { tst_resm(TFAIL | TERRNO, "open(%s) failed", nosetgid_B); local_flag = FAILED; } close(ret); if (stat(nosetgid_B, &buf) < 0) { tst_resm(TFAIL | TERRNO, "stat(%s) failed", nosetgid_B); local_flag = FAILED; } /* Verify modes */ if (buf.st_mode & S_ISGID) { tst_resm(TFAIL, "%s: Incorrect modes, setgid bit should be set", nosetgid_B); local_flag = FAILED; } /* Verify group ID */ if (buf.st_gid != group2_gid) { tst_resm(TFAIL, "%s: Incorrect group (got %d and %d)", nosetgid_B, buf.st_gid, group2_gid); local_flag = FAILED; } /* * Create the file with setgid set */ ret = open(setgid_B, O_CREAT | O_EXCL | O_RDWR, MODE_SGID); if (ret < 0) { tst_resm(TFAIL | TERRNO, "open(%s) failed", setgid_B); local_flag = FAILED; } close(ret); if (stat(setgid_B, &buf) < 0) { tst_resm(TFAIL | TERRNO, "stat(%s) failed", setgid_B); local_flag = FAILED; } /* Verify group ID */ if (buf.st_gid != group2_gid) { tst_resm(TFAIL, "%s: Incorrect group (got %d and %d)", setgid_B, buf.st_gid, group2_gid); local_flag = FAILED; } /* Verify modes */ if (!(buf.st_mode & S_ISGID)) { tst_resm(TFAIL, "%s: Incorrect modes, setgid bit not set", setgid_B); local_flag = FAILED; } if (local_flag == PASSED) { tst_resm(TPASS, "Test passed in block2."); } else { tst_resm(TFAIL, "Test failed in block2."); fail_count++; } local_flag = PASSED; /* * Create a file in testdir.B, with the setgid bit set * in the creation modes and do so as root. The file * should inherit the group ID of the parent directory, * group2 and should have the setgid bit set. */ /* Become root again */ if (setreuid(-1, save_myuid) < 0) { tst_resm(TFAIL | TERRNO, "Changing back to root failed"); local_flag = FAILED; } /* Create the file with setgid set */ ret = open(root_setgid_B, O_CREAT | O_EXCL | O_RDWR, MODE_SGID); if (ret < 0) { tst_resm(TFAIL | TERRNO, "open(%s) failed", root_setgid_B); local_flag = FAILED; } close(ret); if (stat(root_setgid_B, &buf) < 0) { tst_resm(TFAIL | TERRNO, "stat(%s) failed", root_setgid_B); local_flag = FAILED; } /* Verify modes */ if (!(buf.st_mode & S_ISGID)) { tst_resm(TFAIL, "%s: Incorrect modes, setgid bit not set", root_setgid_B); local_flag = FAILED; } /* Verify group ID */ if (buf.st_gid != group2_gid) { tst_resm(TFAIL, "%s: Incorrect group (got %d and %d)", root_setgid_B, buf.st_gid, group2_gid); local_flag = FAILED; } if (local_flag == PASSED) { tst_resm(TPASS, "Test passed in block3."); } else { tst_resm(TFAIL, "Test failed in block3."); fail_count++; } /* * Clean up any files created by test before call to anyfail. * Remove the directories. */ if (unlink(setgid_A) < 0) tst_resm(TWARN | TERRNO, "unlink(%s) failed", setgid_A); if (unlink(nosetgid_A) < 0) tst_resm(TWARN | TERRNO, "unlink(%s) failed", nosetgid_A); if (rmdir(DIR_A) < 0) tst_resm(TWARN | TERRNO, "rmdir(%s) failed", DIR_A); if (unlink(setgid_B) < 0) tst_resm(TWARN | TERRNO, "unlink(%s) failed", setgid_B); if (unlink(root_setgid_B) < 0) tst_resm(TWARN | TERRNO, "unlink(%s) failed", root_setgid_B); if (unlink(nosetgid_B) < 0) tst_resm(TWARN | TERRNO, "unlink(%s) failed", nosetgid_B); if (rmdir(DIR_B) < 0) tst_resm(TWARN | TERRNO, "rmdir(%s) failed", DIR_B); if (fail_count == 0) { tst_resm(TPASS, "Test passed."); } else { tst_resm(TFAIL, "Test failed because of above failures."); } } cleanup(); tst_exit(); }
int main(int ac, char **av) { int lc; /* loop counter */ const char *msg; /* message returned from parse_opts */ long tret; /*************************************************************** * parse standard options ***************************************************************/ if ( (msg=parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *) NULL ) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); tst_exit(0); } /*************************************************************** * perform global setup for test ***************************************************************/ setup(); /*************************************************************** * check looping state if -c option given ***************************************************************/ for (lc=0; TEST_LOOPING(lc); lc++) { /* reset Tst_count in case we are looping. */ Tst_count=0; /* * TEST CASE: * Increase by 8192 bytes */ Increment = 8192; /* Call sbrk(2) */ #if defined(sgi) tret=(long)sbrk(Increment); /* Remove -64 IRIX compiler warning */ TEST_ERRNO=errno; #else TEST(sbrk(Increment)); tret=TEST_RETURN; #endif /* check return code */ if ( tret == -1 ) { TEST_ERROR_LOG(TEST_ERRNO); tst_resm(TFAIL, "sbrk - Increase by 8192 bytes failed, errno=%d : %s", TEST_ERRNO, strerror(TEST_ERRNO)); } else { /*************************************************************** * only perform functional verification if flag set (-f not given) ***************************************************************/ if ( STD_FUNCTIONAL_TEST ) { /* No Verification test, yet... */ tst_resm(TPASS, "sbrk - Increase by 8192 bytes returned %d", tret); } } /* * TEST CASE: * Decrease to original size */ Increment=(Increment * -1); /* Call sbrk(2) */ #ifdef CRAY TEST(sbrk(Increment)); tret=TEST_RETURN; #else tret=(long)sbrk(Increment); TEST_ERRNO=errno; #endif /* check return code */ if ( tret == -1 ) { TEST_ERROR_LOG(TEST_ERRNO); tst_resm(TFAIL, "sbrk - Decrease to original size failed, errno=%d : %s", TEST_ERRNO, strerror(TEST_ERRNO)); } else { /*************************************************************** * only perform functional verification if flag set (-f not given) ***************************************************************/ if ( STD_FUNCTIONAL_TEST ) { /* No Verification test, yet... */ tst_resm(TPASS, "sbrk - Decrease to original size returned %d", tret); } } } /* End for TEST_LOOPING */ /*************************************************************** * cleanup and exit ***************************************************************/ cleanup(); return 0; } /* End main */
void BitVector_Test::Test_bitVectorSetAndClearBits() { BitVector<256>* bits; bits = setup(); assertUnchanged(0,7); bits->ClearBits(0,64); assertUnchanged(2,7); assert(bits->Read(0,32) == 0); assert(bits->Read(32,32) == 0); bits->SetBits(48,64); // hits 1,2,3 assert(bits->Read(0,32) == 0); assert(bits->Read(32,32) == 0x0000ffff); assert(bits->Read(64,32) == 0xffffffff); assert(bits->Read(96,32) == 0xffffdef0); bits = setup(); bits->ClearBits(31,33); // 0,1; unaligned start, aligned end assert(bits->Read(0,32) == 0x24681356); assert(bits->Read(32,32) == 0x0); assertUnchanged(2,7); bits = setup(); bits->ClearBits(128,32+32+32+1); // 4-7; aligned start, unaligned end assertUnchanged(0,3); assert(bits->Read(128,32) == 0x0); assert(bits->Read(160,32) == 0x0); assert(bits->Read(192,32) == 0x0); assert(bits->Read(224,32) == 0x7edbca09); bits = setup(); bits->SetBits(128,32+32+32+32); // 4-6; aligned start, aligned end assertUnchanged(0,3); assert(bits->Read(128,32) == 0xffffffff); assert(bits->Read(160,32) == 0xffffffff); assert(bits->Read(192,32) == 0xffffffff); assertUnchanged(7,7); bits = setup(); bits->SetBits(100,48); // 3-4; unaligned start, unaligned end, adjacent assertUnchanged(0,2); assert(bits->Read( 96,32) == 0x9fffffff); assert(bits->Read(128,32) == 0xfffffba9); assertUnchanged(5,7); bits = setup(); bits->ClearBits(4,48); // 0-1; unaligned start&end, adjacent, first unit assert(bits->Read( 0,32) == 0x20000000); assert(bits->Read( 32,32) == 0x00000314); assertUnchanged(2,7); bits = setup(); bits->ClearBits(192+16,32); // 6-7; unaligned start&end, adjacent, last unit assertUnchanged(0,5); assert(bits->Read(192,32) == 0x44330000); assert(bits->Read(224,32) == 0x0000ca09); bits = setup(); bits->ClearBits(32+16,32*5); // 1-6; unaligned start&end, non-adjacent assertUnchanged(0,0); assert(bits->Read( 32,32) == 0x11120000); assert(bits->Read( 64,32) == 0x00000000); assert(bits->Read( 96,32) == 0x00000000); assert(bits->Read(128,32) == 0x00000000); assert(bits->Read(160,32) == 0x00000000); assert(bits->Read(192,32) == 0x00002211); assertUnchanged(7,7); bits = setup(); bits->ClearBits(16,32*7); // 0-7; unaligned start&end, all units assert(bits->Read( 0,32) == 0x24680000); assert(bits->Read( 32,32) == 0x00000000); assert(bits->Read( 64,32) == 0x00000000); assert(bits->Read( 96,32) == 0x00000000); assert(bits->Read(128,32) == 0x00000000); assert(bits->Read(160,32) == 0x00000000); assert(bits->Read(192,32) == 0x00000000); assert(bits->Read(224,32) == 0x0000ca09); bits = setup(); bits->ClearBits(0,32*8); // 0-7; all bits cleared for (u32 i = 0; i < 32*8; i += 32) assert(bits->Read(i,32) == 0x00000000); bits->SetBits(0,32*8); // 0-7; all bits set for (u32 i = 0; i < 32*8; i += 32) assert(bits->Read(i,32) == 0xffffffff); }
int main(int ac, char **av) { pid_t pid1; int lc; /* loop counter */ char *msg; /* message TEST_RETURNurned from parse_opts */ /* parse standard options */ if ((msg = parse_opts(ac, av, (option_t *)NULL, NULL)) != (char *)NULL){ tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg); tst_exit(); } setup(); /* Check looping state if -i option given */ for (lc = 0; TEST_LOOPING(lc); ++lc) { Tst_count = 0; for (testno = 0; testno < TST_TOTAL; ++testno) { /* *fork a child process;testing which one is a child or a parent; * */ TEST(pid1=fork()); //call to fork() if (TEST_RETURN == -1) { tst_resm(TFAIL|TTERRNO, "fork() failed."); cleanup(); tst_exit(); } else if (TEST_RETURN == 0) { TEST_RETURN = unshare(CLONE_FS); if (TEST_RETURN == 0) tst_resm(TPASS, "unshare with CLONE_FILES call " "succeeded"); else if (TEST_RETURN == -1) { if (errno == ENOSYS) tst_resm(TCONF, "unshare is not " "implemented in kernel." ); else tst_resm(TFAIL|TERRNO, "unshare failed."); } tst_exit(); }else{ } TEST(pid1=fork()); //call to fork() if (TEST_RETURN == -1) { tst_resm(TFAIL|TTERRNO, "fork() failed."); cleanup(); tst_exit(); } else if (TEST_RETURN == 0) { TEST_RETURN = unshare(CLONE_FS); if (TEST_RETURN == 0) tst_resm(TPASS, "unshare with CLONE_FS call " "succeeded"); else if (TEST_RETURN == -1) { if (errno == ENOSYS) tst_resm(TCONF, "unshare is not " "implemented in kernel." ); else tst_resm(TFAIL|TERRNO, "unshare failed 2."); } tst_exit(); }else{ } TEST(pid1=fork()); //call to fork() if (TEST_RETURN == -1) { tst_resm(TFAIL|TTERRNO, "fork() failed."); cleanup(); tst_exit(); } else if (TEST_RETURN == 0) { TEST_RETURN = unshare(CLONE_NEWNS); if (TEST_RETURN == 0) { tst_resm(TPASS, "unshare call with CLONE_NEWNS " "succeeded"); } else if (TEST_RETURN == -1) { if (errno == ENOSYS) tst_resm(TCONF, "unshare is not " "implemented in kernel." ); else tst_resm(TFAIL|TERRNO, "unshare failed 2."); } tst_exit(); }else{ } } } cleanup(); tst_exit(); }
void BitVector_Test::Test_bitVectorAllocate() { BitVector<256>* bits = setup(); assert(bits->Read(0, 32) == 0x24681357); }
int test_setup() { setup(); }
/* MotionManager::MotionManager: constructor */ MotionManager::MotionManager(PMDModel * pmd) { initialize(); setup(pmd); }
// Pawn attacks. void test_position_targets_suite__040(void) { setup("Ke1,a3,b3,c3,d3,e3,f3,g3,h3", "Ke8,a6,b6,c6,d6,e6,f6,g6,h6"); Position *p = start(); cl_check(pawn_attacks(p, White) == (bit[A4] | bit[B4] | bit[C4] | bit[D4] | bit[E4] | bit[F4] | bit[G4] | bit[H4])); cl_check(pawn_attacks(p, Black) == (bit[A5] | bit[B5] | bit[C5] | bit[D5] | bit[E5] | bit[F5] | bit[G5] | bit[H5])); }
AIMGRAPH::AIMGRAPH () { for (int i = 0; i < AIM_SIZE; ++i) p[i] = P_MAX / 2; father[ROOT] = ROOT; setup (BIND < AIM, int >()(10, ROOT, HIS_CLUSTER, HIS_MASS, HIS_POTENTIAL, PUBLICAREA, MY_CLUSTER, MY_MASS, MY_POTENTIAL, COMPLICATE, SIMPLIFY)); setup (BIND < AIM, int >()(5, HIS_CLUSTER, GE, FENG, GAN, SHA)); setup (BIND < AIM, int >()(3, SHA, POYAN, SUOYANWEI)); setup (BIND < AIM, int >()(3, HIS_MASS, _ZHENGXING, CHIZI)); setup (BIND < AIM, int >()(8, CHIZI, DA, JIA, GUN, JIEBUGUI, DAOPU, ZHENGZI, DAOTUOXUE)); setup (BIND < AIM, int >()(6, HIS_POTENTIAL, QINGXIAO, BI, SHENGTUI, QINSHI, DARU)); setup (BIND < AIM, int >()(2, PUBLICAREA, ZHANDACHANG)); setup (BIND < AIM, int >()(5, MY_CLUSTER, _GE, TUWEI, SHENGGEN, ZUOHUO)); setup (BIND < AIM, int >()(3, ZUOHUO, ZUOYAN, KUOYANWEI)); setup (BIND < AIM, int >()(3, MY_MASS, ZHENGXING, JIUZI)); setup (BIND < AIM, int >()(8, JIUZI, _DA, _JIA, _GUN, _JIEBUGUI, _DAOPU, _ZHENGZI, _DAOTUOXUE)); setup (BIND < AIM, int >()(6, MY_POTENTIAL, KUOZHANG, CHAI, _SHENGTUI, _QINSHI, _DARU)); setup (BIND < AIM, int >()(1, ZHIGAODIAN)); setup (BIND < AIM, int >()(9, COMPLICATE, TENNUO, JIAO, YUWEI, SHIYINGSHOU, ZUOJIE, XUNJIE, CHANGSHENG, DUISHA)); setup (BIND < AIM, int >()(5, SIMPLIFY, DINGXING, LIYONG, ZHENGXIAN, DAJIANG)); }
int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ int advise; /* Check this system has fadvise64 system which is used in posix_fadvise. */ if ((_FILE_OFFSET_BITS != 64) && (__NR_fadvise64 == 0)) { tst_resm(TWARN, "This test can only run on kernels that implements "); tst_resm(TWARN, "fadvise64 which is used from posix_fadvise"); exit(0); } /* * parse standard options */ if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); /* * perform global setup for test */ setup(); /* * check looping state if -i option given on the command line */ for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; /* loop through the test cases */ for (advise = 0; advise < advise_limit; advise++) { /* Don't use defiend advise as an argument. */ if (is_defined_advise(advise)) { continue; } TEST(posix_fadvise(fd, 0, 0, advise)); if (TEST_RETURN == 0) { tst_resm(TFAIL, "call succeeded unexpectedly"); continue; } /* Man page says: "On error, an error number is returned." */ if (TEST_RETURN == expected_error) { tst_resm(TPASS, "expected failure - " "returned value = %ld, advise = %d : %s", TEST_RETURN, advise, strerror(TEST_RETURN)); } else { tst_resm(TFAIL, "unexpected return value - %ld : %s, advise %d - " "expected %d", TEST_RETURN, strerror(TEST_RETURN), advise, expected_error); } } } /* * cleanup and exit */ cleanup(); tst_exit(); }
SHomography::SHomography(SAttachedPoint *a=0, SAttachedPoint *b=0, SAttachedPoint *c=0, SAttachedPoint *d=0) { for (int i=0; i<4; i++) pts[i]=0; setup(a,b,c,d); }
GameSpyServer::GameSpyServer(const char *host, int port) { setup(host, port); }
int main(int ac, char **av) { int lc; char *msg; int i, red, wtstatus; int pipefd[2]; /* fds for pipe read/write */ char rebuf[BUFSIZ]; int Acnt = 0, Bcnt = 0; /* count 'A' and 'B' */ int fork_1, fork_2; /* ret values in parent */ if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { /* reset Tst_count in case we are looping */ Tst_count = 0; TEST(pipe(pipefd)); if (TEST_RETURN == -1) { tst_resm(TFAIL, "pipe() call failed"); continue; } if (!STD_FUNCTIONAL_TEST) { tst_resm(TWARN, "-f option should not be used"); tst_resm(TPASS, "call succeeded"); continue; } if ((fork_1 = FORK_OR_VFORK()) == -1) { tst_brkm(TBROK, cleanup, "fork() #1 failed"); } if (fork_1 == 0) { /* 1st child */ if (close(pipefd[0]) != 0) { tst_resm(TWARN, "pipefd[0] close failed, " "errno = %d", errno); exit(1); } for (i = 0; i < PIPEWRTCNT / 2; ++i) { if (write(pipefd[1], "A", 1) != 1) { tst_resm(TWARN, "write to pipe failed"); exit(1); } } exit(0); } /* parent */ if (waitpid(fork_1, &wtstatus, 0) == -1) tst_brkm(TBROK, cleanup, "waitpid failed"); if (WIFEXITED(wtstatus) && WEXITSTATUS(wtstatus) != 0) { tst_brkm(TBROK, cleanup, "child exited abnormally"); } if ((fork_2 = FORK_OR_VFORK()) == -1) { tst_brkm(TBROK, cleanup, "fork() #2 failed"); } if (fork_2 == 0) { /* 2nd child */ if (close(pipefd[0]) != 0) { perror("pipefd[0] close failed"); exit(1); } for (i = 0; i < PIPEWRTCNT / 2; ++i) { if (write(pipefd[1], "B", 1) != 1) { perror("write to pipe failed"); exit(1); } } exit(0); } /* parent */ if (waitpid(fork_2, &wtstatus, 0) == -1) tst_brkm(TBROK, cleanup, "waitpid failed"); if (WEXITSTATUS(wtstatus) != 0) { tst_brkm(TBROK, cleanup, "problem detected in child, " "wait status %d, errno = %d", wtstatus, errno); } if (close(pipefd[1]) != 0) { tst_brkm(TBROK|TERRNO, cleanup, "pipefd[1] close failed"); } while ((red = safe_read(pipefd[0], rebuf, 100)) > 0) { for (i = 0; i < red; i++) { if (rebuf[i] == 'A') { Acnt++; continue; } if (rebuf[i] == 'B') { Bcnt++; continue; } tst_resm(TFAIL, "got bogus '%c' character", rebuf[i]); break; } } if (red == -1) { tst_brkm(TBROK|TERRNO, cleanup, "reading pipefd pipe failed"); } if (Bcnt == Acnt && Bcnt == (PIPEWRTCNT / 2)) { tst_resm(TPASS, "functionality appears to be correct"); } else { tst_resm(TFAIL, "functionality is not correct - Acnt " "= %d, Bcnt = %d", Acnt, Bcnt); } /* clean up things in case we are looping */ Acnt = Bcnt = 0; } cleanup(); tst_exit(); }
int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ char file_content; /* tempfile content */ if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; /* * Call mmap to map the temporary file 'TEMPFILE' * with no access. */ errno = 0; addr = mmap(0, page_sz, PROT_NONE, MAP_FILE | MAP_SHARED, fildes, 0); TEST_ERRNO = errno; /* Check for the return value of mmap() */ if (addr == MAP_FAILED) { tst_resm(TFAIL|TERRNO, "mmap() failed on %s", TEMPFILE); continue; } /* * Perform functional verification if test * executed without (-f) option. */ if (STD_FUNCTIONAL_TEST) { /* * Try to access the mapped region. This should * generate a SIGSEGV which will be caught below. * * This is wrapped by the sigsetjmp() call that will * take care of restoring the program's context in an * elegant way in conjunction with the call to * siglongjmp() in the signal handler. */ if (sigsetjmp(env, 1) == 0) { file_content = addr[0]; } if (pass) { tst_resm(TPASS, "Got SIGSEGV as expected"); } else { tst_resm(TFAIL, "Mapped memory region with NO " "access is accessible"); } } else { tst_resm(TPASS, "call succeeded"); } /* Unmap mapped memory and reset pass in case we are looping */ if (munmap((void *)addr, page_sz) != 0) { tst_brkm(TFAIL|TERRNO, cleanup, "munmap failed"); } pass = 0; } cleanup(); tst_exit(); }
ofxGuiGroup * ofxGuiGroup::setup(string collectionName, string filename, float x, float y){ parameters.setName(collectionName); return setup(parameters,filename,x,y); }
int main(int ac, char **av) { int lc; char *msg; pid_t my_pid; /* test process id */ msg = parse_opts(ac, av, NULL, NULL); if (msg != NULL) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); /*NOTREACED*/} setup(); /* set the expected errnos... */ TEST_EXP_ENOS(exp_enos); for (lc = 0; TEST_LOOPING(lc); lc++) { tst_count = 0; /* * Call sigprocmask() to block (SIGINT) signal * so that, signal will not be delivered to * the test process. */ TEST(sigprocmask(SIG_BLOCK, &sigset, 0)); /* Get the process id of test process */ my_pid = getpid(); /* Send SIGINT signal to the process */ kill(my_pid, SIGINT); if (TEST_RETURN == -1) { TEST_ERROR_LOG(TEST_ERRNO); tst_resm(TFAIL, "sigprocmask() Failed, errno=%d : %s", TEST_ERRNO, strerror(TEST_ERRNO)); } else { /* * Perform functional verification if test * executed without (-f) option. */ if (STD_FUNCTIONAL_TEST) { /* * Check whether process received the signal. * If yes! signal handler was executed and * incremented 'sig_catch' variable. */ if (sig_catch) { tst_resm(TFAIL, "sigprocmask fails to " "change process's signal mask"); } else { /* * Check whether specified signal * 'SIGINT' is pending for the process. */ errno = 0; if (sigpending(&sigset2) == -1) { tst_brkm(TFAIL, cleanup, "blocked signal not " "in pending state, " "error:%d", errno); } /* * Check whether specified signal * is the member of signal set. */ errno = 0; if (!sigismember(&sigset2, SIGINT)) { tst_brkm(TFAIL, cleanup, "sigismember() failed, " "error:%d", errno); } /* * Invoke sigprocmask() again to * unblock the specified signal. * so that, signal is delivered and * signal handler executed. */ errno = 0; if (sigprocmask(SIG_UNBLOCK, &sigset, 0) == -1) { tst_brkm(TFAIL, cleanup, "sigprocmask() failed " "to unblock signal, " "error=%d", errno); } if (sig_catch) { tst_resm(TPASS, "Functionality " "of sigprocmask() " "Successful"); } else { tst_resm(TFAIL, "Functionality " "of sigprocmask() " "Failed"); } /* set sig_catch back to 0 */ sig_catch = 0; } } else { tst_resm(TPASS, "Call succeeded"); } } tst_count++; /* incr TEST_LOOP counter */ } cleanup(); tst_exit(); }