sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

tests cleanup

Browse source 
. make common.o link with the tests instead of being
	  #included as common.c
	. fix warnings about missing prototypes by declaring functions
	  static
	. reduces some duplicated code

Change-Id: Ic2a765d7f5886add5863190efec3fdd2d2ea2137
This commit is contained in:
Ben Gras 2013-04-16 16:04:46 +00:00
parent cef94e096e
commit 5977114c42
80 changed files with 364 additions and 327 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
test/Makefile
View file

@ -70,6 +70,10 @@ LDSTATIC= -dynamic
PROGS+= test63 mod PROGS+= test63 mod
.endif .endif
.for o in $(PROGS)
OBJS.${o} += common.o
.endfor
# LSC Make sure there is not leftover after a failed testrun # LSC Make sure there is not leftover after a failed testrun
clean: .PHONY .MAKE clean: .PHONY .MAKE
$(MAKE) -C select clean $(MAKE) -C select clean

23
test/common.c
View file

@ -1,6 +1,6 @@
/* Utility routines for Minix tests. /* Utility routines for Minix tests.
* This is designed to be #includ'ed near the top of test programs. It is * This is designed to be #includ'ed near the top of test programs. It is
* self-contained except for MAX_ERRORS. * self-contained except for max_error.
*/ */
#include <errno.h> #include <errno.h>
@ -10,18 +10,17 @@
#include <stdio.h> #include <stdio.h>
#include <sys/statvfs.h> #include <sys/statvfs.h>
#include "common.h"
int common_test_nr = -1, errct = 0, subtest; int common_test_nr = -1, errct = 0, subtest;
#define e(errn) e_f(__FILE__, __LINE__, (errn)) /* provide a default max_error symbol as Max_error with a value
* of 5. The test program can override it wit its own max_error
void cleanup(void); * symbol if it wants that this code will then use instead.
int does_fs_truncate(void); */
void e_f(char *file, int lineno, int n); __weak_alias(max_error,Max_error);
int name_max(char *path); int Max_error = 5;
void quit(void); extern int max_error;
void rm_rf_dir(int test_nr);
void rm_rf_ppdir(int test_nr);
void start(int test_nr);
void start(test_nr) void start(test_nr)
int test_nr; int test_nr;
@ -107,7 +106,7 @@ void e_f(char *file, int line, int n)
if (errct == 0) printf("\n"); /* finish header */ if (errct == 0) printf("\n"); /* finish header */
printf("%s:%d: Subtest %d, error %d, errno %d: %s\n", printf("%s:%d: Subtest %d, error %d, errno %d: %s\n",
file, line, subtest, n, errno, strerror(errno)); file, line, subtest, n, errno, strerror(errno));
if (++errct > MAX_ERROR) { if (++errct > max_error) {
printf("Too many errors; test aborted\n"); printf("Too many errors; test aborted\n");
cleanup(); cleanup();
exit(1); exit(1);

24
test/common.h Normal file
View file

@ -0,0 +1,24 @@
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
#include <sys/statvfs.h>
#define e(errn) e_f(__FILE__, __LINE__, (errn))
#define em(errn,msg) do { fprintf(stderr, "%s\n", msg); e(errn); } while(0)
void printprogress(char *msg, int i, int max);
void cleanup(void);
int does_fs_truncate(void);
void e_f(char *file, int lineno, int n);
int name_max(char *path);
void quit(void);
void rm_rf_dir(int test_nr);
void rm_rf_ppdir(int test_nr);
void start(int test_nr);
extern int common_test_nr, errct, subtest;

1
test/magic.h
View file

@ -7,3 +7,4 @@
#define MAGIC6 0x17D1FF #define MAGIC6 0x17D1FF
long hellodriver(void); long hellodriver(void);
long modfunction(long, long *, long);

31
test/t40a.c
View file

@ -22,16 +22,7 @@
#define MAX_ERROR 5 #define MAX_ERROR 5
int errct = 0, subtest = -1; #include "common.h"
void e(int n, char *s) {
printf("Subtest %d, error %d, %s\n", subtest, n, s);
if (errct++ > MAX_ERROR) {
printf("Too many errors; test aborted\n");
exit(errct);
}
}
int main(int argc, char **argv) { int main(int argc, char **argv) {
fd_set fds; fd_set fds;
@ -50,7 +41,7 @@ int main(int argc, char **argv) {
FD_ZERO(&fds); FD_ZERO(&fds);
for(i = 0; i < OPEN_MAX; i++) { for(i = 0; i < OPEN_MAX; i++) {
if(FD_ISSET(i, &fds)) { if(FD_ISSET(i, &fds)) {
e(1, "fd set should be completely empty"); em(1, "fd set should be completely empty");
break; break;
} }
} }
@ -59,7 +50,7 @@ int main(int argc, char **argv) {
for(i = 0; i < OPEN_MAX; i++) FD_SET(i, &fds); for(i = 0; i < OPEN_MAX; i++) FD_SET(i, &fds);
for(i = 0; i < OPEN_MAX; i++) { for(i = 0; i < OPEN_MAX; i++) {
if(!FD_ISSET(i, &fds)) { if(!FD_ISSET(i, &fds)) {
e(2, "fd set should be completely filled"); em(2, "fd set should be completely filled");
break; break;
} }
} }
@ -68,7 +59,7 @@ int main(int argc, char **argv) {
FD_ZERO(&fds); FD_ZERO(&fds);
for(i = 0; i < OPEN_MAX; i++) { for(i = 0; i < OPEN_MAX; i++) {
if(FD_ISSET(i, &fds)) { if(FD_ISSET(i, &fds)) {
e(3, "fd set should be completely empty"); em(3, "fd set should be completely empty");
break; break;
} }
} }
@ -77,7 +68,7 @@ int main(int argc, char **argv) {
for(i = 0; i < OPEN_MAX; i += 2) FD_SET(i, &fds); for(i = 0; i < OPEN_MAX; i += 2) FD_SET(i, &fds);
for(i = 0; i < OPEN_MAX - 1; i+= 2 ) { for(i = 0; i < OPEN_MAX - 1; i+= 2 ) {
if(!(FD_ISSET(i, &fds) && !FD_ISSET(i+1, &fds))) { if(!(FD_ISSET(i, &fds) && !FD_ISSET(i+1, &fds))) {
e(4, "bit pattern does not match"); em(4, "bit pattern does not match");
break; break;
} }
} }
@ -86,7 +77,7 @@ int main(int argc, char **argv) {
FD_ZERO(&fds); FD_ZERO(&fds);
for(i = 0; i < OPEN_MAX; i++) { for(i = 0; i < OPEN_MAX; i++) {
if(FD_ISSET(i, &fds)) { if(FD_ISSET(i, &fds)) {
e(5,"fd set should be completely empty"); em(5,"fd set should be completely empty");
break; break;
} }
} }
@ -95,7 +86,7 @@ int main(int argc, char **argv) {
for(i = 0; i < OPEN_MAX - 1; i += 2) FD_SET(i+1, &fds); for(i = 0; i < OPEN_MAX - 1; i += 2) FD_SET(i+1, &fds);
for(i = 0; i < OPEN_MAX - 1; i+= 2 ) { for(i = 0; i < OPEN_MAX - 1; i+= 2 ) {
if(!(FD_ISSET(i+1, &fds) && !FD_ISSET(i, &fds))) { if(!(FD_ISSET(i+1, &fds) && !FD_ISSET(i, &fds))) {
e(6, "bit pattern does not match"); em(6, "bit pattern does not match");
break; break;
} }
} }
@ -104,7 +95,7 @@ int main(int argc, char **argv) {
FD_ZERO(&fds); FD_ZERO(&fds);
for(i = 0; i < OPEN_MAX; i++) { for(i = 0; i < OPEN_MAX; i++) {
if(FD_ISSET(i, &fds)) { if(FD_ISSET(i, &fds)) {
e(7, "fd set should be completely empty"); em(7, "fd set should be completely empty");
break; break;
} }
} }
@ -114,7 +105,7 @@ int main(int argc, char **argv) {
for(i = 0; i < OPEN_MAX; i++) FD_CLR(i, &fds); /* Clear all bits */ for(i = 0; i < OPEN_MAX; i++) FD_CLR(i, &fds); /* Clear all bits */
for(i = 0; i < OPEN_MAX; i++) { for(i = 0; i < OPEN_MAX; i++) {
if(FD_ISSET(i, &fds)) { if(FD_ISSET(i, &fds)) {
e(8, "all bits in fd set should be cleared"); em(8, "all bits in fd set should be cleared");
break; break;
} }
} }
@ -123,7 +114,7 @@ int main(int argc, char **argv) {
FD_ZERO(&fds); FD_ZERO(&fds);
for(i = 0; i < OPEN_MAX; i++) { for(i = 0; i < OPEN_MAX; i++) {
if(FD_ISSET(i, &fds)) { if(FD_ISSET(i, &fds)) {
e(9, "fd set should be completely empty"); em(9, "fd set should be completely empty");
break; break;
} }
} }
@ -132,7 +123,7 @@ int main(int argc, char **argv) {
for(i = 0; i < OPEN_MAX; i += 2) FD_CLR(i, &fds); /* Clear all bits */ for(i = 0; i < OPEN_MAX; i += 2) FD_CLR(i, &fds); /* Clear all bits */
for(i = 0; i < OPEN_MAX; i += 2) { for(i = 0; i < OPEN_MAX; i += 2) {
if(FD_ISSET(i, &fds)) { if(FD_ISSET(i, &fds)) {
e(10, "all even bits in fd set should be cleared"); em(10, "all even bits in fd set should be cleared");
break; break;
} }
} }

44
test/t40b.c
View file

@ -23,24 +23,16 @@
#include <errno.h> #include <errno.h>
#include <time.h> #include <time.h>
#include "common.h"
#define FILE1 "selecttestb-1" #define FILE1 "selecttestb-1"
#define FILES 2 #define FILES 2
#define TIME 3 #define TIME 3
#define MAX_ERROR 10 #define MAX_ERROR 10
int errct = 0, subtest = -1;
char errorbuf[1000]; char errorbuf[1000];
void e(int n, char *s) {
printf("Subtest %d, error %d, %s\n", subtest, n, s);
if (errct++ > MAX_ERROR) {
printf("Too many errors; test aborted\n");
exit(errct);
}
}
int main(int argc, char **argv) { int main(int argc, char **argv) {
int fd1, fd2, retval; int fd1, fd2, retval;
fd_set fds_read, fds_write, fds_error; fd_set fds_read, fds_write, fds_error;
@ -64,7 +56,7 @@ int main(int argc, char **argv) {
if((fd1 = open(FILE1, O_WRONLY|O_CREAT, 0644)) == -1) { if((fd1 = open(FILE1, O_WRONLY|O_CREAT, 0644)) == -1) {
snprintf(errorbuf, sizeof(errorbuf), "failed to open file %s for writing", snprintf(errorbuf, sizeof(errorbuf), "failed to open file %s for writing",
FILE1); FILE1);
e(1, errorbuf); em(1, errorbuf);
perror(NULL); perror(NULL);
exit(1); exit(1);
} }
@ -73,7 +65,7 @@ int main(int argc, char **argv) {
if((fd2 = open(FILE1, O_RDONLY)) == -1) { if((fd2 = open(FILE1, O_RDONLY)) == -1) {
snprintf(errorbuf, sizeof(errorbuf), "failed to open file %s for reading", snprintf(errorbuf, sizeof(errorbuf), "failed to open file %s for reading",
FILE1); FILE1);
e(2, errorbuf); em(2, errorbuf);
perror(NULL); perror(NULL);
exit(1); exit(1);
} }
@ -94,20 +86,20 @@ int main(int argc, char **argv) {
/* Correct amount of ready file descriptors? 1 read + 1 write + 2 errors */ /* Correct amount of ready file descriptors? 1 read + 1 write + 2 errors */
if(retval != 4) { if(retval != 4) {
e(3, "four fds should be set"); em(3, "four fds should be set");
} }
/* Test resulting bit masks */ /* Test resulting bit masks */
if(!FD_ISSET(fd1, &fds_write)) e(4, "write should be set"); if(!FD_ISSET(fd1, &fds_write)) em(4, "write should be set");
if(!FD_ISSET(fd2, &fds_read)) e(5, "read should be set"); if(!FD_ISSET(fd2, &fds_read)) em(5, "read should be set");
if(!FD_ISSET(fd1, &fds_error)) e(6, "error should be set"); if(!FD_ISSET(fd1, &fds_error)) em(6, "error should be set");
if(!FD_ISSET(fd2, &fds_error)) e(7, "error should be set"); if(!FD_ISSET(fd2, &fds_error)) em(7, "error should be set");
/* Was it instantaneous? */ /* Was it instantaneous? */
if(end-start != TIME - TIME) { if(end-start != TIME - TIME) {
snprintf(errorbuf,sizeof(errorbuf),"time spent blocking is not %d, but %ld", snprintf(errorbuf,sizeof(errorbuf),"time spent blocking is not %d, but %ld",
TIME - TIME, (long int) (end-start)); TIME - TIME, (long int) (end-start));
e(8, errorbuf); em(8, errorbuf);
} }
/* Wait for read to become ready on O_WRONLY. This should fail immediately. */ /* Wait for read to become ready on O_WRONLY. This should fail immediately. */
@ -120,10 +112,10 @@ int main(int argc, char **argv) {
retval = select(fd2+1, &fds_read, NULL, &fds_error, &tv); retval = select(fd2+1, &fds_read, NULL, &fds_error, &tv);
/* Correct amount of ready file descriptors? 1 read + 2 error */ /* Correct amount of ready file descriptors? 1 read + 2 error */
if(retval != 3) e(9, "incorrect amount of ready file descriptors"); if(retval != 3) em(9, "incorrect amount of ready file descriptors");
if(!FD_ISSET(fd1, &fds_read)) e(10, "read should be set"); if(!FD_ISSET(fd1, &fds_read)) em(10, "read should be set");
if(!FD_ISSET(fd1, &fds_error)) e(11, "error should be set"); if(!FD_ISSET(fd1, &fds_error)) em(11, "error should be set");
if(!FD_ISSET(fd2, &fds_error)) e(12, "error should be set"); if(!FD_ISSET(fd2, &fds_error)) em(12, "error should be set");
/* Try again as above, bit this time with O_RDONLY in the write set */ /* Try again as above, bit this time with O_RDONLY in the write set */
FD_ZERO(&fds_error); FD_ZERO(&fds_error);
@ -135,10 +127,10 @@ int main(int argc, char **argv) {
retval = select(fd2+1, NULL, &fds_write, &fds_error, &tv); retval = select(fd2+1, NULL, &fds_write, &fds_error, &tv);
/* Correct amount of ready file descriptors? 1 write + 2 errors */ /* Correct amount of ready file descriptors? 1 write + 2 errors */
if(retval != 3) e(13, "incorrect amount of ready file descriptors"); if(retval != 3) em(13, "incorrect amount of ready file descriptors");
if(!FD_ISSET(fd2, &fds_write)) e(14, "write should be set"); if(!FD_ISSET(fd2, &fds_write)) em(14, "write should be set");
if(!FD_ISSET(fd1, &fds_error)) e(15, "error should be set"); if(!FD_ISSET(fd1, &fds_error)) em(15, "error should be set");
if(!FD_ISSET(fd2, &fds_error)) e(16, "error should be set"); if(!FD_ISSET(fd2, &fds_error)) em(16, "error should be set");
close(fd1); close(fd1);
close(fd2); close(fd2);

35
test/t40c.c
View file

@ -21,23 +21,14 @@
#include <sys/wait.h> #include <sys/wait.h>
#include <string.h> #include <string.h>
#include "common.h"
#define TERMINALW "/dev/ttypf" #define TERMINALW "/dev/ttypf"
#define TERMINALR "/dev/ptypf" #define TERMINALR "/dev/ptypf"
#define SENDSTRING "minixrocks" #define SENDSTRING "minixrocks"
#define MAX_ERROR 5 #define MAX_ERROR 5
int errct = 0, subtest = -1; static void open_terminal(int *child_fd, int *parent_fd) {
void e(int n, char *s) {
printf("Subtest %d, error %d, %s\n", subtest, n, s);
if (errct++ > MAX_ERROR) {
printf("Too many errors; test aborted\n");
exit(errct);
}
}
void open_terminal(int *child_fd, int *parent_fd) {
int fd1, fd2, i; int fd1, fd2, i;
char opentermw[5+OPEN_MAX+1]; char opentermw[5+OPEN_MAX+1];
char opentermr[5+OPEN_MAX+1]; char opentermr[5+OPEN_MAX+1];
@ -68,7 +59,7 @@ void open_terminal(int *child_fd, int *parent_fd) {
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
int do_child(int terminal) { static int do_child(int terminal) {
struct timeval tv; struct timeval tv;
/* Going to sleep for two seconds to allow the parent proc to get ready */ /* Going to sleep for two seconds to allow the parent proc to get ready */
@ -86,7 +77,7 @@ int do_child(int terminal) {
exit(0); exit(0);
} }
int do_parent(int child, int terminal) { static int do_parent(int child, int terminal) {
fd_set fds_read, fds_write, fds_error; fd_set fds_read, fds_write, fds_error;
int retval; int retval;
@ -103,21 +94,21 @@ int do_parent(int child, int terminal) {
* sub-test as reading from fd is blocking at this point. */ * sub-test as reading from fd is blocking at this point. */
retval = select(terminal+1, &fds_read, &fds_write, &fds_error, NULL); retval = select(terminal+1, &fds_read, &fds_write, &fds_error, NULL);
if(retval != 1) e(1, "incorrect amount of ready file descriptors"); if(retval != 1) em(1, "incorrect amount of ready file descriptors");
if(FD_ISSET(terminal, &fds_read)) e(2, "read should NOT be set"); if(FD_ISSET(terminal, &fds_read)) em(2, "read should NOT be set");
if(!FD_ISSET(terminal, &fds_write)) e(3, "write should be set"); if(!FD_ISSET(terminal, &fds_write)) em(3, "write should be set");
if(FD_ISSET(terminal, &fds_error)) e(4, "error should NOT be set"); if(FD_ISSET(terminal, &fds_error)) em(4, "error should NOT be set");
/* Block until ready; until child wrote stuff */ /* Block until ready; until child wrote stuff */
FD_ZERO(&fds_read); FD_ZERO(&fds_write); FD_ZERO(&fds_error); FD_ZERO(&fds_read); FD_ZERO(&fds_write); FD_ZERO(&fds_error);
FD_SET(terminal, &fds_read); FD_SET(terminal, &fds_read);
retval = select(terminal+1, &fds_read, NULL, &fds_error, NULL); retval = select(terminal+1, &fds_read, NULL, &fds_error, NULL);
if(retval != 1) e(5, "incorrect amount of ready file descriptors"); if(retval != 1) em(5, "incorrect amount of ready file descriptors");
if(!FD_ISSET(terminal, &fds_read)) e(6, "read should be set"); if(!FD_ISSET(terminal, &fds_read)) em(6, "read should be set");
if(FD_ISSET(terminal, &fds_error)) e(7, "error should not be set"); if(FD_ISSET(terminal, &fds_error)) em(7, "error should not be set");
FD_ZERO(&fds_read); FD_ZERO(&fds_error); FD_ZERO(&fds_read); FD_ZERO(&fds_error);
@ -125,7 +116,7 @@ int do_parent(int child, int terminal) {
retval = select(terminal+1, NULL, &fds_write, NULL, NULL); retval = select(terminal+1, NULL, &fds_write, NULL, NULL);
/* As it is impossible to write to a read only fd, this select should return /* As it is impossible to write to a read only fd, this select should return
* immediately with fd set in fds_write. */ * immediately with fd set in fds_write. */
if(retval != 1) e(8, "incorrect amount or ready file descriptors"); if(retval != 1) em(8, "incorrect amount or ready file descriptors");
close(terminal); close(terminal);
waitpid(child, &retval, 0); waitpid(child, &retval, 0);

64
test/t40d.c
View file

@ -44,22 +44,14 @@
#define DO_TIMEOUT 7 #define DO_TIMEOUT 7
#define MAX_ERROR 5 #define MAX_ERROR 5
int errct = 0, subtest = -1; #include "common.h"
char errbuf[1000]; char errbuf[1000];
int fd_ap[2]; /* Anonymous pipe; read from fd_ap[0], write to fd_ap[1] */ int fd_ap[2]; /* Anonymous pipe; read from fd_ap[0], write to fd_ap[1] */
int fd_np1; /* Named pipe */ int fd_np1; /* Named pipe */
int fd_np2; /* Named pipe */ int fd_np2; /* Named pipe */
void e(int n, char *s) { static void do_child(void) {
printf("Subtest %d, error %d, %s\n", subtest, n, s);
if (errct++ > MAX_ERROR) {
printf("Too many errors; test aborted\n");
exit(errct);
}
}
void do_child(void) {
struct timeval tv; struct timeval tv;
/* Open named pipe for writing. This will block until a reader arrives. */ /* Open named pipe for writing. This will block until a reader arrives. */
@ -125,7 +117,8 @@ void do_child(void) {
exit(0); exit(0);
} }
int count_fds(int nfds, fd_set *fds) { #if 0
static int count_fds(int nfds, fd_set *fds) {
/* Return number of bits set in fds */ /* Return number of bits set in fds */
int i, result = 0; int i, result = 0;
assert(fds != NULL && nfds > 0); assert(fds != NULL && nfds > 0);
@ -134,8 +127,9 @@ int count_fds(int nfds, fd_set *fds) {
} }
return result; return result;
} }
#endif
int empty_fds(int nfds, fd_set *fds) { static int empty_fds(int nfds, fd_set *fds) {
/* Returns nonzero if the first bits up to nfds in fds are not set */ /* Returns nonzero if the first bits up to nfds in fds are not set */
int i; int i;
assert(fds != NULL && nfds > 0); assert(fds != NULL && nfds > 0);
@ -143,7 +137,7 @@ int empty_fds(int nfds, fd_set *fds) {
return 1; return 1;
} }
int compare_fds(int nfds, fd_set *lh, fd_set *rh) { static int compare_fds(int nfds, fd_set *lh, fd_set *rh) {
/* Returns nonzero if lh equals rh up to nfds bits */ /* Returns nonzero if lh equals rh up to nfds bits */
int i; int i;
assert(lh != NULL && rh != NULL && nfds > 0); assert(lh != NULL && rh != NULL && nfds > 0);
@ -156,7 +150,8 @@ int compare_fds(int nfds, fd_set *lh, fd_set *rh) {
return 1; return 1;
} }
void dump_fds(int nfds, fd_set *fds) { #if 0
static void dump_fds(int nfds, fd_set *fds) {
/* Print a graphical representation of bits in fds */ /* Print a graphical representation of bits in fds */
int i; int i;
if(fds != NULL && nfds > 0) { if(fds != NULL && nfds > 0) {
@ -164,8 +159,9 @@ void dump_fds(int nfds, fd_set *fds) {
printf("\n"); printf("\n");
} }
} }
#endif
void do_parent(int child) { static void do_parent(int child) {
fd_set fds_read, fds_write, fds_error; fd_set fds_read, fds_write, fds_error;
fd_set fds_compare_read, fds_compare_write; fd_set fds_compare_read, fds_compare_write;
struct timeval tv; struct timeval tv;
@ -205,16 +201,16 @@ void do_parent(int child) {
if(retval <= 0) { if(retval <= 0) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : "")); "one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : ""));
e(1, errbuf); em(1, errbuf);
} }
if(!empty_fds(fd_np1+1,&fds_read)) e(2, "no read bits should be set"); if(!empty_fds(fd_np1+1,&fds_read)) em(2, "no read bits should be set");
/* Make sure the write bit is set (and just 1 bit) */ /* Make sure the write bit is set (and just 1 bit) */
FD_ZERO(&fds_compare_write); FD_SET(fd_np1, &fds_compare_write); FD_ZERO(&fds_compare_write); FD_SET(fd_np1, &fds_compare_write);
if(!compare_fds(fd_np1+1, &fds_compare_write, &fds_write)) if(!compare_fds(fd_np1+1, &fds_compare_write, &fds_write))
e(3, "write should be set"); em(3, "write should be set");
/* Clear sets and set up new bit masks */ /* Clear sets and set up new bit masks */
FD_ZERO(&fds_read); FD_ZERO(&fds_write); FD_ZERO(&fds_read); FD_ZERO(&fds_write);
@ -231,14 +227,14 @@ void do_parent(int child) {
if(retval != 1) { if(retval != 1) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : "")); "one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : ""));
e(4, errbuf); em(4, errbuf);
} }
if(!FD_ISSET(fd_np1, &fds_read)) e(5, "read should be set"); if(!FD_ISSET(fd_np1, &fds_read)) em(5, "read should be set");
/* Note that we left the write set empty. This should be equivalent to /* Note that we left the write set empty. This should be equivalent to
* setting this parameter to NULL. */ * setting this parameter to NULL. */
if(!empty_fds(fd_np1+1, &fds_write)) e(6, "write should NOT be set"); if(!empty_fds(fd_np1+1, &fds_write)) em(6, "write should NOT be set");
/* In case something went wrong above, we might end up with a child process /* In case something went wrong above, we might end up with a child process
* blocking on a write call we close the file descriptor now. Synchronize on * blocking on a write call we close the file descriptor now. Synchronize on
@ -284,21 +280,21 @@ void do_parent(int child) {
if(retval <= 0) { if(retval <= 0) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"two fds should be set%s", (retval == 0 ? " (TIMEOUT)" : "")); "two fds should be set%s", (retval == 0 ? " (TIMEOUT)" : ""));
e(7, errbuf); em(7, errbuf);
} }
/* Make sure read bit is set (and just 1 bit) */ /* Make sure read bit is set (and just 1 bit) */
FD_ZERO(&fds_compare_read); FD_SET(fd_np2, &fds_compare_read); FD_ZERO(&fds_compare_read); FD_SET(fd_np2, &fds_compare_read);
if(!compare_fds(fd_np2+1, &fds_compare_read, &fds_read)) if(!compare_fds(fd_np2+1, &fds_compare_read, &fds_read))
e(8, "read should be set"); em(8, "read should be set");
/* Write bit should be set (and just 1 bit) */ /* Write bit should be set (and just 1 bit) */
FD_ZERO(&fds_compare_write); FD_SET(fd_np2, &fds_compare_write); FD_ZERO(&fds_compare_write); FD_SET(fd_np2, &fds_compare_write);
if(!compare_fds(fd_np2+1, &fds_compare_write, &fds_write)) if(!compare_fds(fd_np2+1, &fds_compare_write, &fds_write))
e(9, "write should be set"); em(9, "write should be set");
if(!empty_fds(fd_np2+1, &fds_error)) if(!empty_fds(fd_np2+1, &fds_error))
e(10, "Error should NOT be set"); em(10, "Error should NOT be set");
FD_ZERO(&fds_read); FD_ZERO(&fds_write); FD_ZERO(&fds_read); FD_ZERO(&fds_write);
FD_SET(fd_np2, &fds_write); FD_SET(fd_np2, &fds_write);
@ -310,10 +306,10 @@ void do_parent(int child) {
if(retval != 1) { if(retval != 1) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : "")); "one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : ""));
e(11, errbuf); em(11, errbuf);
} }
if(!empty_fds(fd_np2+1, &fds_read)) e(12, "read should NOT be set"); if(!empty_fds(fd_np2+1, &fds_read)) em(12, "read should NOT be set");
/* Anonymous pipe */ /* Anonymous pipe */
@ -328,13 +324,13 @@ void do_parent(int child) {
if(retval != 1) { if(retval != 1) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : "")); "one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : ""));
e(13, errbuf); em(13, errbuf);
} }
/* Make sure write bit is set (and just 1 bit) */ /* Make sure write bit is set (and just 1 bit) */
FD_ZERO(&fds_compare_write); FD_SET(fd_ap[1], &fds_compare_write); FD_ZERO(&fds_compare_write); FD_SET(fd_ap[1], &fds_compare_write);
if(!compare_fds(fd_ap[1]+1, &fds_compare_write, &fds_write)) if(!compare_fds(fd_ap[1]+1, &fds_compare_write, &fds_write))
e(14, "write should be set"); em(14, "write should be set");
/* Intentionally test reading from pipe and letting it time out. */ /* Intentionally test reading from pipe and letting it time out. */
FD_SET(fd_ap[0], &fds_read); FD_SET(fd_ap[0], &fds_read);
@ -345,14 +341,14 @@ void do_parent(int child) {
end = time(NULL); end = time(NULL);
/* Did we time out? */ /* Did we time out? */
if(retval != 0) e(15, "we should have timed out"); if(retval != 0) em(15, "we should have timed out");
/* Did it take us approximately 1 second? */ /* Did it take us approximately 1 second? */
if((int) (end - start) != 1) { if((int) (end - start) != 1) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"time out is not 1 second (instead, it is %ld)", "time out is not 1 second (instead, it is %ld)",
(long int) (end - start)); (long int) (end - start));
e(16, errbuf); em(16, errbuf);
} }
/* Do another read, but this time we expect incoming data from child. */ /* Do another read, but this time we expect incoming data from child. */
@ -363,12 +359,12 @@ void do_parent(int child) {
retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv); retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv);
/* Correct amount of ready file descriptors? Just 1 read. */ /* Correct amount of ready file descriptors? Just 1 read. */
if(retval != 1) e(17, "one fd should be set"); if(retval != 1) em(17, "one fd should be set");
/* Is the read bit set? And just 1 bit. */ /* Is the read bit set? And just 1 bit. */
FD_ZERO(&fds_compare_read); FD_SET(fd_ap[0], &fds_compare_read); FD_ZERO(&fds_compare_read); FD_SET(fd_ap[0], &fds_compare_read);
if(!compare_fds(fd_ap[0]+1, &fds_compare_read, &fds_read)) if(!compare_fds(fd_ap[0]+1, &fds_compare_read, &fds_read))
e(18, "read should be set."); em(18, "read should be set.");
/* By convention fd_ap[0] is meant to be used for reading from the pipe and /* By convention fd_ap[0] is meant to be used for reading from the pipe and
* fd_ap[1] is meant for writing, where fd_ap is a an anonymous pipe. * fd_ap[1] is meant for writing, where fd_ap is a an anonymous pipe.

42
test/t40e.c
View file

@ -62,6 +62,8 @@
#include <assert.h> #include <assert.h>
#include <netdb.h> #include <netdb.h>
#include "common.h"
#define DO_HANDLEDATA 1 #define DO_HANDLEDATA 1
#define DO_PAUSE 3 #define DO_PAUSE 3
#define DO_TIMEOUT 7 #define DO_TIMEOUT 7
@ -69,22 +71,13 @@
#define NUMCHILDREN 5 #define NUMCHILDREN 5
#define MAX_ERROR 10 #define MAX_ERROR 10
int errct = 0, subtest = -1;
char errbuf[1000]; char errbuf[1000];
void e(int n, char *s) {
printf("Subtest %d, error %d, %s\n", subtest, n, s);
if (errct++ > MAX_ERROR) {
printf("Too many errors; test aborted\n");
exit(errct);
}
}
/* All *_fds routines are helping routines. They intentionally use FD_* macros /* All *_fds routines are helping routines. They intentionally use FD_* macros
in order to prevent making assumptions on how the macros are implemented.*/ in order to prevent making assumptions on how the macros are implemented.*/
int count_fds(int nfds, fd_set *fds) { #if 0
static int count_fds(int nfds, fd_set *fds) {
/* Return number of bits set in fds */ /* Return number of bits set in fds */
int i, result = 0; int i, result = 0;
assert(fds != NULL && nfds > 0); assert(fds != NULL && nfds > 0);
@ -93,8 +86,9 @@ int count_fds(int nfds, fd_set *fds) {
} }
return result; return result;
} }
#endif
int empty_fds(int nfds, fd_set *fds) { static int empty_fds(int nfds, fd_set *fds) {
/* Returns nonzero if the first bits up to nfds in fds are not set */ /* Returns nonzero if the first bits up to nfds in fds are not set */
int i; int i;
assert(fds != NULL && nfds > 0); assert(fds != NULL && nfds > 0);
@ -102,7 +96,7 @@ int empty_fds(int nfds, fd_set *fds) {
return 1; return 1;
} }
int compare_fds(int nfds, fd_set *lh, fd_set *rh) { static int compare_fds(int nfds, fd_set *lh, fd_set *rh) {
/* Returns nonzero if lh equals rh up to nfds bits */ /* Returns nonzero if lh equals rh up to nfds bits */
int i; int i;
assert(lh != NULL && rh != NULL && nfds > 0); assert(lh != NULL && rh != NULL && nfds > 0);
@ -115,7 +109,8 @@ int compare_fds(int nfds, fd_set *lh, fd_set *rh) {
return 1; return 1;
} }
void dump_fds(int nfds, fd_set *fds) { #if 0
static void dump_fds(int nfds, fd_set *fds) {
/* Print a graphical representation of bits in fds */ /* Print a graphical representation of bits in fds */
int i; int i;
if(fds != NULL && nfds > 0) { if(fds != NULL && nfds > 0) {
@ -123,8 +118,9 @@ void dump_fds(int nfds, fd_set *fds) {
printf("\n"); printf("\n");
} }
} }
#endif
void do_child(int childno) { static void do_child(int childno) {
int fd_sock, port; int fd_sock, port;
int retval; int retval;
@ -203,11 +199,11 @@ void do_child(int childno) {
retval = select(fd_sock+1, NULL, &fds_write, NULL, &tv); retval = select(fd_sock+1, NULL, &fds_write, NULL, &tv);
if(retval <= 0) e(6, "expected one fd to be ready"); if(retval <= 0) em(6, "expected one fd to be ready");
FD_ZERO(&fds_compare_write); FD_SET(fd_sock, &fds_compare_write); FD_ZERO(&fds_compare_write); FD_SET(fd_sock, &fds_compare_write);
if(!compare_fds(fd_sock+1, &fds_compare_write, &fds_compare_write)) if(!compare_fds(fd_sock+1, &fds_compare_write, &fds_compare_write))
e(7, "write should be set"); em(7, "write should be set");
} }
if(close(fd_sock) < 0) { if(close(fd_sock) < 0) {
@ -218,7 +214,7 @@ void do_child(int childno) {
exit(errct); exit(errct);
} }
void do_parent(void) { static void do_parent(void) {
#if !defined(__minix) #if !defined(__minix)
int yes = 1; int yes = 1;
#endif #endif
@ -317,7 +313,7 @@ void do_parent(void) {
if(retval <= 0) { if(retval <= 0) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"two fds should be set%s", (retval == 0 ? " (TIMEOUT)" : "")); "two fds should be set%s", (retval == 0 ? " (TIMEOUT)" : ""));
e(1, errbuf); em(1, errbuf);
} }
FD_ZERO(&fds_compare_read); FD_ZERO(&fds_compare_write); FD_ZERO(&fds_compare_read); FD_ZERO(&fds_compare_write);
@ -327,10 +323,10 @@ void do_parent(void) {
is not specified and the other side might have data ready for us to read is not specified and the other side might have data ready for us to read
*/ */
if(!compare_fds(sockets[childresults]+1, &fds_compare_write, &fds_write)) if(!compare_fds(sockets[childresults]+1, &fds_compare_write, &fds_write))
e(2, "write should be set"); em(2, "write should be set");
if(!empty_fds(sockets[childresults]+1, &fds_error)) if(!empty_fds(sockets[childresults]+1, &fds_error))
e(3, "no error should be set"); em(3, "no error should be set");
} }
@ -356,13 +352,13 @@ void do_parent(void) {
if(retval <= 0) { if(retval <= 0) {
snprintf(errbuf, sizeof(errbuf), snprintf(errbuf, sizeof(errbuf),
"one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : "")); "one fd should be set%s", (retval == 0 ? " (TIMEOUT)" : ""));
e(4, errbuf); em(4, errbuf);
} }
/* Check read bit is set */ /* Check read bit is set */
FD_ZERO(&fds_compare_read); FD_SET(fd_sock, &fds_compare_read); FD_ZERO(&fds_compare_read); FD_SET(fd_sock, &fds_compare_read);
if(!compare_fds(fd_sock+1, &fds_compare_read, &fds_read)) if(!compare_fds(fd_sock+1, &fds_compare_read, &fds_read))
e(5, "read should be set"); em(5, "read should be set");
/* Accept incoming connection to unblock child 5 */ /* Accept incoming connection to unblock child 5 */

39
test/t40f.c
View file

@ -19,6 +19,8 @@
#include <string.h> #include <string.h>
#include <signal.h> #include <signal.h>
#include "common.h"
#define DO_HANDLEDATA 1 #define DO_HANDLEDATA 1
#define DO_PAUSE 3 #define DO_PAUSE 3
#define DO_TIMEOUT 7 #define DO_TIMEOUT 7
@ -27,23 +29,14 @@
#define DELTA(x,y) (x.tv_sec - y.tv_sec) * CLOCKS_PER_SEC \ #define DELTA(x,y) (x.tv_sec - y.tv_sec) * CLOCKS_PER_SEC \
+ (x.tv_usec - y.tv_usec) * CLOCKS_PER_SEC / 1000000 + (x.tv_usec - y.tv_usec) * CLOCKS_PER_SEC / 1000000
int errct = 0, subtest = -1, got_signal = 0; int got_signal = 0;
int fd_ap[2]; int fd_ap[2];
void catch_signal(int sig_no) { static void catch_signal(int sig_no) {
got_signal = 1; got_signal = 1;
} }
void e(int n, char *s) { static float compute_diff(struct timeval start, struct timeval end, float compare) {
printf("Subtest %d, error %d, %s\n", subtest, n, s);
if (errct++ > MAX_ERROR) {
printf("Too many errors; test aborted\n");
exit(errct);
}
}
float compute_diff(struct timeval start, struct timeval end, float compare) {
/* Compute time difference. It is assumed that the value of start <= end. */ /* Compute time difference. It is assumed that the value of start <= end. */
clock_t delta; clock_t delta;
int seconds, hundreths; int seconds, hundreths;
@ -60,7 +53,7 @@ float compute_diff(struct timeval start, struct timeval end, float compare) {
return diff; return diff;
} }
void do_child(void) { static void do_child(void) {
struct timeval tv; struct timeval tv;
/* Let the parent do initial read and write tests from and to the pipe. */ /* Let the parent do initial read and write tests from and to the pipe. */
@ -75,7 +68,7 @@ void do_child(void) {
exit(0); exit(0);
} }
void do_parent(int child) { static void do_parent(int child) {
fd_set fds_read; fd_set fds_read;
struct timeval tv, start_time, end_time; struct timeval tv, start_time, end_time;
int retval; int retval;
@ -96,13 +89,13 @@ void do_parent(int child) {
(void) gettimeofday(&end_time, NULL); /* Record ending time */ (void) gettimeofday(&end_time, NULL); /* Record ending time */
/* Did we time out? */ /* Did we time out? */
if(retval != 0) e(1, "Should have timed out"); if(retval != 0) em(1, "Should have timed out");
/* Approximately right? The standard does not specify how precise the timeout /* Approximately right? The standard does not specify how precise the timeout
should be. Instead, the granularity is implementation-defined. In this should be. Instead, the granularity is implementation-defined. In this
test we assume that the difference should be no more than half a second.*/ test we assume that the difference should be no more than half a second.*/
if(compute_diff(start_time, end_time, DO_PAUSE) > DO_DELTA) if(compute_diff(start_time, end_time, DO_PAUSE) > DO_DELTA)
e(2, "Time difference too large"); em(2, "Time difference too large");
/* Let's wait for another DO_PAUSE seconds, expressed as microseconds */ /* Let's wait for another DO_PAUSE seconds, expressed as microseconds */
FD_ZERO(&fds_read); FD_ZERO(&fds_read);
@ -114,9 +107,9 @@ void do_parent(int child) {
retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv); retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv);
(void) gettimeofday(&end_time, NULL); /* Record ending time */ (void) gettimeofday(&end_time, NULL); /* Record ending time */
if(retval != 0) e(3, "Should have timed out"); if(retval != 0) em(3, "Should have timed out");
if(compute_diff(start_time, end_time, DO_PAUSE) > DO_DELTA) if(compute_diff(start_time, end_time, DO_PAUSE) > DO_DELTA)
e(4, "Time difference too large"); em(4, "Time difference too large");
/* Let's wait for another DO_PAUSE seconds, expressed in seconds and micro /* Let's wait for another DO_PAUSE seconds, expressed in seconds and micro
seconds. */ seconds. */
@ -129,9 +122,9 @@ void do_parent(int child) {
retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv); retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv);
(void) gettimeofday(&end_time, NULL); /* Record ending time */ (void) gettimeofday(&end_time, NULL); /* Record ending time */
if(retval != 0) e(5, "Should have timed out"); if(retval != 0) em(5, "Should have timed out");
if(compute_diff(start_time, end_time, DO_PAUSE) > DO_DELTA) if(compute_diff(start_time, end_time, DO_PAUSE) > DO_DELTA)
e(6, "Time difference too large"); em(6, "Time difference too large");
/* Finally, we test if our timeout is interrupted by a signal */ /* Finally, we test if our timeout is interrupted by a signal */
FD_ZERO(&fds_read); FD_ZERO(&fds_read);
@ -143,11 +136,11 @@ void do_parent(int child) {
retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv); retval = select(fd_ap[0]+1, &fds_read, NULL, NULL, &tv);
(void) gettimeofday(&end_time, NULL); /* Record ending time */ (void) gettimeofday(&end_time, NULL); /* Record ending time */
if(retval != -1) e(7, "Should have been interrupted"); if(retval != -1) em(7, "Should have been interrupted");
if(compute_diff(start_time, end_time, DO_TIMEOUT) < DO_DELTA) if(compute_diff(start_time, end_time, DO_TIMEOUT) < DO_DELTA)
e(8, "Failed to get interrupted by a signal"); em(8, "Failed to get interrupted by a signal");
if(!got_signal) e(9, "Failed to get interrupted by a signal"); if(!got_signal) em(9, "Failed to get interrupted by a signal");
waitpid(child, &retval, 0); waitpid(child, &retval, 0);
exit(errct); exit(errct);

6
test/test1.c
View file

@ -9,13 +9,13 @@
#include <stdio.h> #include <stdio.h>
#define SIGNUM 10 #define SIGNUM 10
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
volatile int glov, gct; volatile int glov, gct;
int errct;
int subtest; int subtest;
#include "common.c"
int main(int argc, char *argv []); int main(int argc, char *argv []);
void test1a(void); void test1a(void);

5
test/test10.c
View file

@ -15,8 +15,9 @@ char *name[] = {"t10a", "t10b", "t10c", "t10d", "t10e", "t10f", "t10g",
long prog[PROGBUF_LONGS]; long prog[PROGBUF_LONGS];
int psize; int psize;
#define MAX_ERROR 2 int max_error = 2;
#include "common.c" #include "common.h"
int main(void); int main(void);
void spawn(int n); void spawn(int n);

5
test/test11.c
View file

@ -11,13 +11,14 @@
#include <stdio.h> #include <stdio.h>
#define ITERATIONS 10 #define ITERATIONS 10
#define MAX_ERROR 1 int max_error = 1;
#include "common.h"
int errct, subtest; int errct, subtest;
char *envp[3] = {"spring", "summer", 0}; char *envp[3] = {"spring", "summer", 0};
char *passwd_file = "/etc/passwd"; char *passwd_file = "/etc/passwd";
#include "common.c"
int main(int argc, char *argv[]); int main(int argc, char *argv[]);
void test11a(void); void test11a(void);

5
test/test12.c
View file

@ -10,9 +10,10 @@
#include <stdio.h> #include <stdio.h>
#define NUM_TIMES 1000 #define NUM_TIMES 1000
#define MAX_ERROR 2 int max_error = 2;
#include "common.h"
#include "common.c"
int main(void); int main(void);

5
test/test13.c
View file

@ -17,8 +17,9 @@
char buffer[BLOCK_SIZE]; char buffer[BLOCK_SIZE];
#define MAX_ERROR 2 int max_error = 2;
#include "common.c" #include "common.h"
int main(void); int main(void);
void quit(void); void quit(void);

5
test/test14.c
View file

@ -8,12 +8,13 @@
#include <stdio.h> #include <stdio.h>
#define TRIALS 100 #define TRIALS 100
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
char name[20] = {"TMP14."}; char name[20] = {"TMP14."};
int subtest = 1; int subtest = 1;
#include "common.c"
int main(void); int main(void);
void quit(void); void quit(void);

6
test/test15.c
View file

@ -17,14 +17,14 @@
#define STREQ(a, b) (strcmp((a), (b)) == 0) #define STREQ(a, b) (strcmp((a), (b)) == 0)
char *it = "<UNSET>"; /* Routine name for message routines. */ char *it = "<UNSET>"; /* Routine name for message routines. */
int errct; /* count errors */
int waserror = 0; /* For exit status. */ int waserror = 0; /* For exit status. */
char uctest[] = "\004\203"; /* For testing signedness of chars. */ char uctest[] = "\004\203"; /* For testing signedness of chars. */
int charsigned; /* Result. */ int charsigned; /* Result. */
#define MAX_ERROR 2 int max_error = 2;
#include "common.c" #include "common.h"
void check(int thing, int number); void check(int thing, int number);
void equal(char *a, char *b, int number); void equal(char *a, char *b, int number);

5
test/test16.c
View file

@ -9,12 +9,13 @@
#include <utime.h> #include <utime.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
int subtest, passes; int subtest, passes;
int V1filesystem = 0; int V1filesystem = 0;
#include "common.c"
int main(int argc, char *argv []); int main(int argc, char *argv []);
void test16init(void); void test16init(void);

6
test/test17.c
View file

@ -17,7 +17,9 @@
#define NOCRASH 1 /* test11(), 2nd pipe */ #define NOCRASH 1 /* test11(), 2nd pipe */
#define PDPNOHANG 1 /* test03(), write_standards() */ #define PDPNOHANG 1 /* test03(), write_standards() */
#define MAX_ERROR 2 int max_error = 2;
#include "common.h"
#define USER_ID 12 #define USER_ID 12
#define GROUP_ID 1 #define GROUP_ID 1
@ -61,7 +63,6 @@
#define DUP "dup" #define DUP "dup"
#define UTIME "utime" #define UTIME "utime"
int errct;
/* "decl.c", created by Rene Montsma and Menno Wilcke */ /* "decl.c", created by Rene Montsma and Menno Wilcke */
@ -76,7 +77,6 @@ char *mode_fnames[MODES] = {"---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rw
/* "test.c", created by Rene Montsma and Menno Wilcke */ /* "test.c", created by Rene Montsma and Menno Wilcke */
#include "common.c"
int main(int argc, char *argv []); int main(int argc, char *argv []);
void test(int mask); void test(int mask);

6
test/test18.c
View file

@ -64,8 +64,9 @@
#define DUP "dup" #define DUP "dup"
#define UTIME "utime" #define UTIME "utime"
int errct; int max_error = 2;
#define MAX_ERROR 2 #include "common.h"
/* "decl.c", created by Rene Montsma and Menno Wilcke */ /* "decl.c", created by Rene Montsma and Menno Wilcke */
@ -78,7 +79,6 @@ char *fnames[8] = {"---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"},
/* "test.c", created by Rene Montsma and Menno Wilcke */ /* "test.c", created by Rene Montsma and Menno Wilcke */
#include "common.c"
int main(int argc, char **argv); int main(int argc, char **argv);
void test(void); void test(void);

5
test/test19.c
View file

@ -8,7 +8,9 @@
#include <unistd.h> #include <unistd.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
#define NB 30L #define NB 30L
#define NBOUNDS 6 #define NBOUNDS 6
@ -20,7 +22,6 @@ char b[4] = {0, 1, 2, 3}, c[4] = {10, 20, 30, 40}, d[4] = {6, 7, 8, 9};
long bounds[NBOUNDS] = {7, 9, 50, 519, 520, 40000L}; long bounds[NBOUNDS] = {7, 9, 50, 519, 520, 40000L};
char buff[30000]; char buff[30000];
#include "common.c"
int main(int argc, char *argv[]); int main(int argc, char *argv[]);
void test19a(void); void test19a(void);

15
test/test2.c
View file

@ -11,13 +11,14 @@
#include <stdio.h> #include <stdio.h>
#define ITERATIONS 5 #define ITERATIONS 5
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
int is, array[4], parsigs, parcum, sigct, cumsig, subtest; int is, array[4], parsigs, parcum, sigct, cumsig, subtest;
int iteration, kk = 0; int iteration, kk = 0;
char buf[2048]; char buf[2048];
#include "common.c"
int main(int argc, char *argv []); int main(int argc, char *argv []);
void test2a(void); void test2a(void);
@ -63,13 +64,13 @@ void test2a()
subtest = 1; subtest = 1;
if (pipe(fd) < 0) { if (pipe(fd) < 0) {
printf("pipe error. errno= %d\n", errno); printf("pipe error. errno= %d\n", errno);
errct++; e(10);
quit(); quit();
} }
i = fork(); i = fork();
if (i < 0) { if (i < 0) {
printf("fork failed\n"); printf("fork failed\n");
errct++; e(11);
quit(); quit();
} }
if (i != 0) { if (i != 0) {
@ -79,7 +80,7 @@ void test2a()
for (q = 0; q < 8; q++) { for (q = 0; q < 8; q++) {
if (write(fd[1], buf, 2048) < 0) { if (write(fd[1], buf, 2048) < 0) {
printf("write pipe err. errno=%d\n", errno); printf("write pipe err. errno=%d\n", errno);
errct++; e(12);
quit(); quit();
} }
} }
@ -87,7 +88,7 @@ void test2a()
wait(&q); wait(&q);
if (q != 256 * 58) { if (q != 256 * 58) {
printf("wrong exit code %d\n", q); printf("wrong exit code %d\n", q);
errct++; e(13);
quit(); quit();
} }
} else { } else {
@ -97,7 +98,7 @@ void test2a()
n = read(fd[0], buf, 512); n = read(fd[0], buf, 512);
if (n != 512) { if (n != 512) {
printf("read yielded %d bytes, not 512\n", n); printf("read yielded %d bytes, not 512\n", n);
errct++; e(14);
quit(); quit();
} }
for (j = 0; j < n; j++) for (j = 0; j < n; j++)

5
test/test20.c
View file

@ -20,14 +20,15 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
#define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a) #define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a)
#include "common.c"
int superuser; int superuser;

5
test/test21.c
View file

@ -16,9 +16,10 @@
#include <stdio.h> #include <stdio.h>
#define ITERATIONS 1 #define ITERATIONS 1
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
#include "common.c"
int main(int argc, char *argv []); int main(int argc, char *argv []);
void test21a(void); void test21a(void);

4
test/test22.c
View file

@ -9,14 +9,14 @@
#include <sys/wait.h> #include <sys/wait.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 /* Stop after ``MAX_ERROR'' errors. */ #include "common.h"
#define ITERATIONS 2 #define ITERATIONS 2
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
#define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a) #define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a)
#include "common.c"
void test22a(void); void test22a(void);
int mode(char *filename); int mode(char *filename);

5
test/test23.c
View file

@ -10,10 +10,11 @@
#include <fcntl.h> #include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 3 #define ITERATIONS 3
#include "common.c"
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)

5
test/test24.c
View file

@ -20,10 +20,11 @@ void test24c(void);
void makelongnames(void); void makelongnames(void);
#define OVERFLOW_DIR_NR (OPEN_MAX + 1) #define OVERFLOW_DIR_NR (OPEN_MAX + 1)
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 5 #define ITERATIONS 5
#include "common.c"
#define DIRENT0 ((struct dirent *) NULL) #define DIRENT0 ((struct dirent *) NULL)
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)

5
test/test25.c
View file

@ -16,10 +16,11 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 2 #define ITERATIONS 2
#include "common.c"
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)

5
test/test26.c
View file

@ -12,7 +12,9 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
@ -20,7 +22,6 @@
#define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a) #define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a)
#define Mkfifo(f) if (mkfifo(f,0777)!=0) printf("Can't make fifo %s\n", f) #define Mkfifo(f) if (mkfifo(f,0777)!=0) printf("Can't make fifo %s\n", f)
#include "common.c"
void test26a(void); void test26a(void);
void test26b(void); void test26b(void);

5
test/test27.c
View file

@ -13,13 +13,14 @@
#include <stdio.h> #include <stdio.h>
#define MODE_MASK (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID) #define MODE_MASK (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID)
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 2 #define ITERATIONS 2
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
#include "common.c"
int superuser; int superuser;
char *MaxName; /* Name of maximum length */ char *MaxName; /* Name of maximum length */

5
test/test28.c
View file

@ -20,10 +20,11 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 2 #define ITERATIONS 2
#include "common.c"
#define DIRENT0 ((struct dirent *) NULL) #define DIRENT0 ((struct dirent *) NULL)

5
test/test29.c
View file

@ -24,7 +24,9 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
@ -34,7 +36,6 @@
#define IS_CLOEXEC(fd) ((fcntl(fd, F_GETFD) & FD_CLOEXEC) == FD_CLOEXEC) #define IS_CLOEXEC(fd) ((fcntl(fd, F_GETFD) & FD_CLOEXEC) == FD_CLOEXEC)
#define SET_CLOEXEC(fd) fcntl(fd, F_SETFD, FD_CLOEXEC) #define SET_CLOEXEC(fd) fcntl(fd, F_SETFD, FD_CLOEXEC)
#include "common.c"
int superuser; int superuser;

5
test/test3.c
View file

@ -12,13 +12,14 @@
#include <stdio.h> #include <stdio.h>
#define ITERATIONS 10 #define ITERATIONS 10
#define MAX_ERROR 0 int max_error = 0;
#include "common.h"
#define SIZE 64 #define SIZE 64
int subtest; int subtest;
char el_weirdo[] = "\n\t\\\e@@!!##\e\e\n\n"; char el_weirdo[] = "\n\t\\\e@@!!##\e\e\n\n";
#include "common.c"
int main(int argc, char *argv []); int main(int argc, char *argv []);
void test3a(void); void test3a(void);

5
test/test30.c
View file

@ -19,10 +19,11 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
#include "common.c"
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)

5
test/test31.c
View file

@ -12,10 +12,11 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
#include "common.c"
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)

5
test/test32.c
View file

@ -12,7 +12,9 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 2 #define ITERATIONS 2
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
@ -20,7 +22,6 @@
#define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a) #define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a)
#define Creat(f) if (close(creat(f,0777))!=0) printf("Can't creat %s\n",f) #define Creat(f) if (close(creat(f,0777))!=0) printf("Can't creat %s\n",f)
#include "common.c"
int superuser; int superuser;
char *MaxName; /* Name of maximum length */ char *MaxName; /* Name of maximum length */

5
test/test33.c
View file

@ -12,10 +12,11 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 1 int max_error = 1;
#include "common.h"
#define ITERATIONS 2 #define ITERATIONS 2
#include "common.c"
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)

5
test/test34.c
View file

@ -19,11 +19,12 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 4 #define ITERATIONS 4
#define N 100 #define N 100
#include "common.c"
#define ALL_RWXB (S_IRWXU | S_IRWXG | S_IRWXO) #define ALL_RWXB (S_IRWXU | S_IRWXG | S_IRWXO)
#define ALL_SETB (S_ISUID | S_ISGID) #define ALL_SETB (S_ISUID | S_ISGID)

5
test/test35.c
View file

@ -14,11 +14,12 @@
#include <ctype.h> #include <ctype.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 1 int max_error = 1;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
#define N 100 #define N 100
#include "common.c"
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)

5
test/test36.c
View file

@ -12,14 +12,15 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 10 #define ITERATIONS 10
#define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd) #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
#define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a) #define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a)
#include "common.c"
int superuser; int superuser;

5
test/test37.c
View file

@ -12,9 +12,10 @@
#define ITERATIONS 2 #define ITERATIONS 2
#define SIGS 14 #define SIGS 14
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#include "common.c"
int iteration, cumsig, sig1, sig2; int iteration, cumsig, sig1, sig2;

5
test/test38.c
View file

@ -18,7 +18,9 @@
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 3 #define ITERATIONS 3
#define BUF_SIZE 1024 #define BUF_SIZE 1024
@ -26,7 +28,6 @@
#define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir) #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
#define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a) #define Stat(a,b) if (stat(a,b) != 0) printf("Can't stat %s\n", a)
#include "common.c"
int superuser; int superuser;
int signumber = 0; int signumber = 0;

5
test/test39.c
View file

@ -2,8 +2,9 @@
#include <stdio.h> #include <stdio.h>
#include <minix/endpoint.h> #include <minix/endpoint.h>
#include <minix/sys_config.h> #include <minix/sys_config.h>
#define MAX_ERROR 1 int max_error = 1;
#include "common.c" #include "common.h"
void test39a(void); void test39a(void);

5
test/test4.c
View file

@ -15,9 +15,10 @@ int s, i, fd, nextb;
char *tempfile = "test4.temp"; char *tempfile = "test4.temp";
char buf[1024]; char buf[1024];
#define MAX_ERROR 2 int max_error = 2;
#include "common.h"
#include "common.c"
int main(void); int main(void);
void subr(void); void subr(void);

5
test/test40.c
View file

@ -11,8 +11,9 @@
#include <unistd.h> #include <unistd.h>
#include <stdarg.h> #include <stdarg.h>
#define MAX_ERROR 5 int max_error = 5;
#include "common.c" #include "common.h"
int main(int argc, char **argv) { int main(int argc, char **argv) {
char *tests[] = {"t40a", "t40b", "t40c", "t40d", "t40e", "t40f"}; char *tests[] = {"t40a", "t40b", "t40c", "t40d", "t40e", "t40f"};

5
test/test41.c
View file

@ -15,9 +15,10 @@
#include <errno.h> #include <errno.h>
#define ITERATIONS 3 #define ITERATIONS 3
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#include "common.c"
/* we have to keep in mind the millisecond values are rounded up */ /* we have to keep in mind the millisecond values are rounded up */
#define UPPERUSEC(us) ((us)+(1000000/system_hz)) #define UPPERUSEC(us) ((us)+(1000000/system_hz))

5
test/test42.c
View file

@ -11,8 +11,9 @@
#include <sys/ptrace.h> #include <sys/ptrace.h>
#define ITERATIONS 3 #define ITERATIONS 3
#define MAX_ERROR 4 int max_error = 4;
#include "common.c" #include "common.h"
#define _WIFSTOPPED(s) (WIFSTOPPED(s) && !WIFSIGNALED(s) && !WIFEXITED(s)) #define _WIFSTOPPED(s) (WIFSTOPPED(s) && !WIFSIGNALED(s) && !WIFEXITED(s))
#define _WIFSIGNALED(s) (!WIFSTOPPED(s) && WIFSIGNALED(s) && !WIFEXITED(s)) #define _WIFSIGNALED(s) (!WIFSTOPPED(s) && WIFSIGNALED(s) && !WIFEXITED(s))

5
test/test43.c
View file

@ -10,12 +10,13 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h> #include <unistd.h>
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
int subtest; int subtest;
static const char *executable; static const char *executable;
#include "common.c"
#define ERR (e(__LINE__)) #define ERR (e(__LINE__))

5
test/test44.c
View file

@ -7,8 +7,9 @@
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/wait.h> #include <sys/wait.h>
#define MAX_ERROR 2 int max_error = 2;
#include "common.c" #include "common.h"
int subtest = 0; int subtest = 0;

5
test/test45.c
View file

@ -8,8 +8,9 @@
#pragma clang diagnostic ignored "-Wtautological-compare" #pragma clang diagnostic ignored "-Wtautological-compare"
#endif #endif
#define MAX_ERROR 4 int max_error = 4;
#include "common.c" #include "common.h"
/* test strtol */ /* test strtol */
#define TYPE long #define TYPE long

6
test/test45.h
View file

@ -32,11 +32,7 @@ static void GLUE(e, TYPE_FUNC)(int n, const char *s, TYPE result, int base)
/* watch out: don't overwrite the static buffer in make_string */ /* watch out: don't overwrite the static buffer in make_string */
printf("Subtest %s, error %d, errno=%d, s=\"%s\", base=%d, ", TOSTRING(TYPE_FUNC), n, errno, s, base); printf("Subtest %s, error %d, errno=%d, s=\"%s\", base=%d, ", TOSTRING(TYPE_FUNC), n, errno, s, base);
printf("result=%s\n", GLUE(make_string, TYPE_FUNC)(result, base)); printf("result=%s\n", GLUE(make_string, TYPE_FUNC)(result, base));
if (errct++ > MAX_ERROR) e(7);
{
printf("Too many errors; test aborted\n");
exit(1);
}
} }
static void GLUE(test_string, TYPE_FUNC)(const char *s, TYPE value, int base) static void GLUE(test_string, TYPE_FUNC)(const char *s, TYPE value, int base)

5
test/test46.c
View file

@ -28,7 +28,9 @@ void group_test_4(void);
void group_test_5(void); void group_test_5(void);
int dotest(void (*testfunc)(void)); int dotest(void (*testfunc)(void));
#define MAX_ERROR 5 int max_error = 5;
#include "common.h"
#define IMAGINARY_GID 100 #define IMAGINARY_GID 100
#define IMAGINARY_GID_STR "100" #define IMAGINARY_GID_STR "100"
#define IMAGINARY_UID 101 #define IMAGINARY_UID 101
@ -37,7 +39,6 @@ int dotest(void (*testfunc)(void));
setgid((IMAGINARY_GID) + 1 ); \ setgid((IMAGINARY_GID) + 1 ); \
setuid(IMAGINARY_UID); \ setuid(IMAGINARY_UID); \
} while(0) } while(0)
#include "common.c"
int subtest = -1, errorct = 0; int subtest = -1, errorct = 0;

5
test/test47.c
View file

@ -6,8 +6,9 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.c" #include "common.h"
/* maximum allowed FP difference for our tests */ /* maximum allowed FP difference for our tests */
#define EPSILON 0.00000000023283064365386962890625 /* 2^(-32) */ #define EPSILON 0.00000000023283064365386962890625 /* 2^(-32) */

7
test/test48.c
View file

@ -6,9 +6,10 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
#define err() e(__LINE__) #define err() e(__LINE__)
#include "common.c"
static void printstr(const char *s) static void printstr(const char *s)
{ {
@ -253,7 +254,7 @@ static void memsetl(void *s, unsigned long c, size_t n)
p[i] = c >> (8 * (i % sizeof(c))); p[i] = c >> (8 * (i % sizeof(c)));
} }
void test_getnameinfo( static void test_getnameinfo(
unsigned long ipaddr, unsigned long ipaddr,
unsigned short port, unsigned short port,
const char *exp_node, const char *exp_node,

5
test/test49.c
View file

@ -10,8 +10,9 @@
#define ERR e(__LINE__) #define ERR e(__LINE__)
#define MAX_ERROR 4 int max_error = 4;
#include "common.c" #include "common.h"
#define TEST_PRINTF(type, macro, value, result) \ #define TEST_PRINTF(type, macro, value, result) \
{ \ { \

5
test/test5.c
View file

@ -11,13 +11,14 @@
#include <string.h> #include <string.h>
#define ITERATIONS 2 #define ITERATIONS 2
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
int subtest; int subtest;
int zero[1024]; int zero[1024];
int sigmap[5] = {9, 10, 11}; int sigmap[5] = {9, 10, 11};
#include "common.c"
int main(int argc, char *argv[]); int main(int argc, char *argv[]);
void test5a(void); void test5a(void);

5
test/test50.c
View file

@ -6,13 +6,14 @@
#include <assert.h> #include <assert.h>
#define ITERATIONS 1 #define ITERATIONS 1
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define TESTFILE "testfile" #define TESTFILE "testfile"
#define TESTSIZE 4096 #define TESTSIZE 4096
#define THRESHOLD 1048576 #define THRESHOLD 1048576
#include "common.c"
int main(int argc, char *argv[]); int main(int argc, char *argv[]);
void prepare(void); void prepare(void);

7
test/test51.c
View file

@ -29,12 +29,13 @@ void just_exit(void);
void test_brk(void); void test_brk(void);
void verify_main_reenter(void); void verify_main_reenter(void);
#define MAX_ERROR 5 int max_error = 5;
#include "common.h"
#define SSIZE 32768 #define SSIZE 32768
#define ROUNDS 10 #define ROUNDS 10
#define SWAPS 10 #define SWAPS 10
#include "common.c"
int subtest; int subtest;
ucontext_t ctx[3]; ucontext_t ctx[3];
@ -130,7 +131,7 @@ void do_parent(void)
/* Returning to main thread through uc_link */ /* Returning to main thread through uc_link */
} }
void fail(void) static void fail(void)
{ {
/* Shouldn't get here */ /* Shouldn't get here */
err(5, 1); err(5, 1);

5
test/test52.c
View file

@ -8,9 +8,10 @@
#define ROUNDS 20 #define ROUNDS 20
#define SWAPS 40 #define SWAPS 40
#define MAX_ERROR 5 int max_error = 5;
#include "common.h"
#include "common.c"
int pipefdc[2]; int pipefdc[2];
int pipefdp[2]; int pipefdp[2];

10
test/test53.c
View file

@ -8,10 +8,11 @@
#include <unistd.h> #include <unistd.h>
#define ERR err(__LINE__) #define ERR err(__LINE__)
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define TIMED 0 #define TIMED 0
#include "common.c"
static volatile int expect_SIGFPE; static volatile int expect_SIGFPE;
static u64_t i, j, k; static u64_t i, j, k;
@ -27,10 +28,7 @@ static void err(int line)
ex64hi(k), ex64lo(k)); ex64hi(k), ex64lo(k));
/* quit after too many errors */ /* quit after too many errors */
if (errct++ > MAX_ERROR) { e(7);
printf("Too many errors; test aborted\n");
quit();
}
} }
#define LENGTHOF(arr) (sizeof(arr) / sizeof(arr[0])) #define LENGTHOF(arr) (sizeof(arr) / sizeof(arr[0]))

7
test/test54.c
View file

@ -6,12 +6,13 @@
#include <err.h> #include <err.h>
#include <stdlib.h> #include <stdlib.h>
#define MAX_ERROR 3 int max_error = 3;
#include "common.c" #include "common.h"
int subtest = -1; int subtest = -1;
void do_test(void) static void do_test(void)
{ {
int fd; int fd;
char *wbuf, *rbuf; char *wbuf, *rbuf;

5
test/test55.c
View file

@ -8,11 +8,12 @@
#define TRIALS 10 #define TRIALS 10
#define SIZE 65536 #define SIZE 65536
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
int subtest; int subtest;
char *filename = "statvfs_test_XXXXXX"; char *filename = "statvfs_test_XXXXXX";
#include "common.c"
void create_file(void) void create_file(void)
{ {

12
test/test56.c
View file

@ -57,10 +57,11 @@
/* Maximum number of errors that we'll allow to occur before this test /* Maximum number of errors that we'll allow to occur before this test
* program gives us and quits. * program gives us and quits.
*/ */
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
/* Use the common testing code instead of reinventing the wheel. */ /* Use the common testing code instead of reinventing the wheel. */
#include "common.c"
/* path of the unix domain socket */ /* path of the unix domain socket */
#define TEST_SUN_PATH "test.sock" #define TEST_SUN_PATH "test.sock"
@ -131,12 +132,7 @@ void test_fail_fl(char *msg, char *file, int line)
free(timestamp); free(timestamp);
timestamp = NULL; timestamp = NULL;
} }
errct++; e(7);
if (errct++ > MAX_ERROR) {
printf("Too many errors; test aborted\n");
quit();
exit(1);
}
} }
#define test_fail(msg) test_fail_fl(msg, __FILE__, __LINE__) #define test_fail(msg) test_fail_fl(msg, __FILE__, __LINE__)

2
test/test57.c
View file

@ -28,7 +28,7 @@ void check_context_loop(void);
unsigned long newstate[REGS], origstate[REGS]; unsigned long newstate[REGS], origstate[REGS];
void handler(int signal) static void handler(int signal)
{ {
int st; int st;
sigset_t set, oset; sigset_t set, oset;

5
test/test58.c
View file

@ -22,11 +22,12 @@
#include <sys/stat.h> #include <sys/stat.h>
int subtest = -1; int subtest = -1;
#define MAX_ERROR 999 /* Effectively no limit. This is necessary as this int max_error = 999; /* Effectively no limit. This is necessary as this
* test tries to undo errors and should therefore not * test tries to undo errors and should therefore not
* preemptively exit, as that would leave the FS * preemptively exit, as that would leave the FS
* in a corrupted state. */ * in a corrupted state. */
#include "common.c"
#include "common.h"
#define TEST_PATH "a/b/c" #define TEST_PATH "a/b/c"
#define INTEGR_MSG "You might want to check fs integrity\n" #define INTEGR_MSG "You might want to check fs integrity\n"

6
test/test59.c
View file

@ -14,10 +14,10 @@
#define event_t mthread_event_t #define event_t mthread_event_t
#define rwlock_t mthread_rwlock_t #define rwlock_t mthread_rwlock_t
#define MAX_ERROR 5 int max_error = 5;
#include "common.c" #include "common.h"
int errct;
static int count, condition_met; static int count, condition_met;
static int th_a, th_b, th_c, th_d, th_e, th_f, th_g, th_h; static int th_a, th_b, th_c, th_d, th_e, th_f, th_g, th_h;
static int mutex_a_step, mutex_b_step, mutex_c_step; static int mutex_a_step, mutex_b_step, mutex_c_step;

5
test/test6.c
View file

@ -10,12 +10,13 @@
#include <unistd.h> #include <unistd.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
int subtest = 1; int subtest = 1;
int zilch[5000]; int zilch[5000];
#include "common.c"
int main(int argc, char *argv []); int main(int argc, char *argv []);
void test6a(void); void test6a(void);

9
test/test60.c
View file

@ -3,8 +3,9 @@
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#define MAX_ERROR 5 int max_error = 5;
#include "common.c" #include "common.h"
int subtest = -1; int subtest = -1;
@ -97,7 +98,7 @@ void test_setuid(void)
} }
void test_setugid(void) static void test_setugid(void)
{ {
/* Execve a new process that has setuid and setgid bits set */ /* Execve a new process that has setuid and setgid bits set */
subtest = 5; subtest = 5;
@ -233,7 +234,7 @@ void test_self(void)
} }
} }
void switch_to_su(void) static void switch_to_su(void)
{ {
subtest = 0; subtest = 0;
if (setuid(0) != 0) e(1); if (setuid(0) != 0) e(1);

5
test/test61.c
View file

@ -5,8 +5,9 @@
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#define MAX_ERROR 5 int max_error = 5;
#include "common.c" #include "common.h"
void dangling_slink(int sub_test, char const slink_to[PATH_MAX]); void dangling_slink(int sub_test, char const slink_to[PATH_MAX]);

5
test/test62.c
View file

@ -6,8 +6,9 @@
#include <sys/wait.h> #include <sys/wait.h>
#include <machine/fpu.h> #include <machine/fpu.h>
#define MAX_ERROR 1 int max_error = 1;
#include "common.c" #include "common.h"
double state = 2.0; double state = 2.0;
static int count; static int count;

5
test/test63.c
View file

@ -16,10 +16,11 @@
#include <stdio.h> #include <stdio.h>
#include <dlfcn.h> #include <dlfcn.h>
#define MAX_ERROR 2 int max_error = 2;
#include "common.h"
#include "magic.h" #include "magic.h"
#include "common.c"
int main (int argc, char *argv[]) int main (int argc, char *argv[])
{ {

5
test/test64.c
View file

@ -10,10 +10,11 @@
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/wait.h> #include <sys/wait.h>
#define MAX_ERROR 2 int max_error = 2;
#include "common.h"
#include "magic.h" #include "magic.h"
#include "common.c"
int main (int argc, char *argv[]) int main (int argc, char *argv[])
{ {

5
test/test65.c
View file

@ -6,8 +6,9 @@
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#define MAX_ERROR 0 int max_error = 0;
#include "common.c" #include "common.h"
#define TESTMNT "testmnt" #define TESTMNT "testmnt"
#define TESTFILE "test.txt" #define TESTFILE "test.txt"

5
test/test66.c
View file

@ -12,9 +12,10 @@
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <assert.h>
#define MAX_ERROR 10 int max_error = 10;
#include "common.h"
#include "common.c"
#define RESULTSNAME desired #define RESULTSNAME desired
#define SUBRESULTS 131 #define SUBRESULTS 131

5
test/test67.c
View file

@ -10,10 +10,11 @@
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#define MAX_ERROR 5 int max_error = 5;
#include "common.h"
#define CLOEXEC_PORT 3490 #define CLOEXEC_PORT 3490
#define FORK_PORT 3491 #define FORK_PORT 3491
#include "common.c"
static int fd = 0; static int fd = 0;

5
test/test68.c
View file

@ -7,8 +7,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#define MAX_ERROR 5 int max_error = 5;
#include "common.c" #include "common.h"
void copy_subtests(void); void copy_subtests(void);
void test_pipe_cloexec(void); void test_pipe_cloexec(void);

5
test/test69.c
View file

@ -13,14 +13,15 @@
#include <stdio.h> #include <stdio.h>
#define TRIALS 100 #define TRIALS 100
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#ifndef DEBUG #ifndef DEBUG
#define DEBUG 0 #define DEBUG 0
#endif #endif
int subtest = 1; int subtest = 1;
#include "common.c"
int main(void); int main(void);
void quit(void); void quit(void);

5
test/test7.c
View file

@ -18,7 +18,9 @@
#include <setjmp.h> #include <setjmp.h>
#define ITERATIONS 4 #define ITERATIONS 4
#define MAX_ERROR 3 int max_error = 3;
#include "common.h"
#define ITEMS 32 #define ITEMS 32
#define READ 10 #define READ 10
#define WRITE 20 #define WRITE 20
@ -28,7 +30,6 @@
char buf[ITEMS] = {0,1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1,0,1,2,3,4,5,6,7,8,9}; char buf[ITEMS] = {0,1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1,0,1,2,3,4,5,6,7,8,9};
#include "common.c"
int subtes, xfd; int subtes, xfd;
int whence = SEEK_SET, func_code = F_SETLK; int whence = SEEK_SET, func_code = F_SETLK;

5
test/test8.c
View file

@ -12,13 +12,14 @@
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#define ITERATIONS 60 #define ITERATIONS 60
#define Fstat(a,b) if (fstat(a,b) != 0) printf("Can't fstat %d\n", a) #define Fstat(a,b) if (fstat(a,b) != 0) printf("Can't fstat %d\n", a)
#define Time(t) if (time(t) == (time_t)-1) printf("Time error\n") #define Time(t) if (time(t) == (time_t)-1) printf("Time error\n")
#include "common.c"
int subtest; int subtest;

5
test/test9.c
View file

@ -4,9 +4,10 @@
#include <setjmp.h> #include <setjmp.h>
#include <signal.h> #include <signal.h>
#define MAX_ERROR 4 int max_error = 4;
#include "common.h"
#include "common.c"
char *tmpa; char *tmpa;