regression: add regression tests from NxM

These tested problems we found, and fixed them.

They don't yet follow our standard way of indicating pass/fail. They all need to
be double checked.

Change-Id: Ib80842cbd8bb6776da9bfddb54faeb75729e16e3
Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>

sys/src/regress/badsyscall.c

@@ -0,0 +1,84 @@
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <mach.h>
+#include <ureg.h>
+
+int handled = 0;
+int back = 0;
+int inhandler = 0;
+int badsys = 0;
+int verbose = 0;
+char *msg = "Writing from NxM program to stdout via linux write(2)\n";
+
+void
+handler(void *v, char *s)
+{
+        char *f[7];
+	u64int parm[7];
+	struct Ureg* u = v;
+        int i, n, nf;
+
+	inhandler = 1;
+	if (verbose)
+		fprint(2, "handler: %p %s\n", v, s);
+	handled++;
+	if (strncmp(s, "sys: bad sys call", 17)==0 && badsys){
+		badsys = 0;
+		noted(NCONT);
+	}
+	if (strncmp(s, "linux:", 6))
+		noted(NDFLT);
+	s += 6;
+        nf = tokenize(s, f, nelem(f));
+
+	for(i = 0; i < nelem(parm); i++)
+		parm[i] = strtoull(f[i], 0, 0);
+	switch(parm[0]){
+		case 22:
+			u->ax = pipe((void*)(parm[1]));
+			break;
+	}
+	inhandler = 0;
+	noted(NCONT);
+}
+
+void
+main(int argc, char *argv[])
+{
+	uvlong callbadsys(uvlong, ...);
+	int fd[2];
+	int ret;
+	char data[4];
+  
+	if (notify(handler)){
+		fprint(2, "%r\n");
+		exits("notify fails");
+	}
+	fprint(2, "Notify passed\n");
+
+	//callbadsys(0xc0FF);
+	//fprint(2, "Handled %d\n", handled);
+
+	/* try a good linux system call */
+	ret = callbadsys((uvlong)1, (uvlong)1, msg, strlen(msg));
+	fprint(2, "Write to stdout is %d, should be %d\n", ret, strlen(msg));
+	/* try a emulated linux system call */
+	fprint(2, "Call pipe\n");
+	ret = callbadsys((uvlong)22, (uvlong)fd);
+	fprint(2, "PIPE ret %d = fd [%d,%d]\n", ret, fd[0], fd[1]);
+	ret = write(fd[0], "hi.", 3);
+	fprint(2, "write to pipe is %d (should be 3)\n", ret);
+	data[3] = 0;
+	read(fd[1], data, 3);
+	fprint(2, "read from pipe is %d (should be 3); data is :%s:\n", ret, data);
+	/* now try a bad linux system call */
+	badsys = 1;
+	callbadsys(0x3FFF);
+	fprint(2, "Handled %d\n", handled);
+	back++;
+
+	if (!handled)
+		exits("badsyscall test fails");
+	exits(nil);
+}

sys/src/regress/callbadsys.s

@@ -0,0 +1,15 @@
+/* because this moves RARG to ax you can call linux
+ * or plan 9 system calls
+ */
+	TEXT	callbadsys+0(SB),0,$0
+	MOVQ RARG, a0+0(FP)
+	MOVQ	a1+8(FP),DI
+	MOVQ	a2+16(FP),SI
+	MOVQ	a3+24(FP),DX
+	MOVQ	a4+32(FP),R10
+	MOVQ	a5+40(FP),R8
+	MOVQ	a6+48(FP),R9
+	MOVQ RARG,AX
+	SYSCALL	
+	RET	,
+	END	,

sys/src/regress/float.c

@@ -0,0 +1,57 @@
+#include <u.h>
+#include <libc.h>
+
+#define DPRECSTR	"0.0000004000000000125"
+#define DPREC	0.0000004000000000125
+#define DIEEELO	0x9ac0499f
+#define DIEEEHI	0x3e9ad7f2
+
+jmp_buf errj;
+char *err;
+
+void
+catcher(void *u, char *s)
+{
+	err = 0;
+	if(strncmp(s, "sys: fp:", 8) == 0){
+		err = s;
+		notejmp(u, errj, 0);
+	}
+	noted(NDFLT);
+}
+
+void
+tstdiv(double p)
+{
+	double r = 1.0;
+
+	r /= p;
+	print("1/%0.20g = %0.20g\n", p, r);
+} 
+
+void
+main(void)
+{
+	double p = DPREC;
+	int d[2] = { DIEEELO, DIEEEHI };
+	uvlong dieee, q;
+	dieee = *(uvlong*)d;
+	q = *(uvlong*)&p;
+
+	err = 0;
+	notify(catcher);
+	setjmp(errj);
+	if(err){
+		fprint(2, "%s\n", err);
+		exits("FAIL");
+	}
+
+	print("Double-precision test number: %s\n", DPRECSTR);
+	print("Expected internal representation: %ullx\n", dieee);
+	print("Actual internal representation: %ullx\n", q);
+
+	if(q != dieee)
+		exits("FAIL");
+
+	tstdiv(p);
+}

