usb 2.12.1 → 2.13.0

package/libusb/tests/set_option.c

@@ -0,0 +1,253 @@
+/* -*- Mode: C; indent-tabs-mode:nil -*- */
+/*
+ * Unit tests for libusb_set_option
+ * Copyright © 2023 Nathan Hjelm <hjelmn@cs.unm.edu>
+ * Copyright © 2023 Google, LLC. All rights reserved.
+ *
+ * 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 "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include "libusbi.h"
+#include "libusb_testlib.h"
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <winbase.h>
+
+#if defined(ENABLE_LOGGING)
+static int unsetenv(const char *env) {
+  return _putenv_s(env, "");
+}
+
+static int setenv(const char *env, const char *value, int overwrite) {
+  if (getenv(env) && !overwrite)
+    return 0;
+  return _putenv_s(env, value);
+}
+#endif
+#endif
+
+#define LIBUSB_TEST_CLEAN_EXIT(code) \
+  do {                               \
+    if (test_ctx != NULL) {          \
+      libusb_exit(test_ctx);         \
+    }                                \
+    unsetenv("LIBUSB_DEBUG");        \
+    return (code);                   \
+  } while (0)
+
+/**
+ * Fail the test if the expression does not evaluate to LIBUSB_SUCCESS.
+ */
+#define LIBUSB_TEST_RETURN_ON_ERROR(expr)                       \
+  do {                                                          \
+    int _result = (expr);                                       \
+    if (LIBUSB_SUCCESS != _result) {                            \
+      libusb_testlib_logf("Not success (%s) at %s:%d", #expr,   \
+                          __FILE__, __LINE__);                  \
+      LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_FAILURE);              \
+    }                                                           \
+  } while (0)
+
+/**
+ * Use relational operator to compare two values and fail the test if the
+ * comparison is false. Intended to compare integer or pointer types.
+ *
+ * Example: LIBUSB_EXPECT(==, 0, 1) -> fail, LIBUSB_EXPECT(==, 0, 0) -> ok.
+ */
+#define LIBUSB_EXPECT(operator, lhs, rhs)                               \
+  do {                                                                  \
+    int64_t _lhs = (int64_t)(intptr_t)(lhs), _rhs = (int64_t)(intptr_t)(rhs); \
+    if (!(_lhs operator _rhs)) {                                        \
+      libusb_testlib_logf("Expected %s (%" PRId64 ") " #operator        \
+                          " %s (%" PRId64 ") at %s:%d", #lhs,           \
+                          (int64_t)(intptr_t)_lhs, #rhs,                \
+                          (int64_t)(intptr_t)_rhs, __FILE__,            \
+                          __LINE__);                                    \
+      LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_FAILURE);                      \
+    }                                                                   \
+  } while (0)
+
+
+static libusb_testlib_result test_set_log_level_basic(void) {
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+  libusb_context *test_ctx = NULL;
+
+  /* unset LIBUSB_DEBUG if it is set */
+  unsetenv("LIBUSB_DEBUG");
+
+  /* test basic functionality */
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                  /*num_options=*/0));
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx,
+                                                LIBUSB_OPTION_LOG_LEVEL,
+                                                LIBUSB_LOG_LEVEL_ERROR));
+  LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_ERROR);
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx,
+                                                LIBUSB_OPTION_LOG_LEVEL,
+                                                LIBUSB_LOG_LEVEL_NONE));
+  LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_NONE);
+
+  LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+  return TEST_STATUS_SKIP;
+#endif
+}
+
+static libusb_testlib_result test_set_log_level_default(void) {
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+  libusb_context *test_ctx = NULL;
+
+  /* set the default debug level */
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL,
+                                                LIBUSB_LOG_LEVEL_ERROR));
+
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                  /*num_options=*/0));
+  /* check that debug level came from the default */
+  LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_ERROR);
+
+  /* try to override the old log level. since this was set from the default it
+   * should be possible to change it */
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx,
+                                                LIBUSB_OPTION_LOG_LEVEL,
+                                                LIBUSB_LOG_LEVEL_NONE));
+  LIBUSB_EXPECT(==, test_ctx->debug, LIBUSB_LOG_LEVEL_NONE);
+
+  LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+  return TEST_STATUS_SKIP;
+#endif
+}
+
+static libusb_testlib_result test_set_log_level_env(void) {
+#if defined(ENABLE_LOGGING)
+  libusb_context *test_ctx = NULL;
+
+  /* check that libusb_set_option does not change the log level when it was set
+   * from the environment. */
+  setenv("LIBUSB_DEBUG", "4", /*overwrite=*/0);
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                  /*num_options=*/0));
+#ifndef ENABLE_DEBUG_LOGGING
+  LIBUSB_EXPECT(==, test_ctx->debug, 4);
+#endif
+
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx,
+                                                LIBUSB_OPTION_LOG_LEVEL,
+                                                LIBUSB_LOG_LEVEL_ERROR));
+  /* environment variable should always override LIBUSB_OPTION_LOG_LEVEL if set */
+#ifndef ENABLE_DEBUG_LOGGING
+  LIBUSB_EXPECT(==, test_ctx->debug, 4);
+#endif
+
+  LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+  return TEST_STATUS_SKIP;
+#endif
+}
+
+
+static libusb_testlib_result test_no_discovery(void)
+{
+#if defined(__linux__)
+  libusb_context *test_ctx;
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                  /*num_options=*/0));
+  libusb_device **device_list = NULL;
+  ssize_t num_devices = libusb_get_device_list(test_ctx, &device_list);
+  libusb_free_device_list(device_list, /*unref_devices=*/1);
+  libusb_exit(test_ctx);
+  test_ctx = NULL;
+
+  if (num_devices == 0) {
+    libusb_testlib_logf("Warning: no devices found, the test will only verify that setting LIBUSB_OPTION_NO_DEVICE_DISCOVERY succeeds.");
+  }
+
+  LIBUSB_EXPECT(>=, num_devices, 0);
+
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(NULL, LIBUSB_OPTION_NO_DEVICE_DISCOVERY));
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                  /*num_options=*/0));
+  device_list = NULL;
+  num_devices = libusb_get_device_list(test_ctx, &device_list);
+  libusb_free_device_list(device_list, /*unref_devices=*/1);
+
+  LIBUSB_EXPECT(==, num_devices, 0);
+  LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+  return TEST_STATUS_SKIP;
+#endif
+}
+
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+static void LIBUSB_CALL test_log_cb(libusb_context *ctx, enum libusb_log_level level,
+                        const char *str) {
+  UNUSED(ctx);
+  UNUSED(level);
+  UNUSED(str);
+}
+#endif
+
+
+static libusb_testlib_result test_set_log_cb(void)
+{
+#if defined(ENABLE_LOGGING) && !defined(ENABLE_DEBUG_LOGGING)
+  libusb_context *test_ctx = NULL;
+
+  /* set the log callback on the context */
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                  /*num_options=*/0));
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(test_ctx, LIBUSB_OPTION_LOG_CB,
+                                                test_log_cb));
+
+  /* check that debug level came from the default */
+  LIBUSB_EXPECT(==, test_ctx->log_handler, test_log_cb);
+
+  libusb_exit(test_ctx);
+  test_ctx = NULL;
+
+  /* set the log callback for all future contexts */
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_set_option(/*ctx=*/NULL, LIBUSB_OPTION_LOG_CB,
+                                                test_log_cb));
+  LIBUSB_TEST_RETURN_ON_ERROR(libusb_init_context(&test_ctx, /*options=*/NULL,
+                                                  /*num_options=*/0));
+  LIBUSB_EXPECT(==, test_ctx->log_handler, test_log_cb);
+
+
+  LIBUSB_TEST_CLEAN_EXIT(TEST_STATUS_SUCCESS);
+#else
+  return TEST_STATUS_SKIP;
+#endif
+}
+
+static const libusb_testlib_test tests[] = {
+  { "test_set_log_level_basic", &test_set_log_level_basic },
+  { "test_set_log_level_env", &test_set_log_level_env },
+  { "test_no_discovery", &test_no_discovery },
+  /* since default options can't be unset, run this one last */
+  { "test_set_log_level_default", &test_set_log_level_default },
+  { "test_set_log_cb", &test_set_log_cb },
+  LIBUSB_NULL_TEST
+};
+
+int main(int argc, char *argv[])
+{
+  return libusb_testlib_run_tests(argc, argv, tests);
+}

