usb 2.1.2 → 2.3.0

package/libusb/tests/testlib.c

@@ -17,43 +17,26 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libusb_testlib.h"
+#include <config.h>
 
-#include <stdio.h>
+#include <errno.h>
 #include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
 #include <string.h>
-#include <errno.h>
-#if !defined(_WIN32_WCE)
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#endif
 
-#if defined(_WIN32_WCE)
-// No support for selective redirection of STDOUT on WinCE.
-#define DISABLE_STDOUT_REDIRECTION
-#define STDOUT_FILENO 1
-#elif defined(_WIN32)
-#include <io.h>
-#define dup _dup
-#define dup2 _dup2
-#define open _open
-#define close _close
-#define fdopen _fdopen
-#define NULL_PATH "nul"
-#define STDOUT_FILENO 1
-#define STDERR_FILENO 2
-#else
-#include <unistd.h>
+#include "libusb_testlib.h"
+
+#if defined(PLATFORM_POSIX)
 #define NULL_PATH "/dev/null"
+#elif defined(PLATFORM_WINDOWS)
+#define NULL_PATH "nul"
 #endif
-#define INVALID_FD -1
-#define IGNORE_RETVAL(expr) do { (void)(expr); } while(0)
 
 /**
  * Converts a test result code into a human readable string.
  */
-static const char* test_result_to_str(libusb_testlib_result result)
+static const char *test_result_to_str(libusb_testlib_result result)
 {
 	switch (result) {
 	case TEST_STATUS_SUCCESS:
@@ -69,100 +52,27 @@ static const char* test_result_to_str(libusb_testlib_result result)
 	}
 }
 
-static void print_usage(int argc, char ** argv)
+static void print_usage(const char *progname)
 {
-	printf("Usage: %s [-l] [-v] [<test_name> ...]\n",
-		argc > 0 ? argv[0] : "test_*");
+	printf("Usage: %s [-l] [-v] [<test_name> ...]\n", progname);
 	printf("   -l   List available tests\n");
-	printf("   -v   Don't redirect STDERR/STDOUT during tests\n");
+	printf("   -v   Don't redirect STDERR before running tests\n");
+	printf("   -h   Display this help and exit\n");
 }
 
-static void cleanup_test_output(libusb_testlib_ctx * ctx)
-{
-#ifndef DISABLE_STDOUT_REDIRECTION
-	if (!ctx->verbose) {
-		if (ctx->old_stdout != INVALID_FD) {
-			IGNORE_RETVAL(dup2(ctx->old_stdout, STDOUT_FILENO));
-			ctx->old_stdout = INVALID_FD;
-		}
-		if (ctx->old_stderr != INVALID_FD) {
-			IGNORE_RETVAL(dup2(ctx->old_stderr, STDERR_FILENO));
-			ctx->old_stderr = INVALID_FD;
-		}
-		if (ctx->null_fd != INVALID_FD) {
-			close(ctx->null_fd);
-			ctx->null_fd = INVALID_FD;
-		}
-		if (ctx->output_file != stdout) {
-			fclose(ctx->output_file);
-			ctx->output_file = stdout;
-		}
-	}
-#endif
-}
-
-/**
- * Setup test output handles
- * \return zero on success, non-zero on failure
- */
-static int setup_test_output(libusb_testlib_ctx * ctx)
-{
-#ifndef DISABLE_STDOUT_REDIRECTION
-	/* Stop output to stdout and stderr from being displayed if using non-verbose output */
-	if (!ctx->verbose) {
-		/* Keep a copy of STDOUT and STDERR */
-		ctx->old_stdout = dup(STDOUT_FILENO);
-		if (ctx->old_stdout < 0) {
-			ctx->old_stdout = INVALID_FD;
-			printf("Failed to duplicate stdout handle: %d\n", errno);
-			return 1;
-		}
-		ctx->old_stderr = dup(STDERR_FILENO);
-		if (ctx->old_stderr < 0) {
-			ctx->old_stderr = INVALID_FD;
-			cleanup_test_output(ctx);
-			printf("Failed to duplicate stderr handle: %d\n", errno);
-			return 1;
-		}
-		/* Redirect STDOUT_FILENO and STDERR_FILENO to /dev/null or "nul"*/
-		ctx->null_fd = open(NULL_PATH, O_WRONLY);
-		if (ctx->null_fd < 0) {
-			ctx->null_fd = INVALID_FD;
-			cleanup_test_output(ctx);
-			printf("Failed to open null handle: %d\n", errno);
-			return 1;
-		}
-		if ((dup2(ctx->null_fd, STDOUT_FILENO) < 0) ||
-			(dup2(ctx->null_fd, STDERR_FILENO) < 0)) {
-				cleanup_test_output(ctx);
-				return 1;
-		}
-		ctx->output_file = fdopen(ctx->old_stdout, "w");
-		if (!ctx->output_file) {
-			ctx->output_file = stdout;
-			cleanup_test_output(ctx);
-			printf("Failed to open FILE for output handle: %d\n", errno);
-			return 1;
-		}
-	}
-#endif
-	return 0;
-}
-
-void libusb_testlib_logf(libusb_testlib_ctx * ctx,
-	const char* fmt, ...)
+void libusb_testlib_logf(const char *fmt, ...)
 {
 	va_list va;
+
 	va_start(va, fmt);
-	vfprintf(ctx->output_file, fmt, va);
+	vfprintf(stdout, fmt, va);
 	va_end(va);
-	fprintf(ctx->output_file, "\n");
-	fflush(ctx->output_file);
+	fputc('\n', stdout);
+	fflush(stdout);
 }
 
