int main() { printf("#Test start: success cases' outputs\n"); printf("#should output 'PASS: message A'\n"); testrun("message A", t1); printf("#Test end: success cases' outputs\n"); printf("#Test start: failure cases' outputs\n"); printf("#should output 'FAIL: message A'\n"); testrun("message A", t2); printf("#Test end: failure cases' outputs\n"); printf("#Test start: failure cases' outputs(assertion)\n"); printf("#should output like below\n"); printf("#'FAIL: message A'\n"); printf("#'DETAIL: error1'\n"); testrun("message A", t3); printf("#Test end: failure cases' outputs(assertion)\n"); printf("#Test start: multiple testerror calls\n"); printf("#should output like below\n"); printf("#'FAIL: message A'\n"); printf("#'DETAIL: error1'\n"); printf("#'DETAIL: error2'\n"); testrun("message A", t4); printf("#Test end: multiple testerror calls\n"); }
int main(void) { if (TESTING) { return testrun(); } int status = run_game(); if (!status) { printf("Program exitted with error code %d\n", status); } printf("End of program\n"); return 0; }
int main() { testrun("address", tint); testrun("trap gate", tattrtrap); testrun("interrupt gate", tattrintr); testrun("segment selector", tssel); testrun("invalidate", invalidate); testrun("validate", validate); return 0; }
static int fork_testrun(void) { int status; if (tst_test->timeout) tst_set_timeout(tst_test->timeout); else tst_set_timeout(300); SAFE_SIGNAL(SIGINT, sigint_handler); test_pid = fork(); if (test_pid < 0) tst_brk(TBROK | TERRNO, "fork()"); if (!test_pid) { SAFE_SIGNAL(SIGALRM, SIG_DFL); SAFE_SIGNAL(SIGUSR1, SIG_DFL); SAFE_SIGNAL(SIGINT, SIG_DFL); SAFE_SETPGID(0, 0); testrun(); } SAFE_WAITPID(test_pid, &status, 0); alarm(0); SAFE_SIGNAL(SIGINT, SIG_DFL); if (WIFEXITED(status) && WEXITSTATUS(status)) return WEXITSTATUS(status); if (WIFSIGNALED(status) && WTERMSIG(status) == SIGKILL) { tst_res(TINFO, "If you are running on slow machine, " "try exporting LTP_TIMEOUT_MUL > 1"); tst_brk(TBROK, "Test killed! (timeout?)"); } if (WIFSIGNALED(status)) tst_brk(TBROK, "Test killed by %s!", tst_strsig(WTERMSIG(status))); return 0; }
int main(/*@unused@*/ int argc, /*@unused@*/ char **argv) { SCARDHANDLE hCard; SCARDCONTEXT hContext; SCARD_READERSTATE_A rgReaderStates[1]; DWORD dwReaderLen, dwState, dwProt, dwAtrLen; DWORD dwPref, dwReaders = 0; char *pcReaders = NULL, *mszReaders; #ifdef USE_AUTOALLOCATE unsigned char *pbAtr = NULL; #else unsigned char pbAtr[MAX_ATR_SIZE]; #endif union { unsigned char as_char[100]; DWORD as_DWORD; uint32_t as_uint32_t; } buf; DWORD dwBufLen; unsigned char *pbAttr = NULL; DWORD pcbAttrLen; char *mszGroups; DWORD dwGroups = 0; long rv; DWORD i; int p, iReader; int iList[16]; SCARD_IO_REQUEST pioRecvPci; SCARD_IO_REQUEST pioSendPci; unsigned char bSendBuffer[MAX_BUFFER_SIZE]; unsigned char bRecvBuffer[MAX_BUFFER_SIZE]; DWORD send_length, length; (void)argc; (void)argv; printf("\nMUSCLE PC/SC Lite unitary test Program\n\n"); printf(MAGENTA "THIS PROGRAM IS NOT DESIGNED AS A TESTING TOOL FOR END USERS!\n"); printf("Do NOT use it unless you really know what you do.\n\n" NORMAL); printf("Testing SCardEstablishContext\t: "); rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext); test_rv(rv, hContext, PANIC); printf("Testing SCardIsValidContext\t: "); rv = SCardIsValidContext(hContext); test_rv(rv, hContext, PANIC); printf("Testing SCardIsValidContext\t: "); rv = SCardIsValidContext(hContext+1); test_rv(rv, hContext, DONT_PANIC); printf("Testing SCardListReaderGroups\t: "); #ifdef USE_AUTOALLOCATE dwGroups = SCARD_AUTOALLOCATE; rv = SCardListReaderGroups(hContext, (LPSTR)&mszGroups, &dwGroups); #else rv = SCardListReaderGroups(hContext, NULL, &dwGroups); test_rv(rv, hContext, PANIC); printf("Testing SCardListReaderGroups\t: "); mszGroups = calloc(dwGroups, sizeof(char)); rv = SCardListReaderGroups(hContext, mszGroups, &dwGroups); #endif test_rv(rv, hContext, PANIC); /* * Have to understand the multi-string here */ p = 0; for (i = 0; i+1 < dwGroups; i++) { ++p; printf(GREEN "Group %02d: %s\n" NORMAL, p, &mszGroups[i]); while (mszGroups[++i] != 0) ; } #ifdef USE_AUTOALLOCATE printf("Testing SCardFreeMemory\t\t: "); rv = SCardFreeMemory(hContext, mszGroups); test_rv(rv, hContext, PANIC); #else free(mszGroups); #endif wait_for_card_again: mszGroups = NULL; printf("Testing SCardListReaders\t: "); rv = SCardListReaders(hContext, mszGroups, NULL, &dwReaders); test_rv(rv, hContext, DONT_PANIC); if (SCARD_E_NO_READERS_AVAILABLE == rv) { printf("Testing SCardGetStatusChange \n"); printf("Please insert a working reader\t: "); (void)fflush(stdout); rgReaderStates[0].szReader = "\\\\?PnP?\\Notification"; rgReaderStates[0].dwCurrentState = SCARD_STATE_EMPTY; rv = SCardGetStatusChange(hContext, INFINITE, rgReaderStates, 1); test_rv(rv, hContext, PANIC); } printf("Testing SCardListReaders\t: "); #ifdef USE_AUTOALLOCATE dwReaders = SCARD_AUTOALLOCATE; rv = SCardListReaders(hContext, mszGroups, (LPSTR)&mszReaders, &dwReaders); #else rv = SCardListReaders(hContext, mszGroups, NULL, &dwReaders); test_rv(rv, hContext, PANIC); printf("Testing SCardListReaders\t: "); mszReaders = calloc(dwReaders, sizeof(char)); rv = SCardListReaders(hContext, mszGroups, mszReaders, &dwReaders); #endif test_rv(rv, hContext, DONT_PANIC); /* * Have to understand the multi-string here */ p = 0; for (i = 0; i+1 < dwReaders; i++) { ++p; printf(GREEN "Reader %02d: %s\n" NORMAL, p, &mszReaders[i]); iList[p] = i; while (mszReaders[++i] != 0) ; } if (p > 1) do { char input[80]; printf("Enter the reader number\t\t: "); (void)fgets(input, sizeof(input), stdin); (void)sscanf(input, "%d", &iReader); if (iReader > p || iReader <= 0) printf("Invalid Value - try again\n"); } while (iReader > p || iReader <= 0); else iReader = 1; rgReaderStates[0].szReader = &mszReaders[iList[iReader]]; rgReaderStates[0].dwCurrentState = SCARD_STATE_EMPTY; printf("Waiting for card insertion\t: "); (void)fflush(stdout); rv = SCardGetStatusChange(hContext, INFINITE, rgReaderStates, 1); test_rv(rv, hContext, PANIC); if (rgReaderStates[0].dwEventState & SCARD_STATE_UNKNOWN) { printf("\nA reader has been connected/disconnected\n"); goto wait_for_card_again; } printf("Testing SCardConnect\t\t: "); rv = SCardConnect(hContext, &mszReaders[iList[iReader]], SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &hCard, &dwPref); test_rv(rv, hContext, PANIC); switch(dwPref) { case SCARD_PROTOCOL_T0: pioSendPci = *SCARD_PCI_T0; break; case SCARD_PROTOCOL_T1: pioSendPci = *SCARD_PCI_T1; break; case SCARD_PROTOCOL_RAW: pioSendPci = *SCARD_PCI_RAW; break; default: printf("Unknown protocol\n"); return -1; } int bBreak = 0; while (1) { char inputCommand[1024]; char inputAPDU[1024]; int inputAPDULen = sizeof(inputAPDU); printf("Enter APDU to send, (e.g. 00:A4:04:00:00)\n"); printf("Command APDU: "); (void)fgets(inputCommand, sizeof(inputCommand), stdin); int stringlen = strlen(inputCommand); if( inputCommand[stringlen-1] == '\n' ) { inputCommand[stringlen-1] = 0; } //remove newline int bError = sc_hex_to_bin(inputCommand, inputAPDU, &inputAPDULen); //printf("debug - value bError: %i\n",bError); if (bError) { printf("Error parsing input\n\n"); continue; } send_length = inputAPDULen; if (inputAPDULen == 0) { break; } printf("debug inputAPDULen: %i\n",inputAPDULen); memcpy(bSendBuffer, inputAPDU, send_length); length = sizeof(bRecvBuffer); printf("Testing SCardTransmit:\n "); printf("-> "); for (i=0; i<send_length; i++) { printf(" %02X", bSendBuffer[i]); } printf("\n"); rv = SCardTransmit(hCard, &pioSendPci, bSendBuffer, send_length, &pioRecvPci, bRecvBuffer, &length); test_rv(rv, hContext, PANIC); printf("<- " GREEN); for (i=0; i<length; i++) printf(" %02X", bRecvBuffer[i]); printf("\n" NORMAL); } testrun(&hCard, &hContext, &pioSendPci, 0); testrun(&hCard, &hContext, &pioSendPci, 1); testrun(&hCard, &hContext, &pioSendPci, 2); testrun(&hCard, &hContext, &pioSendPci, 3); printf("Testing SCardControl\t\t: "); #ifdef PCSC_PRE_120 { char buffer[1024] = "Foobar"; DWORD cbRecvLength = sizeof(buffer); rv = SCardControl(hCard, buffer, 7, buffer, &cbRecvLength); } #else { char buffer[1024] = { 0x02 }; DWORD cbRecvLength = sizeof(buffer); rv = SCardControl(hCard, SCARD_CTL_CODE(1), buffer, 1, buffer, sizeof(buffer), &cbRecvLength); if (cbRecvLength && (SCARD_S_SUCCESS == rv)) { for (i=0; i<cbRecvLength; i++) printf("%c", buffer[i]); printf(" "); } } #endif test_rv(rv, hContext, DONT_PANIC); printf("Testing SCardGetAttrib\t\t: "); #ifdef USE_AUTOALLOCATE pcbAttrLen = SCARD_AUTOALLOCATE; rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, (unsigned char *)&pbAttr, &pcbAttrLen); #else rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, NULL, &pcbAttrLen); test_rv(rv, hContext, DONT_PANIC); if (rv == SCARD_S_SUCCESS) { printf("SCARD_ATTR_DEVICE_FRIENDLY_NAME length: " GREEN "%ld\n" NORMAL, pcbAttrLen); pbAttr = malloc(pcbAttrLen); } printf("Testing SCardGetAttrib\t\t: "); rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, pbAttr, &pcbAttrLen); #endif test_rv(rv, hContext, DONT_PANIC); if (rv == SCARD_S_SUCCESS) printf("SCARD_ATTR_DEVICE_FRIENDLY_NAME: " GREEN "%s\n" NORMAL, pbAttr); #ifdef USE_AUTOALLOCATE printf("Testing SCardFreeMemory\t\t: "); rv = SCardFreeMemory(hContext, pbAttr); test_rv(rv, hContext, PANIC); #else if (pbAttr) free(pbAttr); #endif printf("Testing SCardGetAttrib\t\t: "); #ifdef USE_AUTOALLOCATE pcbAttrLen = SCARD_AUTOALLOCATE; rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, (unsigned char *)&pbAttr, &pcbAttrLen); #else rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, NULL, &pcbAttrLen); test_rv(rv, hContext, DONT_PANIC); if (rv == SCARD_S_SUCCESS) { printf("SCARD_ATTR_ATR_STRING length: " GREEN "%ld\n" NORMAL, pcbAttrLen); pbAttr = malloc(pcbAttrLen); } printf("Testing SCardGetAttrib\t\t: "); rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, pbAttr, &pcbAttrLen); #endif test_rv(rv, hContext, DONT_PANIC); if (rv == SCARD_S_SUCCESS) { printf("SCARD_ATTR_ATR_STRING length: " GREEN "%ld\n" NORMAL, pcbAttrLen); printf("SCARD_ATTR_ATR_STRING: " GREEN); for (i = 0; i < pcbAttrLen; i++) printf("%02X ", pbAttr[i]); printf("\n" NORMAL); } #ifdef USE_AUTOALLOCATE printf("Testing SCardFreeMemory\t\t: "); rv = SCardFreeMemory(hContext, pbAttr); test_rv(rv, hContext, PANIC); #else if (pbAttr) free(pbAttr); #endif printf("Testing SCardGetAttrib\t\t: "); dwBufLen = sizeof(buf); rv = SCardGetAttrib(hCard, SCARD_ATTR_VENDOR_IFD_VERSION, buf.as_char, &dwBufLen); test_rv(rv, hContext, DONT_PANIC); if (rv == SCARD_S_SUCCESS) printf("Vendor IFD version\t\t: " GREEN "0x%08lX\n" NORMAL, buf.as_DWORD); printf("Testing SCardGetAttrib\t\t: "); dwBufLen = sizeof(buf); rv = SCardGetAttrib(hCard, SCARD_ATTR_MAXINPUT, buf.as_char, &dwBufLen); test_rv(rv, hContext, DONT_PANIC); if (rv == SCARD_S_SUCCESS) { if (dwBufLen == sizeof(uint32_t)) printf("Max message length\t\t: " GREEN "%d\n" NORMAL, buf.as_uint32_t); else printf(RED "Wrong size" NORMAL); } printf("Testing SCardGetAttrib\t\t: "); dwBufLen = sizeof(buf); rv = SCardGetAttrib(hCard, SCARD_ATTR_VENDOR_NAME, buf.as_char, &dwBufLen); test_rv(rv, hContext, DONT_PANIC); if (rv == SCARD_S_SUCCESS) printf("Vendor name\t\t\t: " GREEN "%s\n" NORMAL, buf.as_char); printf("Testing SCardSetAttrib\t\t: "); rv = SCardSetAttrib(hCard, SCARD_ATTR_ATR_STRING, (LPCBYTE)"", 1); test_rv(rv, hContext, DONT_PANIC); printf("Testing SCardStatus\t\t: "); #ifdef USE_AUTOALLOCATE dwReaderLen = SCARD_AUTOALLOCATE; dwAtrLen = SCARD_AUTOALLOCATE; rv = SCardStatus(hCard, (LPSTR)&pcReaders, &dwReaderLen, &dwState, &dwProt, (LPBYTE)&pbAtr, &dwAtrLen); #else dwReaderLen = 100; pcReaders = malloc(sizeof(char) * 100); dwAtrLen = MAX_ATR_SIZE; rv = SCardStatus(hCard, pcReaders, &dwReaderLen, &dwState, &dwProt, pbAtr, &dwAtrLen); #endif test_rv(rv, hContext, PANIC); printf("Current Reader Name\t\t: " GREEN "%s\n" NORMAL, pcReaders); printf("Current Reader State\t\t: " GREEN "0x%.4lx\n" NORMAL, dwState); printf("Current Reader Protocol\t\t: T=" GREEN "%ld\n" NORMAL, dwProt - 1); printf("Current Reader ATR Size\t\t: " GREEN "%ld" NORMAL " bytes\n", dwAtrLen); printf("Current Reader ATR Value\t: " GREEN); for (i = 0; i < dwAtrLen; i++) { printf("%02X ", pbAtr[i]); } printf(NORMAL "\n"); #ifdef USE_AUTOALLOCATE printf("Testing SCardFreeMemory\t\t: "); rv = SCardFreeMemory(hContext, pcReaders); test_rv(rv, hContext, PANIC); printf("Testing SCardFreeMemory\t\t: "); rv = SCardFreeMemory(hContext, pbAtr); test_rv(rv, hContext, PANIC); #else if (pcReaders) free(pcReaders); #endif if (rv != SCARD_S_SUCCESS) { (void)SCardDisconnect(hCard, SCARD_RESET_CARD); (void)SCardReleaseContext(hContext); } printf("Press enter: "); (void)getchar(); printf("Testing SCardReconnect\t\t: "); rv = SCardReconnect(hCard, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, SCARD_UNPOWER_CARD, &dwPref); test_rv(rv, hContext, PANIC); printf("Testing SCardDisconnect\t\t: "); rv = SCardDisconnect(hCard, SCARD_UNPOWER_CARD); test_rv(rv, hContext, PANIC); #ifdef USE_AUTOALLOCATE printf("Testing SCardFreeMemory\t\t: "); rv = SCardFreeMemory(hContext, mszReaders); test_rv(rv, hContext, PANIC); #else free(mszReaders); #endif printf("Testing SCardReleaseContext\t: "); rv = SCardReleaseContext(hContext); test_rv(rv, hContext, PANIC); printf("\n"); printf("PC/SC Test Completed Successfully !\n"); return 0; }
int main(int argc, char * argv[]) { PV_Init* initObj = new PV_Init(&argc, &argv, true/*allowUnrecognizedArguments*/); // argv has to allow --generate, --testrun, etc. int rank = 0; MPI_Comm_rank(MPI_COMM_WORLD, &rank); bool generateFlag = false; // Flag for whether to generate correct output for future tests; don't check the RequireAllZeroActivity probe bool testrunFlag = false; // Flag for whether to run from params and then check the RequireAllZeroActivity probe bool testcheckpointFlag = false; // Flag for whether to run from checkpoint and then check the RequireAllZeroActivity probe bool testioparamsFlag = false; // Flag for whether to run from the output pv.params and then check the RequireAllZeroActivity probe // Run through the command line arguments. If an argument is any of // --generate // --testrun // --testcheckpoint // --testioparams // --testall // set the appropriate test flags for (int arg=0; arg<argc;arg++) { const char * thisarg = argv[arg]; if (!strcmp(thisarg, "--generate")) { generateFlag = true; } else if (!strcmp(thisarg, "--testrun")) { testrunFlag = true; } else if (!strcmp(thisarg, "--testcheckpoint")) { testcheckpointFlag = true; } else if (!strcmp(thisarg, "--testioparams")) { testioparamsFlag = true; } else if (!strcmp(thisarg, "--testall")) { testrunFlag = true; testcheckpointFlag = true; testioparamsFlag = true; } else { /* nothing to do here */ } } if (generateFlag && (testrunFlag||testcheckpointFlag||testioparamsFlag)) { if (rank==0) { fprintf(stderr, "%s error: --generate option conflicts with the --test* options.\n", argv[0]); } MPI_Barrier(MPI_COMM_WORLD); // Make sure no child processes take down the MPI environment before root process prints error message. exit(EXIT_FAILURE); } if (!(generateFlag||testrunFlag||testcheckpointFlag||testioparamsFlag)) { if (rank==0) { fprintf(stderr, "%s error: At least one of \"--generate\", \"--testrun\", \"--testcheckpoint\", \"--testioparams\" must be selected.\n", argv[0]); } MPI_Barrier(MPI_COMM_WORLD); // Make sure no child processes take down the MPI environment before root process prints error message. exit(EXIT_FAILURE); } assert(generateFlag||testrunFlag||testcheckpointFlag||testioparamsFlag); int status = PV_SUCCESS; if (status==PV_SUCCESS && generateFlag) { if (generate(initObj, rank)!=PV_SUCCESS) { status = PV_FAILURE; if (rank==0) { fprintf(stderr, "%s: generate failed.\n", initObj->getArguments()->getProgramName()); } } } if (status==PV_SUCCESS && testrunFlag) { if (testrun(initObj, rank)!=PV_SUCCESS) { status = PV_FAILURE; if (rank==0) { fprintf(stderr, "%s: testrun failed.\n", initObj->getArguments()->getProgramName()); } } } if (status==PV_SUCCESS && testcheckpointFlag) { if (testcheckpoint(initObj, rank)!=PV_SUCCESS) { status = PV_FAILURE; if (rank==0) { fprintf(stderr, "%s: testcheckpoint failed.\n", initObj->getArguments()->getProgramName()); } } } if (status==PV_SUCCESS && testioparamsFlag) { if (testioparams(initObj, rank)!=PV_SUCCESS) { status = PV_FAILURE; if (rank==0) { fprintf(stderr, "%s: testioparams failed.\n", initObj->getArguments()->getProgramName()); } } } delete initObj; return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE; }
/*********************************************************************** * MAIN ***********************************************************************/ int main(int ac, char **av) { int i; /* counter */ int ret_val; /* return value from testrun call */ int eok; /* everything is ok flag */ int lc; /* loop counter */ const char *msg; /* message returned from parse_opts */ int flag_cnt; Tst_nobuf=1; Num_flags = sizeof(Flags)/sizeof(int); TST_TOTAL= 3 * Num_flags; /*************************************************************** * parse standard options, and exit if there is an error ***************************************************************/ if ( (msg=parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *) NULL ) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); tst_exit(); } /*************************************************************** * 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; for (flag_cnt=0; flag_cnt<Num_flags; flag_cnt++) { /* * call testrun writing (BUFSIZ + 1) byte chunks */ filename=FNAME1; if( testrun(Flags[flag_cnt],BUFSIZ+1,1) != OK) tst_resm(TFAIL,ERR_MSG1); else if ( STD_FUNCTIONAL_TEST ) { tst_resm(TPASS, "More than BUFSIZE bytes multiple synchronous writes to a file check out ok"); } /* * call testrun writing BUFSIZ byte chunks */ filename=FNAME2; if(testrun(Flags[flag_cnt],BUFSIZ,2) != OK) { tst_resm(TFAIL,ERR_MSG1); } else if ( STD_FUNCTIONAL_TEST ) { tst_resm(TPASS, "BUFSIZE bytes multiple synchronous writes to a file checks out ok"); } /* * while the byte chunks are greater than 0 * call testrun() with decreasing chunk sizes */ filename=FNAME3; eok=1; for(i = BUFSIZ-1; i >= 0; i -= DECR) { if((ret_val = testrun(Flags[flag_cnt],i,3)) != OK) { char output[80]; /* local output char string */ (void)sprintf(output,ERR_MSG2,ret_val,i*WRITES); tst_resm(TFAIL,output); } } if ( eok && STD_FUNCTIONAL_TEST ) tst_resm(TPASS, "Less than BUFSIZE bytes multiple synchronous writes to a file checks out ok"); } } cleanup(); return 0; } /* end main() */
/*********************************************************************** * MAIN ***********************************************************************/ int main(int ac, char **av) { int i; int ret_val; int eok; /* everything is ok flag */ int lc; char *msg; int flag_cnt; Num_flags = sizeof(Flags) / sizeof(int); TST_TOTAL = 3 * Num_flags; 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; for (flag_cnt = 0; flag_cnt < Num_flags; flag_cnt++) { /* * call testrun writing (BUFSIZ + 1) byte chunks */ filename = FNAME1; if (testrun(Flags[flag_cnt], BUFSIZ + 1, 1) != OK) tst_resm(TFAIL, ERR_MSG1); else if (STD_FUNCTIONAL_TEST) { tst_resm(TPASS, "More than BUFSIZE bytes multiple synchronous writes to a file check out ok"); } /* * call testrun writing BUFSIZ byte chunks */ filename = FNAME2; if (testrun(Flags[flag_cnt], BUFSIZ, 2) != OK) { tst_resm(TFAIL, ERR_MSG1); } else if (STD_FUNCTIONAL_TEST) { tst_resm(TPASS, "BUFSIZE bytes multiple synchronous writes to a file checks out ok"); } /* * while the byte chunks are greater than 0 * call testrun() with decreasing chunk sizes */ filename = FNAME3; eok = 1; for (i = BUFSIZ - 1; i >= 0; i -= DECR) { if ((ret_val = testrun(Flags[flag_cnt], i, 3)) != OK) { tst_resm(TFAIL, ERR_MSG2, ret_val, i * WRITES); } } if (eok && STD_FUNCTIONAL_TEST) tst_resm(TPASS, "Less than BUFSIZE bytes multiple synchronous writes to a file checks out ok"); } } cleanup(); tst_exit(); } /* end main() */