package/libusb/tests/stress.c

@@ -32,7 +32,7 @@ static libusb_testlib_result test_init_and_exit(void)
 		libusb_context *ctx = NULL;
 		int r;
 
-		r = libusb_init(&ctx);
+		r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
 		if (r != LIBUSB_SUCCESS) {
 			libusb_testlib_logf(
 				"Failed to init libusb on iteration %d: %d",
@@ -51,7 +51,7 @@ static libusb_testlib_result test_get_device_list(void)
 	libusb_context *ctx;
 	int r;
 
-	r = libusb_init(&ctx);
+	r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
 	if (r != LIBUSB_SUCCESS) {
 		libusb_testlib_logf("Failed to init libusb: %d", r);
 		return TEST_STATUS_FAILURE;
@@ -63,7 +63,7 @@ static libusb_testlib_result test_get_device_list(void)
 		if (list_size < 0 || !device_list) {
 			libusb_testlib_logf(
 				"Failed to get device list on iteration %d: %ld (%p)",
-				i, (long)-list_size, device_list);
+				i, (long) -list_size, (void *) device_list);
 			libusb_exit(ctx);
 			return TEST_STATUS_FAILURE;
 		}
@@ -83,7 +83,7 @@ static libusb_testlib_result test_many_device_lists(void)
 	libusb_device **device_lists[LIST_COUNT];
 	int r;
 
-	r = libusb_init(&ctx);
+	r = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0);
 	if (r != LIBUSB_SUCCESS) {
 		libusb_testlib_logf("Failed to init libusb: %d", r);
 		return TEST_STATUS_FAILURE;
@@ -97,7 +97,7 @@ static libusb_testlib_result test_many_device_lists(void)
 		if (list_size < 0 || !device_lists[i]) {
 			libusb_testlib_logf(
 				"Failed to get device list on iteration %d: %ld (%p)",
-				i, (long)-list_size, device_lists[i]);
+				i, (long) -list_size, (void *) device_lists[i]);
 			result = TEST_STATUS_FAILURE;
 			break;
 		}
@@ -123,22 +123,25 @@ static libusb_testlib_result test_default_context_change(void)
 		libusb_context *ctx = NULL;
 		int r;
 
+
+		/* Enable debug output on new context, to be sure to use the context */
+		struct libusb_init_option options[] = {
+		  {
+		    .option = LIBUSB_OPTION_LOG_LEVEL,
+		    .value = {.ival = LIBUSB_LOG_LEVEL_DEBUG},
+		  },
+		};
+		int num_options = 1;
+
 		/* First create a new context */
-		r = libusb_init(&ctx);
+		r = libusb_init_context(&ctx, options, num_options);
 		if (r != LIBUSB_SUCCESS) {
 			libusb_testlib_logf("Failed to init libusb: %d", r);
 			return TEST_STATUS_FAILURE;
 		}
 
-		/* Enable debug output on new context, to be sure to use the context */
-		libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_DEBUG);
-
-		/* Enable debug output on the default context. This should work even before
-		 * the context has been created. */
-		libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_DEBUG);
-
 		/* Now create a reference to the default context */