-int libusb_testlib_run_tests(int argc,
-	char ** argv,
-	const libusb_testlib_test * tests)
+int libusb_testlib_run_tests(int argc, char *argv[],
+	const libusb_testlib_test *tests)
 {
 	int run_count = 0;
 	int idx = 0;
@@ -170,108 +80,105 @@ int libusb_testlib_run_tests(int argc,
 	int fail_count = 0;
 	int error_count = 0;
 	int skip_count = 0;
-	int r, j;
-	size_t arglen;
-	libusb_testlib_result test_result;
-	libusb_testlib_ctx ctx;
 
 	/* Setup default mode of operation */
-	ctx.test_names = NULL;
-	ctx.test_count = 0;
-	ctx.list_tests = false;
-	ctx.verbose = false;
-	ctx.old_stdout = INVALID_FD;
-	ctx.old_stderr = INVALID_FD;
-	ctx.output_file = stdout;
-	ctx.null_fd = INVALID_FD;
+	char **test_names = NULL;
+	int test_count = 0;
+	bool list_tests = false;
+	bool verbose = false;
 
 	/* Parse command line options */
 	if (argc >= 2) {
-		for (j = 1; j < argc; j++) {
-			arglen = strlen(argv[j]);
-			if ( ((argv[j][0] == '-') || (argv[j][0] == '/')) &&
-				arglen >=2 ) {
-					switch (argv[j][1]) {
+		for (int j = 1; j < argc; j++) {
+			const char *argstr = argv[j];
+			size_t arglen = strlen(argstr);
+
+			if (argstr[0] == '-' || argstr[0] == '/') {
+				if (arglen == 2) {
+					switch (argstr[1]) {
 					case 'l':
-						ctx.list_tests = true;
-						break;
+						list_tests = true;
+						continue;
 					case 'v':
-						ctx.verbose = true;
-						break;
-					default:
-						printf("Unknown option: '%s'\n", argv[j]);
-						print_usage(argc, argv);
-						return 1;
+						verbose = true;
+						continue;
+					case 'h':
+						print_usage(argv[0]);
+						return 0;
 					}
+				}
+
+				fprintf(stderr, "Unknown option: '%s'\n", argstr);
+				print_usage(argv[0]);
+				return 1;
 			} else {
 				/* End of command line options, remaining must be list of tests to run */
-				ctx.test_names = argv + j;
-				ctx.test_count = argc - j;
+				test_names = argv + j;
+				test_count = argc - j;
 				break;
 			}
 		}
 	}
 
 	/* Validate command line options */
-	if (ctx.test_names && ctx.list_tests) {
-		printf("List of tests requested but test list provided\n");
-		print_usage(argc, argv);
+	if (test_names && list_tests) {
+		fprintf(stderr, "List of tests requested but test list provided\n");
+		print_usage(argv[0]);
 		return 1;
 	}
 
 	/* Setup test log output */
-	r = setup_test_output(&ctx);
-	if (r != 0)
-		return r;  
+	if (!verbose) {
+		if (!freopen(NULL_PATH, "w", stderr)) {
+			printf("Failed to open null handle: %d\n", errno);
+			return 1;
+		}
+	}
 
 	/* Act on any options not related to running tests */
-	if (ctx.list_tests) {
-		while (tests[idx].function != NULL) {
-			libusb_testlib_logf(&ctx, tests[idx].name);
-			++idx;
-		}
-		cleanup_test_output(&ctx);
+	if (list_tests) {
+		while (tests[idx].function)
+			libusb_testlib_logf("%s", tests[idx++].name);
 		return 0;
 	}
 
 	/* Run any requested tests */
-	while (tests[idx].function != NULL) {
-		const libusb_testlib_test * test = &tests[idx];
-		++idx;
-		if (ctx.test_count > 0) {
+	while (tests[idx].function) {
+		const libusb_testlib_test *test = &tests[idx++];
+		libusb_testlib_result test_result;
+
+		if (test_count > 0) {
 			/* Filtering tests to run, check if this is one of them */
 			int i;
-			for (i = 0; i < ctx.test_count; ++i) {
-				if (strcmp(ctx.test_names[i], test->name) == 0)
+
+			for (i = 0; i < test_count; i++) {
+				if (!strcmp(test_names[i], test->name))
 					/* Matches a requested test name */
 					break;
 			}
-			if (i >= ctx.test_count) {
+			if (i == test_count) {
 				/* Failed to find a test match, so do the next loop iteration */
 				continue;
 			}
 		}
-		libusb_testlib_logf(&ctx,
-			"Starting test run: %s...", test->name);
-		test_result = test->function(&ctx);
-		libusb_testlib_logf(&ctx,
-			"%s (%d)",
-			test_result_to_str(test_result), test_result);
+		libusb_testlib_logf("Starting test run: %s...", test->name);
+		test_result = test->function();
+		libusb_testlib_logf("%s (%d)", test_result_to_str(test_result), test_result);
 		switch (test_result) {
 		case TEST_STATUS_SUCCESS: pass_count++; break;
 		case TEST_STATUS_FAILURE: fail_count++; break;
 		case TEST_STATUS_ERROR: error_count++; break;
 		case TEST_STATUS_SKIP: skip_count++; break;
 		}
-		++run_count;
+		run_count++;
 	}
-	libusb_testlib_logf(&ctx, "---");
-	libusb_testlib_logf(&ctx, "Ran %d tests", run_count);
-	libusb_testlib_logf(&ctx, "Passed %d tests", pass_count);
-	libusb_testlib_logf(&ctx, "Failed %d tests", fail_count);
-	libusb_testlib_logf(&ctx, "Error in %d tests", error_count);
-	libusb_testlib_logf(&ctx, "Skipped %d tests", skip_count);
 
-	cleanup_test_output(&ctx);
+	libusb_testlib_logf("---");
+	libusb_testlib_logf("Ran %d tests", run_count);
+	libusb_testlib_logf("Passed %d tests", pass_count);
+	libusb_testlib_logf("Failed %d tests", fail_count);
+	libusb_testlib_logf("Error in %d tests", error_count);
+	libusb_testlib_logf("Skipped %d tests", skip_count);
+
 	return pass_count != run_count;
 }