sys/src/regress/frexp.c

@@ -0,0 +1,78 @@
+#include <u.h>
+#include <libc.h>
+
+#define DEEPS	".5*2^-1073"
+#define DENEPS	"-.5*2^-1073"
+#define DEPINF	"+Inf*2^0"
+#define DENAN "NaN*2^0"
+
+jmp_buf errj;
+char *err;
+int fail = 0;
+
+void
+catcher(void *u, char *s)
+{
+	err = 0;
+	if(strncmp(s, "sys: fp:", 8) == 0){
+		err = s;
+		notejmp(u, errj, 0);
+	}
+	noted(NDFLT);
+}
+
+void
+decomp(double d, int *exp, char *s)
+{
+	double m;
+
+	m = frexp(d, exp);
+	print("Expected decomposition: %s\n", s);
+	print("Actual decomposition: %g*2^%d\n", m, *exp);
+
+	if(isNaN(d)){
+		if(*exp != 0 || !isNaN(m))
+			fail = 1;
+		return;
+	}
+	if(isInf(d, 1)){
+		if(*exp != 0 || !isInf(m, 1))
+			fail = 1;
+		return;
+	}
+	if(fabs(d - ldexp(m, *exp)) > 4e-16)
+		fail = 1;
+}
+
+void
+main(void)
+{
+	double eps, neps;
+	int exp;
+
+	err = 0;
+	notify(catcher);
+	setjmp(errj);
+	if(err){
+		fprint(2, "%s\n", err);
+		exits("FAIL");
+	}
+
+	eps = ldexp(1, -1074);
+	neps = ldexp(-1, -1074);
+
+	print("Smallest Positive Double: %g\n", eps);
+	decomp(eps, &exp, DEEPS);
+
+	print("Largest Negative Double: %g\n", neps);
+	decomp(neps, &exp, DENEPS);
+
+	print("Positive infinity: %g\n", Inf(1));
+	decomp(Inf(1), &exp, DEPINF);
+
+	print("NaN: %g\n", NaN());
+	decomp(NaN(), &exp, DENAN);
+
+	if(fail)
+		exits("FAIL");
+}

sys/src/regress/idseg.c

@@ -0,0 +1,10 @@
+#include <u.h>
+#include <libc.h>
+
+void
+main(void)
+{
+	char *p = segbrk((void *)(1024ULL * 1024 * 1024 * 1024), nil);
+	print("%p\n", p);
+	memset(p, 0, 4096);
+}

sys/src/regress/mixedfloat.c

@@ -0,0 +1,31 @@
+#include <u.h>
+#include <libc.h>
+
+#define INT	2
+#define FLOAT	2.5
+#define A	4	// addition result
+#define M	5	// multiplication result
+
+void
+main()
+{
+	int a, b, x, y;
+	float f;
+	double d;
+
+	f = FLOAT;
+	d = FLOAT;
+	a = b = x = y = INT;
+
+	a += (double)d;
+	b *= (double)d;
+	x += (float)f;
+	y *= (float)f;
+
+	print("[double] addition: %d; multiplication: %d\n", a, b);
+
+	print("[float] addition: %d; multiplication: %d\n", x, y);
+
+	if(a != A || x != A || b != M || y != M)
+		exits("FAIL");
+}

sys/src/regress/nanotime.c

@@ -0,0 +1,27 @@
+#include <u.h>
+#include <libc.h>
+
+int verbose = 0;
+void
+main(void)
+{
+	int ret = 0; // success
+	vlong start, end;
+	char *msg;
+
+	start = nsec();
+	sleep(1);
+	end = nsec();
+
+	if (end <= start)
+		ret = 1;
+
+	if (verbose)
+		print("nanotime: start %llx, end %llx\n", start, end);
+	if(ret){
+		msg = smprint("nanotime: FAIL: start %llx end %llx",
+			start, end);
+		print("%s\n", msg);
+		exits(msg);
+	}
+}

sys/src/regress/sysstatread.c

@@ -0,0 +1,34 @@
+#include <u.h>
+#include <libc.h>
+
+// Change-Id: I1cfd642d29a3955499b3507f56f0449d1710700e
+// sys/src/nxm/port/devcons.c:
+//	make reads on #c/sysstat return only as many bytes as
+//	requested
+
+void
+main(void)
+{
+	int ret; // 0 = pass, 1 = fail
+	int fd, n;
+	char buf[1];
+
+	fd = open("/dev/sysstat", OREAD);
+	if(fd < 0){
+		print("couldn't open /dev/sysstat: %r\n");
+		exits("FAIL");
+	}
+
+	ret = 0;
+	for(;;){
+		n = read(fd, buf, sizeof(buf));
+		if(n <= 0)
+			break;
+		if(n > sizeof(buf))
+			ret = 1;
+	}
+	close(fd);
+
+	if(ret)
+		exits("FAIL");
+}