-		r = libusb_init(NULL);
+		r = libusb_init_context(/*ctx=*/NULL, options, num_options);
 		if (r != LIBUSB_SUCCESS) {
 			libusb_testlib_logf("Failed to init libusb: %d", r);
 			libusb_exit(ctx);

package/libusb/tests/stress_mt.c

@@ -0,0 +1,265 @@
+/*
+ * libusb multi-thread test program
+ * Copyright 2022-2023 Tormod Volden
+ *
+ * This program 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 program 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 <config.h>
+
+#include <libusb.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#if defined(PLATFORM_POSIX)
+
+#include <pthread.h>
+typedef pthread_t thread_t;
+typedef void * thread_return_t;
+#define THREAD_RETURN_VALUE NULL
+#define THREAD_CALL_TYPE
+
+static inline int thread_create(thread_t *thread,
+	thread_return_t (*thread_entry)(void *arg), void *arg)
+{
+	return pthread_create(thread, NULL, thread_entry, arg) == 0 ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread)
+{
+	(void)pthread_join(thread, NULL);
+}
+
+#include <stdatomic.h>
+
+#elif defined(PLATFORM_WINDOWS)
+
+typedef HANDLE thread_t;
+#define THREAD_RETURN_VALUE 0
+#define THREAD_CALL_TYPE __stdcall
+
+#if defined(__CYGWIN__)
+typedef DWORD thread_return_t;
+#else
+#include <process.h>
+typedef unsigned thread_return_t;
+#endif
+
+static inline int thread_create(thread_t *thread,
+	thread_return_t (__stdcall *thread_entry)(void *arg), void *arg)
+{
+#if defined(__CYGWIN__)
+	*thread = CreateThread(NULL, 0, thread_entry, arg, 0, NULL);
+#else
+	*thread = (HANDLE)_beginthreadex(NULL, 0, thread_entry, arg, 0, NULL);
+#endif
+	return *thread != NULL ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread)
+{
+	(void)WaitForSingleObject(thread, INFINITE);
+	(void)CloseHandle(thread);
+}
+
+typedef volatile LONG atomic_bool;
+
+#define atomic_exchange InterlockedExchange
+#endif /* PLATFORM_WINDOWS */
+
+/* Test that creates and destroys contexts repeatedly */
+
+#define NTHREADS 8
+#define ITERS 64
+#define MAX_DEVCOUNT 128
+
+struct thread_info {
+	int number;
+	int enumerate;
+	ssize_t devcount;
+	int err;
+	int iteration;
+} tinfo[NTHREADS];
+
+atomic_bool no_access[MAX_DEVCOUNT];
+
+/* Function called by backend during device initialization to convert
+ * multi-byte fields in the device descriptor to host-endian format.
+ * Copied from libusbi.h as we want test to be realistic and not depend on internals.
+ */
+static inline void usbi_localize_device_descriptor(struct libusb_device_descriptor *desc)
+{
+	desc->bcdUSB = libusb_le16_to_cpu(desc->bcdUSB);
+	desc->idVendor = libusb_le16_to_cpu(desc->idVendor);
+	desc->idProduct = libusb_le16_to_cpu(desc->idProduct);
+	desc->bcdDevice = libusb_le16_to_cpu(desc->bcdDevice);
+}
+
+static thread_return_t THREAD_CALL_TYPE init_and_exit(void * arg)
+{
+	struct thread_info *ti = (struct thread_info *) arg;
+
+	for (ti->iteration = 0; ti->iteration < ITERS && !ti->err; ti->iteration++) {
+		libusb_context *ctx = NULL;
+
+		if ((ti->err = libusb_init_context(&ctx, /*options=*/NULL, /*num_options=*/0)) != 0) {
+			break;
+		}
+		if (ti->enumerate) {
+			libusb_device **devs;
+			ti->devcount = libusb_get_device_list(ctx, &devs);
+			if (ti->devcount < 0) {
+				ti->err = (int)ti->devcount;
+				break;
+			}
+			for (int i = 0; i < ti->devcount && ti->err == 0; i++) {
+				libusb_device *dev = devs[i];
+				struct libusb_device_descriptor desc;
+				if ((ti->err = libusb_get_device_descriptor(dev, &desc)) != 0) {
+					break;
+				}
+				if (no_access[i]) {
+					continue;
+				}
+				libusb_device_handle *dev_handle;
+				int open_err = libusb_open(dev, &dev_handle);
+				if (open_err == LIBUSB_ERROR_ACCESS
+#if defined(PLATFORM_WINDOWS)
+				    || open_err == LIBUSB_ERROR_NOT_SUPPORTED
+				    || open_err == LIBUSB_ERROR_NOT_FOUND
+#endif
+						) {
+					/* Use atomic swap to ensure we print warning only once across all threads.
+					   This is a warning and not a hard error because it should be fine to run tests
+					   even if we don't have access to some devices. */
+					if (!atomic_exchange(&no_access[i], true)) {
+						fprintf(stderr, "No access to device %04x:%04x, skipping transfer tests.\n", desc.idVendor, desc.idProduct);
+					}
+					continue;
+				}
+				if (open_err != 0) {
+					ti->err = open_err;
+					break;
+				}
+				/* Request raw descriptor via control transfer.
+				   This tests opening, transferring and closing from multiple threads in parallel. */
+				struct libusb_device_descriptor raw_desc;
+				int raw_desc_len = libusb_get_descriptor(dev_handle, LIBUSB_DT_DEVICE, 0, (unsigned char *)&raw_desc, sizeof(raw_desc));
+				if (raw_desc_len < 0) {
+					ti->err = raw_desc_len;
+					goto close;
+				}
+				if (raw_desc_len != sizeof(raw_desc)) {
+					fprintf(stderr, "Thread %d: device %d: unexpected raw descriptor length %d\n",
+						ti->number, i, raw_desc_len);
+					ti->err = LIBUSB_ERROR_OTHER;
+					goto close;
+				}
+				usbi_localize_device_descriptor(&raw_desc);
+#define ASSERT_EQ(field) if (raw_desc.field != desc.field) { \
+	fprintf(stderr, "Thread %d: device %d: mismatch in field " #field ": %d != %d\n", \
+		ti->number, i, raw_desc.field, desc.field); \
+		ti->err = LIBUSB_ERROR_OTHER; \
+		goto close; \
+}
+				ASSERT_EQ(bLength);
+				ASSERT_EQ(bDescriptorType);
+#if !defined(PLATFORM_WINDOWS)
+				/* these are hardcoded by the winusbx HID backend */
+				ASSERT_EQ(bcdUSB);
+				ASSERT_EQ(bDeviceClass);
+				ASSERT_EQ(bDeviceSubClass);
+				ASSERT_EQ(bDeviceProtocol);
+				ASSERT_EQ(bMaxPacketSize0);
+				ASSERT_EQ(bcdDevice);
+#endif
+				ASSERT_EQ(idVendor);
+				ASSERT_EQ(idProduct);
+				ASSERT_EQ(iManufacturer);
+				ASSERT_EQ(iProduct);
+				ASSERT_EQ(iSerialNumber);
+				ASSERT_EQ(bNumConfigurations);
+			close:
+				libusb_close(dev_handle);
+			}
+			libusb_free_device_list(devs, 1);
+		}
+
+		libusb_exit(ctx);
+	}
+	return (thread_return_t) THREAD_RETURN_VALUE;
+}
+
+static int test_multi_init(int enumerate)
+{
+	thread_t threadId[NTHREADS];
+	int errs = 0;
+	int t, i;
+	ssize_t last_devcount = 0;
+	int devcount_mismatch = 0;
+	int access_failures = 0;
+
+	printf("Starting %d threads\n", NTHREADS);
+	for (t = 0; t < NTHREADS; t++) {
+		tinfo[t].err = 0;
+		tinfo[t].number = t;
+		tinfo[t].enumerate = enumerate;
+		thread_create(&threadId[t], &init_and_exit, (void *) &tinfo[t]);
+	}
+
+	for (t = 0; t < NTHREADS; t++) {
+		thread_join(threadId[t]);
+		if (tinfo[t].err) {
+			errs++;
+			fprintf(stderr,
+				"Thread %d failed (iteration %d): %s\n",
+				tinfo[t].number,
+				tinfo[t].iteration,
+				libusb_error_name(tinfo[t].err));
+		} else if (enumerate) {
+			if (t > 0 && tinfo[t].devcount != last_devcount) {
+				devcount_mismatch++;
+				printf("Device count mismatch: Thread %d discovered %ld devices instead of %ld\n",
+				       tinfo[t].number,
+				       (long int) tinfo[t].devcount,
+				       (long int) last_devcount);
+			}
+			last_devcount = tinfo[t].devcount;
+		}
+	}
+
+	for (i = 0; i < MAX_DEVCOUNT; i++)
+		if (no_access[i])
+			access_failures++;
+
+	if (enumerate && !devcount_mismatch)
+		printf("All threads discovered %ld devices (%i not opened)\n",
+		       (long int) last_devcount, access_failures);
+
+	return errs + devcount_mismatch;
+}
+
+int main(void)
+{
+	int errs = 0;
+
+	printf("Running multithreaded init/exit test...\n");
+	errs += test_multi_init(0);
+	printf("Running multithreaded init/exit test with enumeration...\n");
+	errs += test_multi_init(1);
+	printf("All done, %d errors\n", errs);
+
+	return errs != 0;
+}

