hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 1255

Browse Source
This commit is contained in:
pineappleEA
2020-12-28 15:15:37 +00:00
parent 84b39492d1
commit 78b48028e1
6254 changed files with 1868140 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
externals/libusb/libusb/tests/Makefile.am vendored Executable file
View File

@@ -0,0 +1,6 @@
AM_CPPFLAGS = -I$(top_srcdir)/libusb
LDADD = ../libusb/libusb-1.0.la
noinst_PROGRAMS = stress
stress_SOURCES = stress.c libusb_testlib.h testlib.c

107
externals/libusb/libusb/tests/libusb_testlib.h vendored Executable file
View File

@@ -0,0 +1,107 @@
/*
* libusb test library helper functions
* Copyright © 2012 Toby Gray <toby.gray@realvnc.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBUSB_TESTLIB_H
#define LIBUSB_TESTLIB_H
#include <stdio.h>
#if !defined(bool)
#define bool int
#endif
#if !defined(true)
#define true (1 == 1)
#endif
#if !defined(false)
#define false (!true)
#endif
/** Values returned from a test function to indicate test result */
typedef enum {
/** Indicates that the test ran successfully. */
TEST_STATUS_SUCCESS,
/** Indicates that the test failed one or more test. */
TEST_STATUS_FAILURE,
/** Indicates that an unexpected error occurred. */
TEST_STATUS_ERROR,
/** Indicates that the test can't be run. For example this may be
* due to no suitable device being connected to perform the tests.*/
TEST_STATUS_SKIP
} libusb_testlib_result;
/**
* Context for test library functions
*/
typedef struct {
char ** test_names;
int test_count;
bool list_tests;
bool verbose;
int old_stdout;
int old_stderr;
FILE* output_file;
int null_fd;
} libusb_testlib_ctx;
/**
* Logs some test information or state
*/
void libusb_testlib_logf(libusb_testlib_ctx * ctx,
const char* fmt, ...);
/**
* Function pointer for a libusb test function.
*
* Should return TEST_STATUS_SUCCESS on success or another TEST_STATUS value.
*/
typedef libusb_testlib_result
(*libusb_testlib_test_function)(libusb_testlib_ctx * ctx);
/**
* Structure holding a test description.
*/
typedef struct {
/** Human readable name of the test. */
const char * name;
/** The test library will call this function to run the test. */
libusb_testlib_test_function function;
} libusb_testlib_test;
/**
* Value to use at the end of a test array to indicate the last
* element.
*/
#define LIBUSB_NULL_TEST {NULL, NULL}
/**
* Runs the tests provided.
*
* Before running any tests argc and argv will be processed
* to determine the mode of operation.
*
* \param argc The argc from main
* \param argv The argv from main
* \param tests A NULL_TEST terminated array of tests
* \return 0 on success, non-zero on failure
*/
int libusb_testlib_run_tests(int argc,
char ** argv,
const libusb_testlib_test * tests);
#endif //LIBUSB_TESTLIB_H

160
externals/libusb/libusb/tests/stress.c vendored Executable file
View File

