/** * This program contains integration test for SAPI Tss2_Sys_GetRandom. * First, this test is checking the return code to make sure the * SAPI is executed correctly(return code should return TPM_RC_SUCCESS). * Second, the SAPI is called twice to make sure the return randomBytes * are different by comparing the two randomBytes through memcmp. * It might not be the best test for random bytes generator but * at least this test shows the return randomBytes are differen. */ int test_invoke (TSS2_SYS_CONTEXT *sapi_context) { TSS2_RC rc; TPM2B_DIGEST randomBytes1 = { { sizeof (TPM2B_DIGEST) - 2, } }; TPM2B_DIGEST randomBytes2 = { { sizeof (TPM2B_DIGEST) - 2, } }; int bytes = 20; print_log("GetRandom tests started."); rc = Tss2_Sys_GetRandom(sapi_context, 0, bytes, &randomBytes1, 0); if (rc != TSS2_RC_SUCCESS) print_fail("GetRandom FAILED! Response Code : %x", rc); rc = Tss2_Sys_GetRandom(sapi_context, 0, bytes, &randomBytes2, 0); if (rc != TSS2_RC_SUCCESS) print_fail("GetRandom FAILED! Response Code : %x", rc); if(memcmp(&randomBytes1, &randomBytes2, bytes) == 0) { print_fail("Comparison FAILED! randomBytes 0x%p & 0x%p are the same.", &randomBytes1, &randomBytes2); } print_log("GetRandom Test Passed!"); return 0; }
static int check_output_line(char *line) { if (strtok(line, " \n") == NULL) return -1; if (tolower(turn[0]) == 'b') { if (strtok(NULL, " \n") == NULL) return -1; } char *move = strtok(NULL, " \n"); if (move == NULL) return -1; if (best_move_count > 0) { for (unsigned i = 0; i < best_move_count; ++i) { if (strcmp(move, best_moves[i]) == 0) { print_success(move); return 0; } } print_fail(move); } else if (avoid_move_count > 0) { for (unsigned i = 0; i < avoid_move_count; ++i) { if (strcmp(move, avoid_moves[i]) == 0) { print_fail(move); return 0; } } print_success(move); } else { print_success(move); } return 0; }
int main(int argc, char* argv[]) { if (argc > 1) { // If there is a test argument } else { // Normal mode std::cout << "Testing exponential... "; if (exponential(2, 1) != 2) { print_fail(); return 0; } if (exponential(3, 4) != 81) { print_fail(); return 0; } if (exponential(6, 3) != 216) { print_fail(); return 0; } print_pass(); } return 0; }
int main(int argc, char **argv) { //TODO: get rid of mem leaks (valgrind) uint8_t flags = 0; const char *sdcFile = NULL; FILE *hdrout = NULL; int option; while((option = getopt_long(argc, argv, "fvH:Vh", options, 0)) != -1) { switch(option) { case '?': return EXIT_INVALIDOPT; //force case 'f': flags |= F_FORCE; break; //verbose case 'v': flags |= F_VERBOSE; break; //header output case 'H': print_status("Opening header sink"); flags |= F_HEADEROUT; hdrout = fopen(optarg, "w"); if(hdrout == NULL) { //error opening a file print_fail(); perror(hdrout); return errno; } print_ok(); break; //version case 'V': print_version(); return EXIT_SUCCESS; //help case 'h': print_help(PH_LONG,argv[0]); return EXIT_SUCCESS; break; default: print_help(PH_SHORT,argv[0]); return EXIT_INVALIDOPT; } } if((argc - optind) == 1) { //parsing argv successful sdcFile = argv[optind]; } else { print_help(PH_SHORT,argv[0]); return EXIT_TOOLESS; } print_status("Opening SDC file"); int result; FILE *in = fopen(sdcFile,"r"); if(in == NULL) { //error opening a file print_fail(); perror(sdcFile); return errno; } print_ok(); //open key file void *keyFileName = malloc(strlen(sdcFile)+5); sprintf((char*)keyFileName,"%s.key",sdcFile); FILE *key = fopen((char*)keyFileName,"r"); if(key == NULL) { //error opening a file print_fail(); perror((char*)keyFileName); return errno; } print_status("Verifying keyfile"); //load keyFileName fseek(key,0,SEEK_END); int unformattedLength = ftell(key); fseek(key,0,SEEK_SET); void *unformatted = malloc(unformattedLength+1); fread(unformatted,1,unformattedLength,key); ((unsigned char *)unformatted)[unformattedLength] = '\0'; fclose(key); //fill unpack structure UnpackData unpackData; UnpackStatus us = fillUnpackStruct(&unpackData,unformatted); switch(us) { case FUS_OK: print_ok(); break; default: print_fail(); fprintf(stderr, "%s: Wrong format of a keyfile!\n", argv[0]); return us; } //load header size uint8_t *hdrSizeBuff = (uint8_t*)malloc(4); fread(hdrSizeBuff,1,4,in); uint32_t headerSize = *(uint32_t*)hdrSizeBuff; free(hdrSizeBuff); hdrSizeBuff = NULL; print_status("Validating SDC header"); //check header length if(headerSize < 0xff) { //it is not length but signature! print_fail(); fprintf(stderr, "%s: Encountered unsupported format! Signature is probably " "0x%02x\n", argv[0], headerSize); return -1; } //load and decode header Header *header = (Header*)malloc(headerSize); DecrError err = loadHeader(in, header, headerSize, &unpackData); if(err != DD_OK) { print_fail(); fprintf(stderr, "%s: Error when decrypting SDC header (errorcode: %d)\n", argv[0], err); return err; } //check if valid sdc file fseeko(in,0,SEEK_END); off_t sdcSize = ftello(in);//FIXME: check if still needed if((sizeof(Header) + (sizeof(File) * header->headerSize)) > headerSize) { printf("[ FAIL ]\n"); fprintf(stderr, "%s: File given is not valid SDC file or decryption key wrong\n", argv[0]); if(! (flags & F_FORCE)) return -1; } print_ok(); print_status("Checking file integrity"); //count crc32 uLong crc = countCrc(in, headerSize); if(flags & F_VERBOSE) fprintf(stderr, "%s: crc32: 0x%08lX; orig: 0x%08X\n", argv[0], crc, unpackData.checksum); //check if crc is valid if(crc != unpackData.checksum) { print_fail(); fprintf( stderr, "%s: CRC32 of sdc file did not match the one supplied in keyfile (0x%04X expected while have 0x%04lX)\n", argv[0], unpackData.checksum, crc ); if(! (flags & F_FORCE)) return crc; } else print_ok(); FileUnion *current = header->files; off_t filestart = headerSize + 4; File *after = &header->files[header->headerSize].file; FileName *fn = (FileName*)after; print_status("Decoding file name"); //decode data from header uint32_t fnLength = fn->fileNameLength; unsigned char *data = (unsigned char*)malloc(getDataOutputSize(fn->fileNameLength) + 1); err = decryptData(&fn->fileName, &fnLength, data, unpackData.fileNameKey, 32); if(err != DD_OK) { print_fail(); fprintf(stderr, "%s: Error while decrypting file name (errorcode: %d)", argv[0], err); return err; } memcpy((void*)&fn->fileName,data, fnLength); print_ok(); // write decrypted header to file if(flags & F_HEADEROUT && hdrout) { fwrite(&headerSize, 4, 1, hdrout); fwrite(header, headerSize, 1, hdrout); fclose(hdrout); } // unpack files int fileid; for(fileid = 0; fileid < header->headerSize; fileid++) { char *filename = (char*)(&fn->fileName); filename += current->file.fileNameOffset; uint32_t fn_size = strlen(filename); if(flags & F_VERBOSE) fprintf(stderr,"File path: %s\n",filename); dosPathToUnix(filename); void *dirName = malloc(fn_size + 1); strcpy((char*)dirName,filename); dirName = dirname((char*)dirName); char *baseName = basename(filename); //get sdc location char *sdcDir = (char*)malloc(strlen(sdcFile)+1); strcpy(sdcDir,sdcFile); sdcDir = dirname(sdcDir); print_status("Creating directory structure at '%s'", dirName); //create directory according to header char *outFile = (char*)malloc(strlen(sdcDir)+strlen((char*)dirName)+2); sprintf(outFile,"%s/%s",sdcDir,(char*)dirName); int ret = createDir(outFile); if(ret != 0) { print_fail(); fprintf(stderr,"%s: Directory '%s' creation failed with errno: %d\n",argv[0], outFile,errno); } print_ok(); if(flags & F_VERBOSE) { #define TIMESIZE 20 char crtime[TIMESIZE]; time_t creation = winTimeToUnix(current->file.creationTime); unixTimeToStr(crtime, TIMESIZE, creation); char actime[TIMESIZE]; time_t access = winTimeToUnix(current->file.accessTime); unixTimeToStr(actime, TIMESIZE, access); char mdtime[TIMESIZE]; time_t modification = winTimeToUnix(current->file.modificationTime); unixTimeToStr(mdtime, TIMESIZE, modification); fprintf(stderr, "File has been originally created at %s, last accessed at %s and modified at %s\n", crtime, actime, mdtime); } print_status("Unpacking '%s'", baseName); //open output file outFile = (char*)realloc(outFile, strlen(sdcDir)+strlen((char*)dirName)+strlen(baseName)+3); sprintf(outFile,"%s/%s/%s",sdcDir,(char*)dirName,baseName); FILE *out = fopen(outFile,"w"); if(out == NULL) { //error opening a file print_fail(); perror(outFile); return errno; } //memory cleanup free(outFile); outFile = NULL; //free(sdcDir);//FIXME: SIGABRT sdcDir = NULL; free(dirName); dirName = NULL; //ensure we are after header int r; if((r = fseek(in,filestart,SEEK_SET))!=0) return r; //create inflate struct z_stream stream; stream.next_in = Z_NULL; stream.avail_in = 0; stream.zalloc = Z_NULL; stream.zfree = Z_NULL; stream.opaque = Z_NULL; //initialize stream r = (int)-1; if(header->headerSignature == SIG_ELARGE) r = inflateInit(&stream); else r = inflateInit2_(&stream,-15,ZLIB_VERSION,(int)sizeof(z_stream)); if(r != Z_OK) { print_fail(); fprintf(stderr,"inflateInit failed with errorcode %d (%s)\n",r,stream.msg); return r; } //read from file unsigned int bytesToRead; if(header->headerSignature == SIG_ELARGE) { bytesToRead = current->file4gb.compressedSize & 0x3fff; } else { bytesToRead = current->file.compressedSize & 0x3fff; } unsigned char *input = (unsigned char*)malloc(bytesToRead); unsigned char *output = (unsigned char*)malloc(0x4000); void *tmp = malloc(bytesToRead); //determine file size unsigned int bytesRemaining = 0; if(header->headerSignature == SIG_ELARGE) bytesRemaining = current->file4gb.fileSize; else bytesRemaining = current->file.fileSize; double fileSize = bytesRemaining, remaining; uint8_t progress = 0; if(flags & F_VERBOSE) fprintf(stderr,"file size has been set as %u (0x%04X), signature: 0x%02X\n",bytesRemaining,bytesRemaining,header->headerSignature); while(bytesRemaining != 0) { // check progress remaining = bytesRemaining; if((((fileSize - remaining) / fileSize) * 6) > progress) { ++progress; print_progress(progress); } result = fread(input+stream.avail_in,1,bytesToRead-stream.avail_in,in); if(result == 0 && stream.avail_in == 0) //stop only if stream iflated whole previous buffer return 1; //still have bytes remaining but container end reached //decode stream.next_in = (Bytef*)input; stream.avail_in += result; stream.next_out = (Bytef*)output; stream.avail_out = 0x4000; stream.total_in = 0; stream.total_out = 0; r = inflate(&stream,0); if(r < Z_OK) { print_fail(); fprintf(stderr,"inflate failed with errorcode %d (%s)\n",r,stream.msg); return r; } //XOR xorBuffer(unpackData.xorVal % 0x100, output, stream.total_out); //write to file fwrite(output,1,stream.total_out,out); bytesRemaining -= stream.total_out; /* * tricky part: input buffer hadn't been fully decompressed * so we need to copy the rest to TMP and then at the beginning * of input buffer so it can be inflated, but before that we need to * read the rest of a chunk so its size would be COMPRESSEDSIZE */ memcpy(tmp,stream.next_in,stream.avail_in); memcpy(input,tmp,stream.avail_in); } if(bytesRemaining != 0) { print_fail(); fprintf(stderr, "%s: Unexpected end of file!\n", argv[0]); } else print_ok(); fclose(out); free(tmp); tmp = NULL; free(input); input = NULL; free(output); output = NULL; if(header->headerSignature == SIG_ELARGE) filestart += current->file4gb.compressedSize; else filestart += current->file.compressedSize; current++; } free(unpackData.unformatted); unpackData.unformatted = NULL; unpackData.fileNameKey = NULL; unpackData.headerKey = NULL; free(header); fclose(in); return 0; }
/* Test a composite of a given operation, source, and destination picture. */ Bool blend_test(Display *dpy, picture_info *win, picture_info *dst, const int *op, int num_op, const picture_info **src_color, int num_src, const picture_info **dst_color, int num_dst) { color4d expected, tested, tdst; char testname[20]; int i, j, k, y, iter; int page, num_pages; /* If the window is smaller than the number of sources to test, * we need to break the sources up into pages. * * We however assume that the window will always be wider than num_ops. */ num_pages = num_src / win_height + 1; k = y = 0; while (k < num_dst) { XImage *image; int k0 = k, k1 = k; int this_src, rem_src; rem_src = num_src; for (page = 0; page < num_pages; page++) { this_src = rem_src / (num_pages - page); for (iter = 0; iter < pixmap_move_iter; iter++) { k1 = k0; y = 0; while (k1 < num_dst && y + this_src <= win_height) { XRenderComposite(dpy, PictOpSrc, dst_color[k1++]->pict, 0, dst->pict, 0, 0, 0, 0, 0, y, num_op, this_src); for (j = 0; j < this_src; j++) { for (i = 0; i < num_op; i++) { XRenderComposite(dpy, ops[op[i]].op, src_color[j]->pict, 0, dst->pict, 0, 0, 0, 0, i, y, 1, 1); } y++; } } } image = XGetImage(dpy, dst->d, 0, 0, num_ops, y, 0xffffffff, ZPixmap); copy_pict_to_win(dpy, dst, win, win_width, win_height); y = 0; for (k = k0; k < k1; k++) { XRenderDirectFormat dst_acc; accuracy(&dst_acc, &dst->format->direct, &dst_color[k]->format->direct); tdst = dst_color[k]->color; color_correct(dst, &tdst); for (j = 0; j < this_src; j++) { XRenderDirectFormat acc; accuracy(&acc, &src_color[j]->format->direct, &dst_acc); for (i = 0; i < num_op; i++) { get_pixel_from_image(image, dst, i, y, &tested); do_composite(ops[op[i]].op, &src_color[j]->color, NULL, &tdst, &expected, FALSE); color_correct(dst, &expected); if (eval_diff(&acc, &expected, &tested) > 3.) { char *srcformat; snprintf(testname, 20, "%s blend", ops[op[i]].name); describe_format(&srcformat, NULL, src_color[j]->format); print_fail(testname, &expected, &tested, 0, 0, eval_diff(&acc, &expected, &tested)); printf("src color: %.2f %.2f %.2f %.2f (%s)\n" "dst color: %.2f %.2f %.2f %.2f\n", src_color[j]->color.r, src_color[j]->color.g, src_color[j]->color.b, src_color[j]->color.a, srcformat, dst_color[k]->color.r, dst_color[k]->color.g, dst_color[k]->color.b, dst_color[k]->color.a); printf("src: %s, dst: %s\n", src_color[j]->name, dst->name); free(srcformat); return FALSE; } } y++; } } XDestroyImage(image); rem_src -= this_src; } } return TRUE; }
int main() { bgrt_item_t bgrt_item_1 = BGRT_ITEM_T_INIT( bgrt_item_1 ); bgrt_item_t bgrt_item_2, bgrt_item_3; bgrt_item_t * head; int test; printf("Test 1: BGRT_ITEM_T_INIT macro: "); if( (bgrt_item_1.next != &bgrt_item_1) || (bgrt_item_1.prev != &bgrt_item_1) ) { print_fail(); return 0; } else { print_ok(); } printf("Test 2: bgrt_item_init function: "); bgrt_item_init( &bgrt_item_2 ); bgrt_item_init( &bgrt_item_3 ); if( (bgrt_item_2.next != &bgrt_item_2) || (bgrt_item_2.prev != &bgrt_item_2) ) { print_fail(); return 0; } else { print_ok(); } printf("Test 3: bgrt_item_insert function: "); head = &bgrt_item_1; bgrt_item_insert( &bgrt_item_2, head ); test = (bgrt_item_1.next != &bgrt_item_2) || (bgrt_item_1.prev != &bgrt_item_2); test |= (bgrt_item_2.next != &bgrt_item_1) || (bgrt_item_2.prev != &bgrt_item_1); bgrt_item_insert( &bgrt_item_3, head ); test |= (bgrt_item_1.next != &bgrt_item_2) || (bgrt_item_1.prev != &bgrt_item_3); test |= (bgrt_item_2.next != &bgrt_item_3) || (bgrt_item_2.prev != &bgrt_item_1); test |= (bgrt_item_3.next != &bgrt_item_1) || (bgrt_item_3.prev != &bgrt_item_2); if( test ) { print_fail(); return 0; } else { print_ok(); } printf("Test 4: bgrt_item_cut function: "); bgrt_item_cut( &bgrt_item_3 ); test = (bgrt_item_1.next != &bgrt_item_2) || (bgrt_item_1.prev != &bgrt_item_2); test |= (bgrt_item_2.next != &bgrt_item_1) || (bgrt_item_2.prev != &bgrt_item_1); bgrt_item_cut( &bgrt_item_2 ); test |= (bgrt_item_1.next != &bgrt_item_1) || (bgrt_item_1.prev != &bgrt_item_1); if( test ) { print_fail(); return 0; } else { print_ok(); } return 0; }
int main(int argc, char *argv[]) { const char *path_list = getenv("PATH"); int short_option, long_option, fail_count = 0, path_index; int show_dot = 0, show_tilde = 0, tty_only = 0; struct option longopts[] = { {"version", 0, &long_option, opt_version}, {"skip-dot", 0, &long_option, opt_skip_dot}, {"skip-tilde", 0, &long_option, opt_skip_tilde}, {"show-dot", 0, &long_option, opt_show_dot}, {"show-tilde", 0, &long_option, opt_show_tilde}, {"tty-only", 0, &long_option, opt_tty_only}, {"all", 0, NULL, 'a'}, {NULL, 0, NULL, 0} }; progname = argv[0]; while ((short_option = getopt_long(argc, argv, "avV", longopts, NULL)) != -1) { switch (short_option) { case 0: switch (long_option) { case opt_version: print_version(); return 0; case opt_skip_dot: skip_dot = !tty_only; break; case opt_skip_tilde: skip_tilde = !tty_only; break; case opt_show_dot: show_dot = !tty_only; break; #ifndef WIN32 case opt_show_tilde: show_tilde = (!tty_only && geteuid() != 0); break; #endif case opt_tty_only: tty_only = !isatty(1); break; } break; case 'a': show_all = 1; break; case 'v': case 'V': print_version(); return 0; } } if (show_dot) get_current_working_directory(); if (show_tilde || skip_tilde) { const char *h; if (!(h = getenv("HOME"))) { fprintf(stderr, "%s: ", progname); if (show_tilde) fprintf(stderr, "--show-tilde"); else fprintf(stderr, "--skip-tilde"); fprintf(stderr, ": Environment variable HOME not set\n"); show_tilde = skip_tilde = 0; } else { strncpy(home, h, sizeof(home)); home[sizeof(home) - 1] = 0; homelen = strlen(home); if (home[homelen - 1] != DIRSEP && homelen < sizeof(home) - 1) { strcat(home, "/"); ++homelen; } } } argv += optind; if (!*argv) { print_usage(); return -1; } for (; *argv; ++argv) { char *result = NULL; int found_something = 0; if (path_list && *path_list != '\0') { int next; path_index = 0; do { next = show_all; result = find_command_in_path(*argv, path_list, &path_index); if (result) { const char *full_path = path_clean_up(result); int in_home = (show_tilde || skip_tilde) && !strncmp(full_path, home, homelen); if (!(skip_tilde && in_home) && show_dot && found_path_starts_with_dot && !strncmp(full_path, cwd, cwdlen)) { full_path += cwdlen; fprintf(stdout, "./"); } else if (in_home) { if (skip_tilde) { next = 1; continue; } if (show_tilde) { full_path += homelen; fprintf(stdout, "~/"); } } fprintf(stdout, "%s\n", full_path); free(result); found_something = 1; } else break; } while(next); } if (!found_something) { print_fail(absolute_path_given ? strrchr(*argv, DIRSEP) + 1 : *argv, absolute_path_given ? abs_path : path_list); ++fail_count; } } return fail_count; }
//============================================= void gradient_wakeup_timer() { uint8_t next_hop_addr; mrfiPacket_t packetToSend; switch (gradient_state) { //--------------------------------------- transmitter case (GRADIENT_IDLE): //wake_up timer /* stop preamble sampling */ wor_stop(IS_SINK_NODE); /* stop possible timers */ stop_timer(); /* check that there is data to send */ dataToSend = QgetInUseSlot(OUTQ); if (!dataToSend) { gradient_end_txrx(); print_debug("\r\nno data to send",17); return; } /* TODO. check that the medium is free */ set_timer(UF_PERIOD); //wake_up timer /* send first uF */ gradient_set_state(GRADIENT_TXUF); uf_counter = NUMBER_UF-1; gradient_build_UF(&packetToSend, uf_counter); MRFI_justTransmit(&packetToSend); break; case (GRADIENT_TXUF): //wake_up timer if (uf_counter > 0) { uf_counter--; /* send uF */ gradient_build_UF(&packetToSend, uf_counter); MRFI_justTransmit(&packetToSend); } else { stop_timer(); /* send CW */ gradient_set_state(GRADIENT_TXCW); gradient_build_CW(&packetToSend, CW_LENGTH); MRFI_justTransmit(&packetToSend); /* wait for ACK */ gradient_set_state(GRADIENT_RXACK); gradient_init_neighbor_table(); MRFI_RxOn(); set_timer(CW_LENGTH); } break; case (GRADIENT_RXACK): //wake_up timer stop_timer(); print_neighbor_table(neighbors); gradient_update_height(); print_height(myAddr,myHeight); next_hop_addr = gradient_next_hop(); if (next_hop_addr==0) { gradient_end_txrx(); print_fail("\r\nTX failed: no neighbor",24); } else { /* send DATA */ gradient_set_state(GRADIENT_TXDATA); //if mine, complete with current neighbor list and empty hop count if ( (&(dataToSend->mrfiPkt))->frame[F_SRC]==myAddr) { gradient_build_DATA_headers(dataToSend); } (&(dataToSend->mrfiPkt))->frame[F_DATA_NEXT_HOP]=next_hop_addr; MRFI_justTransmit(&(dataToSend->mrfiPkt)); /* wait for FIN */ gradient_set_state(GRADIENT_RXFIN); MRFI_RxOn(); set_timer(TIMEOUT_FIN); } break; case (GRADIENT_RXFIN): //wake_up timer gradient_end_txrx(); print_fail("\r\nTX failed: no FIN",19); break; //--------------------------------------- receiver case (GRADIENT_RXUF): //wake_up timer stop_timer(); /* wait for CW */ gradient_set_state(GRADIENT_RXCW); MRFI_RxOn(); set_timer(TIMEOUT_CW); break; case (GRADIENT_RXCW): //wake_up timer gradient_end_txrx(); print_fail("\r\nRX failed: no CW",18); break; case (GRADIENT_BACKOFFACK): //wake_up timer stop_second_random_timer(); /* send ACK */ gradient_set_state(GRADIENT_TXACK); gradient_build_ACK(&packetToSend, addr_initiator); MRFI_justTransmit(&packetToSend); gradient_set_state(GRADIENT_SENTACK); MRFI_RxIdle(); break; case (GRADIENT_SENTACK): //wake_up timer stop_timer(); /* wait for DATA */ gradient_set_state(GRADIENT_RXDATA); MRFI_RxOn(); set_timer(TIMEOUT_DATA); break; case (GRADIENT_RXDATA): //wake_up timer gradient_end_txrx(); print_fail("\r\nRX failed: no DATA",20); break; case (GRADIENT_TXFIN): //wake_up timer stop_timer(); /* send FIN */ gradient_build_FIN(&packetToSend, addr_initiator); MRFI_justTransmit(&packetToSend); print_success("\r\nRX successful",15); print_DATA(&lastData, myAddr); gradient_end_txrx(); break; } }
int test_mtd(int argc, char *argv[]) { unsigned iterations= 0; /* check if microSD card is mounted */ struct stat buffer; if (stat(PARAM_FILE_NAME, &buffer)) { warnx("file %s not found, aborting MTD test", PARAM_FILE_NAME); print_fail(); return 1; } // XXX get real storage space here unsigned file_size = 4096; /* perform tests for a range of chunk sizes */ unsigned chunk_sizes[] = {256, 512, 4096}; for (unsigned c = 0; c < (sizeof(chunk_sizes) / sizeof(chunk_sizes[0])); c++) { printf("\n====== FILE TEST: %u bytes chunks ======\n", chunk_sizes[c]); uint8_t write_buf[chunk_sizes[c]] __attribute__((aligned(64))); /* fill write buffer with known values */ for (unsigned i = 0; i < sizeof(write_buf); i++) { /* this will wrap, but we just need a known value with spacing */ write_buf[i] = i+11; } uint8_t read_buf[chunk_sizes[c]] __attribute__((aligned(64))); hrt_abstime start, end; int fd = open(PARAM_FILE_NAME, O_RDONLY); int rret = read(fd, read_buf, chunk_sizes[c]); close(fd); if (rret <= 0) { err(1, "read error"); } fd = open(PARAM_FILE_NAME, O_WRONLY); printf("printing 2 percent of the first chunk:\n"); for (unsigned i = 0; i < sizeof(read_buf) / 50; i++) { printf("%02X", read_buf[i]); } printf("\n"); iterations = file_size / chunk_sizes[c]; start = hrt_absolute_time(); for (unsigned i = 0; i < iterations; i++) { int wret = write(fd, write_buf, chunk_sizes[c]); if (wret != (int)chunk_sizes[c]) { warn("WRITE ERROR!"); print_fail(); return 1; } fsync(fd); if (!check_user_abort(fd)) return OK; } end = hrt_absolute_time(); close(fd); fd = open(PARAM_FILE_NAME, O_RDONLY); /* read back data for validation */ for (unsigned i = 0; i < iterations; i++) { int rret2 = read(fd, read_buf, chunk_sizes[c]); if (rret2 != (int)chunk_sizes[c]) { warnx("READ ERROR!"); print_fail(); return 1; } /* compare value */ bool compare_ok = true; for (unsigned j = 0; j < chunk_sizes[c]; j++) { if (read_buf[j] != write_buf[j]) { warnx("COMPARISON ERROR: byte %d", j); print_fail(); compare_ok = false; break; } } if (!compare_ok) { warnx("ABORTING FURTHER COMPARISON DUE TO ERROR"); print_fail(); return 1; } if (!check_user_abort(fd)) return OK; } close(fd); } /* fill the file with 0xFF to make it look new again */ char ffbuf[64]; memset(ffbuf, 0xFF, sizeof(ffbuf)); int fd = open(PARAM_FILE_NAME, O_WRONLY); for (unsigned i = 0; i < file_size / sizeof(ffbuf); i++) { int ret = write(fd, ffbuf, sizeof(ffbuf)); if (ret != sizeof(ffbuf)) { warnx("ERROR! Could not fill file with 0xFF"); close(fd); print_fail(); return 1; } } (void)close(fd); print_success(); return 0; }