package/libusb/tests/testlib.c

@@ -180,5 +180,5 @@ int libusb_testlib_run_tests(int argc, char *argv[],
 	libusb_testlib_logf("Error in %d tests", error_count);
 	libusb_testlib_logf("Skipped %d tests", skip_count);
 
-	return pass_count != run_count;
+	return fail_count + error_count;
 }

package/libusb/tests/umockdev.c

@@ -33,7 +33,7 @@
 #define UNUSED_DATA __attribute__ ((unused)) gconstpointer unused_data
 
 /* avoid leak reports inside assertions; leaking stuff on assertion failures does not matter in tests */
-#if !defined(__clang__)
+#if !defined(__clang__) && __GNUC__ > 9
 #pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak"
 #pragma GCC diagnostic ignored "-Wanalyzer-file-leak"
 #endif
@@ -89,7 +89,7 @@ typedef struct {
 	GList *flying_urbs;
 	GList *discarded_urbs;
 
-	/* GMutex confuses tsan unecessarily */
+	/* GMutex confuses TSan unnecessarily */
 	pthread_mutex_t mutex;
 } UMockdevTestbedFixture;
 
@@ -245,7 +245,7 @@ handle_ioctl_cb (UMockdevIoctlBase *handler, UMockdevIoctlClient *client, UMockd
 	ioctl_arg = umockdev_ioctl_client_get_arg (client);
 
 	/* NOTE: We share the address space, dereferencing pointers *will* work.
-	 * However, to make tsan work, we still stick to the API that resolves
+	 * However, to make TSan work, we still stick to the API that resolves
 	 * the data into a local copy! */
 
 	switch (request) {
@@ -430,9 +430,9 @@ test_fixture_setup_libusb(UMockdevTestbedFixture * fixture, int devcount)
 {
 	libusb_device **devs = NULL;
 
-	libusb_init (&fixture->ctx);
+	libusb_init_context(/*ctx=*/&fixture->ctx, /*options=*/NULL, /*num_options=*/0);
 
-	/* Supress global log messages completely
+	/* Suppress global log messages completely
 	 * (though, in some tests it might be interesting to check there are no real ones).
 	 */
 	libusb_set_log_cb (NULL, log_handler_null, LIBUSB_LOG_CB_GLOBAL);
@@ -573,7 +573,7 @@ test_implicit_default(UMockdevTestbedFixture * fixture, UNUSED_DATA)
 	libusb_free_device_list(devs, TRUE);
 	clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO);
 
-	libusb_init(NULL);
+	libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0);
 	g_assert_cmpint(libusb_get_device_list(NULL, &devs), ==, 1);
 	libusb_exit(NULL);
 
@@ -876,7 +876,7 @@ transfer_submit_all_retry(TestThreadedSubmit *data)
 	return NULL;
 }
 