@@ -0,0 +1,160 @@
/*
* libusb stress test program to perform simple stress tests
* Copyright © 2012 Toby Gray <toby.gray@realvnc.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include <memory.h>
#include "libusb.h"
#include "libusb_testlib.h"
/** Test that creates and destroys a single concurrent context
* 10000 times. */
static libusb_testlib_result test_init_and_exit(libusb_testlib_ctx * tctx)
{
libusb_context * ctx = NULL;
int i;
for (i = 0; i < 10000; ++i) {
int r = libusb_init(&ctx);
if (r != LIBUSB_SUCCESS) {
libusb_testlib_logf(tctx,
"Failed to init libusb on iteration %d: %d",
i, r);
return TEST_STATUS_FAILURE;
}
libusb_exit(ctx);
ctx = NULL;
}
return TEST_STATUS_SUCCESS;
}
/** Tests that devices can be listed 1000 times. */
static libusb_testlib_result test_get_device_list(libusb_testlib_ctx * tctx)
{
libusb_context * ctx = NULL;
int r, i;
r = libusb_init(&ctx);
if (r != LIBUSB_SUCCESS) {
libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
return TEST_STATUS_FAILURE;
}
for (i = 0; i < 1000; ++i) {
libusb_device ** device_list;
ssize_t list_size = libusb_get_device_list(ctx, &device_list);
if (list_size < 0 || device_list == NULL) {
libusb_testlib_logf(tctx,
"Failed to get device list on iteration %d: %d (%p)",
i, -list_size, device_list);
return TEST_STATUS_FAILURE;
}
libusb_free_device_list(device_list, 1);
}
libusb_exit(ctx);
return TEST_STATUS_SUCCESS;
}
/** Tests that 100 concurrent device lists can be open at a time. */
static libusb_testlib_result test_many_device_lists(libusb_testlib_ctx * tctx)
{
#define LIST_COUNT 100
libusb_context * ctx = NULL;
libusb_device ** device_lists[LIST_COUNT];
int r, i;
memset(device_lists, 0, sizeof(device_lists));
r = libusb_init(&ctx);
if (r != LIBUSB_SUCCESS) {
libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
return TEST_STATUS_FAILURE;
}
/* Create the 100 device lists. */
for (i = 0; i < LIST_COUNT; ++i) {
ssize_t list_size = libusb_get_device_list(ctx, &(device_lists[i]));
if (list_size < 0 || device_lists[i] == NULL) {
libusb_testlib_logf(tctx,
"Failed to get device list on iteration %d: %d (%p)",
i, -list_size, device_lists[i]);
return TEST_STATUS_FAILURE;
}
}
/* Destroy the 100 device lists. */
for (i = 0; i < LIST_COUNT; ++i) {
if (device_lists[i]) {
libusb_free_device_list(device_lists[i], 1);
device_lists[i] = NULL;
}
}
libusb_exit(ctx);
return TEST_STATUS_SUCCESS;
#undef LIST_COUNT
}
/** Tests that the default context (used for various things including
* logging) works correctly when the first context created in a
* process is destroyed. */
static libusb_testlib_result test_default_context_change(libusb_testlib_ctx * tctx)
{
libusb_context * ctx = NULL;
int r, i;
for (i = 0; i < 100; ++i) {
/* First create a new context */
r = libusb_init(&ctx);
if (r != LIBUSB_SUCCESS) {
libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
return TEST_STATUS_FAILURE;
}
/* Enable debug output, to be sure to use the context */
libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_DEBUG);
libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_DEBUG);
/* Now create a reference to the default context */
r = libusb_init(NULL);
if (r != LIBUSB_SUCCESS) {
libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
return TEST_STATUS_FAILURE;
}
/* Destroy the first context */
libusb_exit(ctx);
/* Destroy the default context */
libusb_exit(NULL);
}
return TEST_STATUS_SUCCESS;
}
/* Fill in the list of tests. */
static const libusb_testlib_test tests[] = {
{"init_and_exit", &test_init_and_exit},
{"get_device_list", &test_get_device_list},
{"many_device_lists", &test_many_device_lists},
{"default_context_change", &test_default_context_change},
LIBUSB_NULL_TEST
};
int main (int argc, char ** argv)
{
return libusb_testlib_run_tests(argc, argv, tests);
}

277
externals/libusb/libusb/tests/testlib.c vendored Executable file
View File

@@ -0,0 +1,277 @@
/*
* libusb test library helper functions
* Copyright © 2012 Toby Gray <toby.gray@realvnc.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libusb_testlib.h"
#include <stdio.h>
#include <stdarg.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>
#define NULL_PATH "/dev/null"
#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)
{
switch (result) {
case TEST_STATUS_SUCCESS:
return "Success";
case TEST_STATUS_FAILURE:
return "Failure";
case TEST_STATUS_ERROR:
return "Error";
case TEST_STATUS_SKIP:
return "Skip";
default:
return "Unknown";
}
}
static void print_usage(int argc, char ** argv)
{
printf("Usage: %s [-l] [-v] [<test_name> ...]\n",
argc > 0 ? argv[0] : "test_*");
printf(" -l List available tests\n");
printf(" -v Don't redirect STDERR/STDOUT during tests\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, ...)
{
va_list va;
va_start(va, fmt);
vfprintf(ctx->output_file, fmt, va);
va_end(va);
fprintf(ctx->output_file, "\n");
fflush(ctx->output_file);
}
int libusb_testlib_run_tests(int argc,
char ** argv,
const libusb_testlib_test * tests)
{
int run_count = 0;
int idx = 0;
int pass_count = 0;
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;
/* 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]) {
case 'l':
ctx.list_tests = true;
break;
case 'v':
ctx.verbose = true;
break;
default:
printf("Unknown option: '%s'\n", argv[j]);
print_usage(argc, argv);
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;
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);
return 1;
}
/* Setup test log output */
r = setup_test_output(&ctx);
if (r != 0)
return r;
/* 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);
return 0;
}
/* Run any requested tests */
while (tests[idx].function != NULL) {
const libusb_testlib_test * test = &tests[idx];
++idx;
if (ctx.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)
/* Matches a requested test name */
break;
}
if (i >= ctx.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);
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;
}
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);
return pass_count != run_count;
}