Files
VCCPlusOSS/tests/toolchain/stream-writes/position.c
T

161 lines
6.5 KiB
C

// SPDX-License-Identifier: GPL-3.0-or-later
// Host-created data and the final raw disk are checked independently of this API.
#include <stdio.h>
#include <limits.h>
#include <cmoc.h>
#include <coco.h>
#include <decbfile.h>
#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;
}