-static void
+static void LIBUSB_CALL
 test_threaded_submit_transfer_cb(struct libusb_transfer *transfer)
 {
 	TestThreadedSubmit *data = transfer->user_data;
@@ -955,7 +955,7 @@ test_threaded_submit(UMockdevTestbedFixture * fixture, UNUSED_DATA)
 	g_free (c);
 }
 
-static int
+static int LIBUSB_CALL
 hotplug_count_arrival_cb(libusb_context *ctx,
                          libusb_device  *device,
                          libusb_hotplug_event event,
@@ -972,7 +972,7 @@ hotplug_count_arrival_cb(libusb_context *ctx,
 }
 
 #ifdef UMOCKDEV_HOTPLUG
-static int
+static int LIBUSB_CALL
 hotplug_count_removal_cb(libusb_context *ctx,
                          libusb_device  *device,
                          libusb_hotplug_event event,

package/libusb/tests/webusb-test-shim/index.js

@@ -0,0 +1,12 @@
+// It's not yet possible to automate actual Chrome's device selection, so
+// for now run automated tests via Node.js WebUSB implementation.
+//
+// It might differ from browser one, but should be enough to catch most obvious issues.
+
+const { WebUSB } = require('usb');
+
+globalThis.navigator = {
+  usb: new WebUSB({
+    allowAllDevices: true
+  })
+};