837 lines
15 KiB
C
837 lines
15 KiB
C
/* E x e r c i s e
|
|
*
|
|
* This program exercises the stdio routines. It does not validate the
|
|
* routines but provides a convenient way to quickly check the functionality
|
|
* of the code.
|
|
*/
|
|
|
|
#ifdef _BSD
|
|
# include <strings.h>
|
|
#else
|
|
# include <stdlib.h>
|
|
# include <string.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
|
|
#define UCHAR(x) ((int) ((x) & 0xff))
|
|
|
|
#define DEC -123
|
|
#define INT 255
|
|
#define UNS (~0)
|
|
#define TESTFILE "test.dat"
|
|
#define LARGEBUFS 16
|
|
#ifdef MSDOS
|
|
# define TTY "con"
|
|
#else
|
|
# define TTY "/dev/tty"
|
|
#endif
|
|
|
|
extern void *malloc(); /* memory allocator */
|
|
extern unsigned sleep(); /* sleep routine */
|
|
extern char *strcpy(); /* string copy */
|
|
extern char *strcat(); /* string concatenation */
|
|
extern int strcmp(); /* string compare */
|
|
extern void exit(); /* exit */
|
|
|
|
FILE *fp; /* per test file pointer */
|
|
|
|
/*
|
|
* Line Buffered Write Test
|
|
*
|
|
* Write to a terminal. This tests that the output buffer is
|
|
* flushed on receipt of a \n.
|
|
*/
|
|
|
|
void lbw_test()
|
|
|
|
{
|
|
int i;
|
|
|
|
puts("\nLine buffered write test");
|
|
if ((fp = fopen(TTY, "w")) != NULL) {
|
|
puts("<pause>ABCDEFGH");
|
|
puts("<pause>ABCD<pause>EFGH");
|
|
for (i = 0; i < 8; i++)
|
|
putc('A'+i, fp), sleep(1);
|
|
putc('\n', fp);
|
|
for (i = 0; i < 8; i++) {
|
|
putc('A'+i, fp);
|
|
if (i == 3)
|
|
fflush(fp);
|
|
sleep(1);
|
|
}
|
|
fclose(fp);
|
|
puts("");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unbuffered Write Test
|
|
*
|
|
* Test that characters are written directly to the output device
|
|
* when the stream is unbuffered.
|
|
*/
|
|
|
|
void ubw_test()
|
|
|
|
{
|
|
int i;
|
|
|
|
puts("\nUnbuffered write test");
|
|
if ((fp = fopen(TTY, "w")) != NULL) {
|
|
setbuf(fp, (char *) 0);
|
|
puts("A<pause>B<pause>C<pause>D<pause>E<pause>F<pause>G<pause>H<pause>");
|
|
puts("A<pause>B<pause>C<pause>D<pause>E<pause>F<pause>G<pause>H<pause>");
|
|
for (i = 0; i < 8; i++)
|
|
putc('A'+i, fp), sleep(1);
|
|
putc('\n', fp);
|
|
for (i = 0; i < 8; i++)
|
|
putc('A'+i, fp), sleep(1);
|
|
fclose(fp);
|
|
puts("");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Buffered Write Test
|
|
*
|
|
* Test that the data is written to the terminal on a per buffer
|
|
* basis.
|
|
*/
|
|
|
|
void bw_test()
|
|
|
|
{
|
|
int i;
|
|
|
|
puts("\nFully buffered write test");
|
|
if ((fp = fopen(TTY, "w")) != NULL) {
|
|
setvbuf(fp, (char *) 0, _IOFBF, 4);
|
|
puts("<pause>ABCD<pause>EFGH<pause>");
|
|
puts("ABC<pause>DEFG<pause>H");
|
|
for (i = 0; i < 8; i++)
|
|
putc('A'+i, fp), sleep(1);
|
|
putc('\n', fp);
|
|
for (i = 0; i < 8; i++)
|
|
putc('A'+i, fp), sleep(1);
|
|
fclose(fp);
|
|
puts("");
|
|
}
|
|
}
|
|
|
|
/* Formatted Output Test
|
|
*
|
|
* This exercises the output formatting code.
|
|
*/
|
|
|
|
void fp_test()
|
|
|
|
{
|
|
int i, j, k, l;
|
|
char buf[7];
|
|
char *prefix = buf;
|
|
char tp[20];
|
|
|
|
puts("\nFormatted output test");
|
|
printf("prefix 6d 6o 6x 6X 6u\n");
|
|
strcpy(prefix, "%");
|
|
for (i = 0; i < 2; i++) {
|
|
for (j = 0; j < 2; j++) {
|
|
for (k = 0; k < 2; k++) {
|
|
for (l = 0; l < 2; l++) {
|
|
strcpy(prefix, "%");
|
|
if (i == 0) strcat(prefix, "-");
|
|
if (j == 0) strcat(prefix, "+");
|
|
if (k == 0) strcat(prefix, "#");
|
|
if (l == 0) strcat(prefix, "0");
|
|
printf("%5s |", prefix);
|
|
strcpy(tp, prefix);
|
|
strcat(tp, "6d |");
|
|
printf(tp, DEC);
|
|
strcpy(tp, prefix);
|
|
strcat(tp, "6o |");
|
|
printf(tp, INT);
|
|
strcpy(tp, prefix);
|
|
strcat(tp, "6x |");
|
|
printf(tp, INT);
|
|
strcpy(tp, prefix);
|
|
strcat(tp, "6X |");
|
|
printf(tp, INT);
|
|
strcpy(tp, prefix);
|
|
strcat(tp, "6u |");
|
|
printf(tp, UNS);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* String Output Test
|
|
*
|
|
* Test the string printf code.
|
|
*/
|
|
|
|
void sw_test()
|
|
|
|
{
|
|
int i;
|
|
char buf[80];
|
|
|
|
puts("\nTest sprintf functionality");
|
|
puts("13 bytes in 'Testing 1 2 3'");
|
|
i = sprintf(buf, "Testing %d %d %d", 1, 2, 3);
|
|
printf("%d bytes in '%s'\n", i, buf);
|
|
}
|
|
|
|
/*
|
|
* String Input Test
|
|
*
|
|
* Test the string scanf code.
|
|
*/
|
|
|
|
void sr_test()
|
|
|
|
{
|
|
int i, j;
|
|
char buf[80];
|
|
|
|
puts("\nTest sscanf functionality");
|
|
puts("2 items yielding 25 and 'thompson'");
|
|
i = sscanf("25 thompson", "%d%s", &j, buf);
|
|
printf("%d items yielding %d and '%s'\n", i, j, buf);
|
|
}
|
|
|
|
/*
|
|
* File Write and Read Test
|
|
*
|
|
* Test that a file can be written to and read from.
|
|
*/
|
|
|
|
void frw_test()
|
|
|
|
{
|
|
int i, j, k;
|
|
char buf[80];
|
|
|
|
puts("\nFile write and read check");
|
|
if ((fp = fopen(TESTFILE, "w")) != NULL) {
|
|
puts("3 items yielding 56, 789 and '56'");
|
|
puts("1 item yielding 'a72'");
|
|
fprintf(fp, "56789 0123 56a72");
|
|
if (freopen(TESTFILE, "r", fp) != fp)
|
|
puts("Cannot open file for reading");
|
|
else {
|
|
i = fscanf(fp, "%2d%d%*d %[0-9]", &j, &k, buf);
|
|
printf("%d items yielding %d, %d and '%s'\n", i, j, k, buf);
|
|
i = fscanf(fp, "%s", buf);
|
|
printf("%d item yielding '%s'\n", i, buf);
|
|
fclose(fp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* File Seek Test
|
|
*
|
|
* Test that seek operations within files work.
|
|
*/
|
|
|
|
void fs_test()
|
|
|
|
{
|
|
int i, j;
|
|
|
|
puts("\nFile seek test");
|
|
if ((fp = fopen(TESTFILE, "w")) != NULL) {
|
|
for (i = 0; i < 256; i++)
|
|
putc(i, fp);
|
|
if (freopen(TESTFILE, "r", fp) != fp)
|
|
puts("Cannot open file for reading");
|
|
else {
|
|
for (i = 1; i <= 255; i++) {
|
|
printf("\r%3d ", i);
|
|
fflush(stdout);
|
|
fseek(fp, (long) -i, SEEK_END);
|
|
if ((j = getc(fp)) != 256-i) {
|
|
printf("SEEK_END failed %d\n", j);
|
|
break;
|
|
}
|
|
if (fseek(fp, (long) i, SEEK_SET)) {
|
|
puts("Cannot SEEK_SET");
|
|
break;
|
|
}
|
|
if ((j = getc(fp)) != i) {
|
|
printf("SEEK_SET failed %d\n", j);
|
|
break;
|
|
}
|
|
if (fseek(fp, (long) i, SEEK_SET)) {
|
|
puts("Cannot SEEK_SET");
|
|
break;
|
|
}
|
|
if (fseek(fp, (long) (i >= 128 ? -128 : 128), SEEK_CUR)) {
|
|
puts("Cannot SEEK_CUR");
|
|
break;
|
|
}
|
|
if ((j = getc(fp)) != (i >= 128 ? i-128 : i+128)) {
|
|
printf("SEEK_CUR failed %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i > 255)
|
|
puts("ok");
|
|
fclose(fp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test gets()
|
|
*
|
|
* Checks that gets() works.
|
|
*/
|
|
|
|
void gets_test()
|
|
|
|
{
|
|
char buf[80];
|
|
|
|
puts("\nGets functionality");
|
|
puts("... Type a line and have it echoed ...");
|
|
gets(buf);
|
|
puts(buf);
|
|
}
|
|
|
|
/*
|
|
* Fputs Test
|
|
*
|
|
* Check that fputs() works into unbuffered streams.
|
|
*/
|
|
|
|
void fputs_test()
|
|
|
|
{
|
|
puts("\nUnbuffered fputs test");
|
|
if ((fp = fopen(TTY, "w")) != NULL) {
|
|
setbuf(fp, (char *) 0);
|
|
puts("ABCDEFGH<pause>");
|
|
puts("ABCDEFGH<pause>");
|
|
fputs("ABCDEFGH", fp), sleep(1);
|
|
fputs("\nABCDEFGH", fp), sleep(1);
|
|
fclose(fp);
|
|
puts("");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Fprintf Test
|
|
*
|
|
* Check that fprintf() works into unbuffered streams.
|
|
*/
|
|
|
|
void fprint_test()
|
|
|
|
{
|
|
puts("\nUnbuffered fprintf test");
|
|
if ((fp = fopen(TTY, "w")) != NULL) {
|
|
setbuf(fp, (char *) 0);
|
|
puts("ABCDEFGH<pause>");
|
|
puts("ABCDEFGH<pause>");
|
|
fprintf(fp, "ABCDEFGH"), sleep(1);
|
|
fprintf(fp, "\nABCDEFGH"), sleep(1);
|
|
fclose(fp);
|
|
puts("");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Fgets Test
|
|
*
|
|
* Check that fgets() works.
|
|
*/
|
|
|
|
void fgets_test()
|
|
|
|
{
|
|
char buf[80];
|
|
|
|
puts("\nFgets functionality");
|
|
puts("a");
|
|
puts("<pause>ab");
|
|
puts("<pause>abc");
|
|
puts("<pause>abcd");
|
|
puts("<pause>abcde");
|
|
puts("<pause>abcdef");
|
|
puts("<pause>abcdefg<pause>");
|
|
puts("<pause>abcdefg<pause>h");
|
|
if ((fp = fopen(TESTFILE, "w")) != NULL) {
|
|
fputs("a\n", fp);
|
|
fputs("ab\n", fp);
|
|
fputs("abc\n", fp);
|
|
fputs("abcd\n", fp);
|
|
fputs("abcde\n", fp);
|
|
fputs("abcdef\n", fp);
|
|
fputs("abcdefg\n", fp);
|
|
fputs("abcdefgh\n", fp);
|
|
fclose(fp);
|
|
if ((fp = fopen(TESTFILE, "r")) != NULL) {
|
|
while (fgets(buf, 8, fp) != NULL) {
|
|
fputs(buf, stdout);
|
|
fflush(stdout);
|
|
sleep(1);
|
|
}
|
|
fclose(fp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Word Read and Write Test
|
|
*
|
|
* Check that putw and getw work.
|
|
*/
|
|
|
|
void word_test()
|
|
|
|
{
|
|
int i, j;
|
|
|
|
puts("\nPutw and Readw Test");
|
|
if ((fp = fopen(TESTFILE, "w")) != NULL) {
|
|
for (i = 0; i < 256; i++)
|
|
putw(i, fp);
|
|
putc(0, fp);
|
|
fclose(fp);
|
|
if ((fp = fopen(TESTFILE, "r")) != NULL) {
|
|
for (i = 0; i < 256; i++) {
|
|
printf("\r%3d", i);
|
|
fflush(stdout);
|
|
if ((j = getw(fp)) != i) {
|
|
printf(" failed %d", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == 256 /* && getw(fp) == EOF && feof(fp)*/)
|
|
fputs(" ok", stdout);
|
|
puts("");
|
|
fclose(fp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Append Test
|
|
*
|
|
* Check that appends go to the end of the file.
|
|
*/
|
|
|
|
void a_test()
|
|
|
|
{
|
|
int ch;
|
|
|
|
puts("\nAppend Test");
|
|
if ((fp = fopen(TESTFILE, "w")) != NULL) {
|
|
putc('a', fp);
|
|
if ((fp = freopen(TESTFILE, "a", fp)) == NULL) {
|
|
puts("Cannot freopen file");
|
|
return;
|
|
}
|
|
if (fseek(fp, 0L, 0) == EOF) {
|
|
puts("Cannot fseek to start");
|
|
return;
|
|
}
|
|
putc('@', fp);
|
|
if ((fp = freopen(TESTFILE, "r", fp)) == NULL) {
|
|
puts("Cannot freopen file");
|
|
return;
|
|
}
|
|
if ((ch = getc(fp)) != 'a')
|
|
printf("Failed a - %c\n", ch);
|
|
else if ((ch = getc(fp)) != '@')
|
|
printf("Failed @ - %c\n", ch);
|
|
else if ((ch = getc(fp)) != EOF)
|
|
printf("Failed EOF - %d\n", ch);
|
|
else
|
|
puts("Ok");
|
|
fclose(fp);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Write and Read Update Test
|
|
*
|
|
* Write a file in update mode, then try to read it.
|
|
*/
|
|
|
|
void uwr_test()
|
|
|
|
{
|
|
int i, j;
|
|
|
|
puts("\nWrite and Read Update Test");
|
|
if ((fp = fopen(TESTFILE, "w+")) != NULL) {
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++)
|
|
putc(i, fp);
|
|
rewind(fp);
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
j = getc(fp);
|
|
if (j != UCHAR(i)) {
|
|
printf(" failed %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == (3*BUFSIZ)/2)
|
|
puts(" ok");
|
|
if (getc(fp) != EOF)
|
|
puts(" failed to find eof");
|
|
else {
|
|
for (i = 0; i < BUFSIZ/2; i++)
|
|
putc(i, fp);
|
|
fseek(fp, (long) (3*BUFSIZ)/2, SEEK_SET);
|
|
for (i = 0; i < BUFSIZ/2; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
j = getc(fp);
|
|
if (j != UCHAR(i)) {
|
|
printf(" failed %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == BUFSIZ/2)
|
|
puts(" ok");
|
|
}
|
|
fclose(fp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Write, Append and Read Update Test
|
|
*
|
|
* Write a file in update mode, close it, append to it and read it.
|
|
*/
|
|
|
|
void uawr_test()
|
|
|
|
{
|
|
int i, j;
|
|
|
|
puts("\nWrite, Append and Read Update Test");
|
|
if ((fp = fopen(TESTFILE, "w")) != NULL) {
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++)
|
|
putc(i, fp);
|
|
fclose(fp);
|
|
if ((fp = fopen(TESTFILE, "a+")) != NULL) {
|
|
for (i = 0; i < BUFSIZ/2; i++)
|
|
putc(i, fp);
|
|
fseek(fp, (long) (3*BUFSIZ)/2, SEEK_SET);
|
|
for (i = 0; i < BUFSIZ/2; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
j = getc(fp);
|
|
if (j != UCHAR(i)) {
|
|
printf(" failed %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == BUFSIZ/2)
|
|
puts(" ok");
|
|
rewind(fp);
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
j = getc(fp);
|
|
if (j != UCHAR(i)) {
|
|
printf(" failed at %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == (3*BUFSIZ)/2)
|
|
puts(" ok");
|
|
}
|
|
fclose(fp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Write, Read, Write and Read Update Test
|
|
*
|
|
* Write a file in update mode, read it, write it and read it.
|
|
*/
|
|
|
|
void uwrwr_test()
|
|
|
|
{
|
|
int i, j;
|
|
|
|
puts("\nWrite, Read, Write and Read Update Test");
|
|
if ((fp = fopen(TESTFILE, "w")) != NULL) {
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++)
|
|
putc(i, fp);
|
|
fclose(fp);
|
|
if ((fp = fopen(TESTFILE, "r+")) != NULL) {
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
j = getc(fp);
|
|
if (j != UCHAR(i)) {
|
|
printf(" failed %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == (3*BUFSIZ)/2)
|
|
puts(" ok");
|
|
if (getc(fp) != EOF)
|
|
puts(" failed to find eof");
|
|
else {
|
|
for (i = 0; i < BUFSIZ/2; i++)
|
|
putc(i, fp);
|
|
rewind(fp);
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++)
|
|
putc((3*BUFSIZ)/2-i, fp);
|
|
fseek(fp, (long) (3*BUFSIZ)/2, SEEK_SET);
|
|
for (i = 0; i < BUFSIZ/2; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
j = getc(fp);
|
|
if (j != UCHAR(i)) {
|
|
printf(" failed %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == BUFSIZ/2)
|
|
puts(" ok");
|
|
rewind(fp);
|
|
for (i = 0; i < (3*BUFSIZ)/2; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
j = getc(fp);
|
|
if (j != UCHAR((3*BUFSIZ)/2-i)) {
|
|
printf(" failed %d\n", j);
|
|
break;
|
|
}
|
|
}
|
|
if (i == (3*BUFSIZ)/2)
|
|
puts(" ok");
|
|
}
|
|
fclose(fp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Fwrite Test
|
|
*
|
|
* Test fwrite with small loads and large loads.
|
|
*/
|
|
|
|
void fwrite_test()
|
|
|
|
{
|
|
unsigned int i, j;
|
|
char buf[1023];
|
|
char bbuf[3071];
|
|
double sqrt();
|
|
void free();
|
|
char *p;
|
|
|
|
puts("\nFwrite Test");
|
|
if ((fp = fopen(TESTFILE, "w+")) != NULL) {
|
|
|
|
for (i = 0; i < sizeof(buf); i++)
|
|
buf[i] = i;
|
|
for (i = 0; i < sizeof(bbuf); i++)
|
|
bbuf[i] = 19-i;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
if (fwrite(buf, 1, sizeof(buf), fp) != sizeof(buf)) {
|
|
puts(" failed\n");
|
|
return;
|
|
}
|
|
putc(0, fp);
|
|
}
|
|
puts(" small write ok");
|
|
rewind(fp);
|
|
for (i = 0; i < 256; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
for (j = 0; j < sizeof(buf); j++) {
|
|
if (getc(fp) != UCHAR(j)) {
|
|
puts(" failed\n");
|
|
return;
|
|
}
|
|
}
|
|
if (getc(fp) != 0) {
|
|
puts(" failed\n");
|
|
return;
|
|
}
|
|
}
|
|
puts(" verified ok");
|
|
|
|
rewind(fp);
|
|
for (i = 0; i < 256; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
if (fwrite(bbuf, 1, sizeof(bbuf), fp) != sizeof(bbuf)) {
|
|
puts(" failed\n");
|
|
return;
|
|
}
|
|
putc(0, fp);
|
|
}
|
|
puts(" large write ok");
|
|
rewind(fp);
|
|
for (i = 0; i < 256; i++) {
|
|
printf("\r%4d", i);
|
|
fflush(stdout);
|
|
for (j = 0; j < sizeof(bbuf); j++) {
|
|
if (getc(fp) != UCHAR(19-j)) {
|
|
puts(" failed\n");
|
|
return;
|
|
}
|
|
}
|
|
if (getc(fp) != 0) {
|
|
puts(" failed\n");
|
|
return;
|
|
}
|
|
}
|
|
puts(" verified ok");
|
|
|
|
rewind(fp);
|
|
if ((p = (char *) malloc(48*1024)) == 0) {
|
|
puts("No memory for large write test");
|
|
return;
|
|
}
|
|
for (j = 13, i = 48*1024; --i; j++)
|
|
p[i] = j;
|
|
fwrite(p, 48*1024, 1, fp);
|
|
rewind(fp);
|
|
for (i = 48*1024; --i; )
|
|
p[i] = 0;
|
|
fread(p, 48*1024, 1, fp);
|
|
for (j = 13, i = 48*1024; --i; j++) {
|
|
if (i % 1024 == 0) {
|
|
printf("\r%5u", i);
|
|
fflush(stdout);
|
|
}
|
|
if (p[i] != (char) j) {
|
|
printf("\r%5u failed %d instead of %d\n", i, p[i], UCHAR(j));
|
|
free(p);
|
|
return;
|
|
}
|
|
}
|
|
printf("\r%5u ok\n", i);
|
|
free(p);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Test the exit code
|
|
*
|
|
* Load an exit handler and check buffer flushing.
|
|
*/
|
|
|
|
static void handler()
|
|
|
|
{
|
|
fputs("Exit handler called ok\n", fp);
|
|
fflush(fp);
|
|
fputs("Buffer flush ok\n", fp);
|
|
sleep(2);
|
|
}
|
|
|
|
void exit_test()
|
|
|
|
{
|
|
int atexit();
|
|
|
|
puts("\nExit Test");
|
|
if ((fp = fopen(TTY, "w")) == NULL) {
|
|
puts("Cannot open tty for exit test");
|
|
return;
|
|
}
|
|
setvbuf(fp, (char *) 0, _IOFBF, BUFSIZ);
|
|
if (atexit(handler) != 0)
|
|
puts("Exit handler not lodged");
|
|
}
|
|
|
|
/* Temporary File Test
|
|
*
|
|
* Check the names produced by tmpnam.
|
|
*/
|
|
|
|
void tmp_test()
|
|
|
|
{
|
|
int i;
|
|
char buf[20];
|
|
char *tf;
|
|
|
|
puts("\nTemporary File Names");
|
|
for (i = 10; i--; ) {
|
|
tf = tmpnam((char *) 0);
|
|
fputs(tf, stdout);
|
|
if (strlen(tf) == L_tmpnam-1)
|
|
puts(" ok");
|
|
else
|
|
puts(" failed");
|
|
}
|
|
if ((fp = tmpfile()) == 0) {
|
|
puts("Cannot make temporary file");
|
|
return;
|
|
}
|
|
printf("Temporary file");
|
|
fputs("123456", fp);
|
|
rewind(fp);
|
|
fgets(buf, 20, fp);
|
|
if (strcmp(buf, "123456") != 0)
|
|
puts(" failed");
|
|
else
|
|
puts(" ok");
|
|
}
|
|
|
|
/* Id test
|
|
*/
|
|
|
|
void id_test()
|
|
|
|
{
|
|
fputs("User id : ", stdout);
|
|
puts(cuserid((char *) 0));
|
|
fputs("Terminal : ", stdout);
|
|
puts(ctermid((char *) 0));
|
|
}
|
|
|
|
int main()
|
|
|
|
{
|
|
id_test();
|
|
lbw_test();
|
|
ubw_test();
|
|
bw_test();
|
|
fp_test();
|
|
sw_test();
|
|
sr_test();
|
|
frw_test();
|
|
fs_test();
|
|
fputs_test();
|
|
fprint_test();
|
|
gets_test();
|
|
fgets_test();
|
|
word_test();
|
|
fwrite_test();
|
|
a_test();
|
|
uwr_test();
|
|
uawr_test();
|
|
uwrwr_test();
|
|
tmp_test();
|
|
exit_test();
|
|
remove(TESTFILE);
|
|
return 0;
|
|
}
|