// SPDX-License-Identifier: GPL-3.0-or-later // Host-created data and the final raw disk are checked independently of this API. #include #include #include #include #include #define CHECK(test) do { if (!(test)) { printf("FAIL LINE %u ERR %u\n", (unsigned)__LINE__, (unsigned)vcc_file_error()); return 1; } } while (0) int checkLegacyFirst(void); int checkStdioFirst(void); static byte block[256]; static int binaryInput(void) { FILE *f = fopen("DISTANT.DAT", "rb"); CHECK(f && ftell(f) == 0L); CHECK(fseek(f, 255L, SEEK_SET) == 0); CHECK(fread(block, 1, 2, f) == 2 && block[0] == 249 && block[1] == 1); // This pair of bytes crosses a deliberately noncontiguous granule. CHECK(fseek(f, 2303L, SEEK_SET) == 0 && ftell(f) == 2303L); CHECK(fgetc(f) == 1 && fgetc(f) == 9); CHECK(fseek(f, -2L, SEEK_CUR) == 0 && fgetc(f) == 1); CHECK(fseek(f, -2L, SEEK_END) == 0 && ftell(f) == 65535L); CHECK(fgetc(f) == 248 && ftell(f) == 65536L); CHECK(fgetc(f) == 0 && ftell(f) == 65537L); CHECK(fgetc(f) == EOF && feof(f)); CHECK(fseek(f, LONG_MAX, SEEK_CUR) != 0 && feof(f) && ftell(f) == 65537L); CHECK(fseek(f, LONG_MIN, SEEK_END) != 0 && feof(f) && ftell(f) == 65537L); CHECK(fseek(f, 0L, 17) != 0 && feof(f)); CHECK(fseek(f, -65537L, SEEK_CUR) == 0 && !feof(f) && ftell(f) == 0L); CHECK(fseek(f, -1L, SEEK_SET) != 0 && ftell(f) == 0L); CHECK(fseek(f, 65538L, SEEK_SET) != 0 && ftell(f) == 0L && fgetc(f) == 0); CHECK(fseek(f, 65536L, SEEK_SET) == 0 && ftell(f) == 65536L && fgetc(f) == 0); CHECK(fgetc(f) == EOF && feof(f)); rewind(f); CHECK(ftell(f) == 0L); CHECK(!feof(f)); CHECK(!ferror(f)); CHECK(fgetc(f) == 0); CHECK(fclose(f) == 0); f = fopen("DISTANT.DAT", "ab"); CHECK(f && ftell(f) == 65537L && fseek(f, 0L, SEEK_SET) == 0); CHECK(ftell(f) == 0L && fputc('!', f) == '!' && ftell(f) == 65538L && fclose(f) == 0); CHECK(ftell(NULL) == -1L && fseek(NULL, 0L, SEEK_SET) != 0); return 0; } static int textBookmarks(void) { FILE *f = fopen("RECORDS.TXT", "r"); long before, after; char line[16]; CHECK(f && fread(block, 1, 255, f) == 255); before = ftell(f); // The CR is the final byte of sector 0. CHECK(before >= 0 && fgetc(f) == '\n'); after = ftell(f); // The paired LF starts sector 1. clearerr(f); // Preserve the pending CRLF translation. CHECK(after >= 0 && after != before && fgetc(f) == 'M'); CHECK(fseek(f, before, SEEK_SET) == 0 && fgetc(f) == '\n' && fgetc(f) == 'M'); CHECK(fseek(f, after, SEEK_SET) == 0); CHECK(fgets(line, sizeof(line), f) && !strcmp(line, "MARS\n")); CHECK(fseek(f, after, SEEK_SET) == 0); CHECK(fseek(f, 1L, SEEK_CUR) != 0 && fseek(f, -1L, SEEK_END) != 0); CHECK(ftell(f) == after && fgetc(f) == 'M'); CHECK(fseek(f, 0L, SEEK_END) == 0 && fgetc(f) == EOF && feof(f)); rewind(f); CHECK(!feof(f) && ftell(f) == 0L && fgetc(f) == 'X'); CHECK(fclose(f) == 0); return 0; } static int editBinary(void) { unsigned sector, i; const long originalSize = 2579L; FILE *f = fopen("PATCH.BIN", "wb"); FILE *reader; CHECK(f && ftell(f) == 0L && fseek(f, 0L, SEEK_END) == 0); for (sector = 0; sector < 10; ++sector) { for (i = 0; i < sizeof(block); ++i) block[i] = (byte)(sector + i); CHECK(fwrite(block, 1, sizeof(block), f) == sizeof(block)); } memset(block, 0xa5, 19); CHECK(fwrite(block, 1, 19, f) == 19 && ftell(f) == originalSize); // The last 19 bytes are still pending when the invalid seek is refused. CHECK(fseek(f, 1L, SEEK_END) != 0 && ftell(f) == originalSize); CHECK(fseek(f, -19L, SEEK_END) == 0 && ftell(f) == 2560L); reader = fopen("PATCH.BIN", "rb"); CHECK(reader && fseek(reader, -1L, SEEK_END) == 0 && fgetc(reader) == 0xa5); CHECK(fseek(f, 255L, SEEK_SET) == 0 && fputs("SECT", f) >= 0 && ftell(f) == 259L); CHECK(fflush(f) == 0); CHECK(fseek(f, 2302L, SEEK_SET) == 0 && fputs("GRAN", f) >= 0); CHECK(fseek(f, -3L, SEEK_END) == 0 && fputs("TAIL++", f) >= 0); CHECK(ftell(f) == originalSize + 3L && fflush(f) == 0); CHECK(fseek(reader, 0L, SEEK_END) == 0 && ftell(reader) == originalSize); CHECK(fgetc(reader) == EOF && feof(reader)); CHECK(fclose(reader) == 0); rewind(f); CHECK(ftell(f) == 0L && fputc('H', f) == 'H' && fclose(f) == 0); f = fopen("PATCH.BIN", "ab"); CHECK(f && ftell(f) == originalSize + 3L && fseek(f, 3L, SEEK_SET) == 0); CHECK(ftell(f) == 3L && fputs("END", f) >= 0 && ftell(f) == originalSize + 6L); rewind(f); CHECK(ftell(f) == 0L && fputc('!', f) == '!' && ftell(f) == originalSize + 7L); CHECK(fclose(f) == 0); return 0; } static int protectedSeek(void) { FILE *f = fopen("REPORT.BIN", "wb"); CHECK(f && fputs("ORBIT", f) >= 0 && fseek(f, 1L, SEEK_SET) == 0); CHECK(fputc('X', f) == 'X' && ftell(f) == 2L); printf("PROTECT NOW\n"); while (waitkey(0) != 'X') {} CHECK(fseek(f, 4L, SEEK_SET) != 0 && ferror(f) == DECB_ERR_IO); CHECK(ftell(f) == 2L); // Only this writer is cleared. The second stream has its own EOF. FILE *reader = fopen("REPORT.BIN", "rb"); CHECK(reader && fseek(reader, 0L, SEEK_END) == 0 && fgetc(reader) == EOF && feof(reader)); clearerr(f); CHECK(ferror(f) == 0 && ftell(f) == 2L && feof(reader)); CHECK(fflush(f) == EOF && ferror(f) == DECB_ERR_IO); clearerr(reader); CHECK(!feof(reader) && !ferror(reader) && ferror(f) == DECB_ERR_IO); CHECK(ftell(reader) == 5L && fgetc(reader) == EOF && feof(reader)); CHECK(fclose(reader) == 0); clearerr(reader); CHECK(vcc_file_error() == DECB_ERR_INVALID_ARGUMENT); rewind(f); // Still protected: position and error survive. CHECK(ftell(f) == 2L && ferror(f) == DECB_ERR_IO); printf("ALLOW RETRY\n"); while (waitkey(0) != 'Y') {} rewind(f); // The buffered overwrite can now be delivered. CHECK(ftell(f) == 0L && !ferror(f) && fclose(f) == 0); return 0; } int main(void) { int result = 1; cls(1); printf("SELECT CHECK\n"); switch (waitkey(0)) { case 'M': result = checkLegacyFirst() || checkStdioFirst(); break; case 'S': result = binaryInput() || textBookmarks() || editBinary(); break; case 'T': result = protectedSeek(); break; } if (!result) printf("POSITIONS PASSED\n"); return result; }