illumos gate

/*

 * Copyright 2011 Jason King.  All rights reserved.

 *

 * cc [-m64] -o test test.c -lnsl [-L${CODEMGR_WS}/root_$(uname -p)/lib[/64]]

 *     [-R${CODEMGR_WS}/root/$(uname -p)/lib[64]]

 */

#include <sys/types.h>

#include <rpc/xdr.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <errno.h>

#include <math.h>

static unsigned int seed;

static int ret;

static void load_seed(const char *filename);

static boolean_t test(const void *, const void *, size_t);

static void initbuf(uint32_t *, size_t);

static void printbuf(const char *, uint32_t *, size_t);

static boolean_t float_test(float);

static boolean_t double_test(double);

int

main(int argc, char** argv)

{

	float floatval;

	double doubleval;

	uint32_t *ip;

	boolean_t ret;

	if (argc > 3) {

		long val;

		ip = (uint32_t *)&floatval;

		val = strtol(argv[1], NULL, 0);

		*ip = val;

		ip = (uint32_t *)&doubleval;

		val = strtol(argv[2], NULL, 0);

		*ip++ = val;

		val = strtol(argv[3], NULL, 0);

		*ip = val;

	} else {

		load_seed(NULL);

		(void) srandom(seed);

		ip = (uint32_t *)&floatval;

		*ip = random();

		*ip = random();

		ip = (uint32_t *)&doubleval;

		ip[0] = random();

		ip[1] = random();

	}

	(void) printf("  Float test\n");

	ret = float_test(floatval);

	ret |= float_test(NAN);

	ret |= float_test(-NAN);

	ret |= float_test(INFINITY);

	ret |= float_test(-INFINITY);

	(void) printf("\n");

	(void) printf("  Double test\n");

	ret |= double_test(doubleval);

	ret |= double_test(NAN);

	ret |= double_test(-NAN);

	ret |= double_test(INFINITY);

	ret |= double_test(-INFINITY);

	(void) printf("==> %s\n", (ret) ? "PASSED" : "FAILED");

	return ((ret) ? 0 : 1);

}

static boolean_t

float_test(float val)

{

	uint32_t *valp = (uint32_t *)&val;

	uint32_t buf[4];

	uint32_t cmp[4];

	float val2;

	XDR xdr;

	boolean_t ret, ret2;

	(void) printf("\t%15s: 0x%08x = %e\n", "Test value", *valp, val);

	initbuf(buf, sizeof (buf) / sizeof (uint32_t));

	initbuf(cmp, sizeof (cmp) / sizeof (uint32_t));

	/* use the middle of the buffer to detect any under/overruns */

	cmp[1] = *valp;

	xdrmem_create(&xdr, (const caddr_t)&buf[1],

	    sizeof (buf) - sizeof (uint32_t), XDR_ENCODE);

	xdr_float(&xdr, &val);

	ret = test(cmp, buf, sizeof (buf));

	(void) printf("\t%15s: %s\n", "Encode test",

	    (ret) ? "PASSED" : "FAILED");

	if (!ret) {

		printbuf("Expected", cmp, sizeof (cmp) / sizeof (uint32_t));

		printbuf("Actual", buf, sizeof (buf) / sizeof (uint32_t));

	}

	(void) memcpy(buf, cmp, sizeof (buf));

	xdrmem_create(&xdr, (const caddr_t)&buf[1],

	    sizeof (buf) - sizeof (uint32_t), XDR_DECODE);

	xdr_float(&xdr, &val2);

	valp = (uint32_t *)&val2;

	ret2 = test(&val2, &val, sizeof (val));

	(void) printf("\t%15s: %s\n", "Decode test",

	    (ret) ? "PASSED" : "FAILED");

	if (!ret2) {

		valp = (uint32_t *)&val;

		(void) printf("\t%15s: 0x%08x = %e\n", "Expected", *valp, val);

		valp = (uint32_t *)&val2;

		(void) printf("\t%15s: 0x%08x = %e\n", "Actual", *valp, val2);

	}

	(void) printf("\n");

	return ((ret && ret2));

}

static boolean_t

double_test(double val)

{

	uint32_t *valp = (uint32_t *)&val;

	uint32_t buf[4];

	uint32_t cmp[4];

	double val2;

	XDR xdr;

	boolean_t ret, ret2;

	(void) printf("\t%15s: 0x%0x 0x%0x = %e\n", "Test value", valp[0],

	    valp[1], val);

	initbuf(buf, sizeof (buf) / sizeof (uint32_t));

	initbuf(cmp, sizeof (cmp) / sizeof (uint32_t));

	/* use the middle of the buffer to detect any under/overruns */

	cmp[1] = valp[0];

	cmp[2] = valp[1];

	xdrmem_create(&xdr, (const caddr_t)&buf[1],

	    sizeof (buf) - sizeof (uint32_t), XDR_ENCODE);

	xdr_double(&xdr, &val);

	ret = test(cmp, buf, sizeof (cmp));

	(void) printf("\t%15s: %s\n", "Encode test",

	    (ret) ? "PASSED" : "FAILED");

	if (!ret) {

		printbuf("Expected", cmp, sizeof (cmp) / sizeof (uint32_t));

		printbuf("Actual", buf, sizeof (buf) / sizeof (uint32_t));

	}

	(void) memcpy(buf, cmp, sizeof (buf));

	xdrmem_create(&xdr, (const caddr_t)&buf[1],

	    sizeof (buf) - sizeof (uint32_t), XDR_DECODE);

	xdr_double(&xdr, &val2);

	ret2 = test(&val2, &val, sizeof (val));

	(void) printf("\t%15s: %s\n", "Decode test",

	    (ret) ? "PASSED" : "FAILED");

	if (!ret2) {

		(void) printf("\t%15s: 0x%08x 0x%08x = %e\n", "Expected",

		   valp[0], valp[1], val);

		valp = (uint32_t *)&val2;

		(void) printf("\t%15s: 0x%08x 0x%08x = %e\n", "Actual", valp[0],

		    valp[1], val2);

	}

	(void) printf("\n");

	return ((ret && ret2));

}

static boolean_t

test(const void *s1, const void *s2, size_t len)

{

	int result = memcmp(s1, s2, len);

	return ((result == 0) ? B_TRUE : B_FALSE);

}

static void

initbuf(uint32_t *buf, size_t len)

{

	int i;

	for (i = 0; i < len; i++)

		buf[i] = 0xfeedface;

}

static void

printbuf(const char *label, uint32_t *buf, size_t len)

{

	int i;

	(void) printf("\t%15s: ", label);

	for (i = 0; i < len; i++)

		(void) printf("0x%08x ", buf[i]);

	(void) printf("\n");

}

static void

load_seed(const char *filename)

{

	ssize_t n;

	int fd;

	if (filename == NULL)

		filename = "/dev/random";

	fd = open(filename, O_RDONLY);

	if (fd == -1) {

		(void) fprintf(stderr, "Unable to read seed from %s: %s\n",

		    filename, strerror(errno));

		exit(1);

	}

	n = read(fd, &seed, sizeof (seed));

	if (n != sizeof (seed)) {

		(void) fprintf(stderr, "Unable to read seed from %s: %s\n",

		    filename, strerror(errno));

		exit(1);

	}

}