summaryrefslogtreecommitdiff
path: root/testsuite/sanei/sanei_usb_test.c
diff options
context:
space:
mode:
Diffstat (limited to 'testsuite/sanei/sanei_usb_test.c')
-rw-r--r--testsuite/sanei/sanei_usb_test.c949
1 files changed, 949 insertions, 0 deletions
diff --git a/testsuite/sanei/sanei_usb_test.c b/testsuite/sanei/sanei_usb_test.c
new file mode 100644
index 0000000..4c5240e
--- /dev/null
+++ b/testsuite/sanei/sanei_usb_test.c
@@ -0,0 +1,949 @@
+#include "../../include/sane/config.h"
+
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <math.h>
+#include <stddef.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_MKDIR
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+#include <assert.h>
+
+#define BACKEND_NAME sanei_usb
+
+#include "../../include/sane/sane.h"
+#include "../../include/sane/sanei.h"
+#include "../../include/sane/saneopts.h"
+
+#include "../../include/sane/sanei_backend.h"
+#include "../../include/sane/sanei_usb.h"
+
+#include "../../include/_stdint.h"
+
+/*
+ * In order to avoid modifying sanei_usb.c to allow for unit tests
+ * we include it so we can use its private variables and structures
+ * and still test the code.
+ */
+#include "../../sanei/sanei_usb.c"
+
+
+/** test sanei_usb_init()
+ * calls sanei_usb_init
+ * @param expected expected use count
+ * @return 1 on success, else 0
+ */
+static int
+test_init (int expected)
+{
+ /* initialize USB */
+ printf ("%s starting ...\n", __FUNCTION__);
+ sanei_usb_init ();
+ if (initialized == 0)
+ {
+ printf ("ERROR: sanei_usb not initialized!\n");
+ return 0;
+ }
+ if (initialized != expected)
+ {
+ printf ("ERROR: incorrect use count, expected %d, got %d!\n", expected,
+ initialized);
+ return 0;
+ }
+
+ printf ("sanei_usb initialized, use count is %d ...\n", initialized);
+ printf ("%s success\n\n", __FUNCTION__);
+ return 1;
+}
+
+/** test sanei_usb_exit()
+ * calls sanei_usb_exit
+ * @param expected use count after exit call
+ * @return 1 on success, else 0
+ */
+static int
+test_exit (int expected)
+{
+ printf ("%s starting ...\n", __FUNCTION__);
+
+ /* end of USB use test */
+ sanei_usb_exit ();
+ if (initialized != expected)
+ {
+ printf ("ERROR: incorrect use count, expected %d, got %d!\n", expected,
+ initialized);
+ return 0;
+ }
+
+ printf ("%s success\n\n", __FUNCTION__);
+ return 1;
+}
+
+
+/** count detected devices
+ * count all detected devices and check it against expected value
+ * @param expected detected count
+ * @return 1 on success, else 0
+ */
+static int
+count_detected (int expected)
+{
+ int num = 0;
+ int i;
+
+ for (i = 0; i < device_number; i++)
+ {
+ if (devices[i].missing == 0 && devices[i].devname != NULL)
+ {
+ num++;
+ }
+ }
+ if (num != expected)
+ {
+ printf ("ERROR: %d detected devices, expected %d!\n", num, expected);
+ return 0;
+ }
+ printf ("%d devices still detected.\n", num);
+ return 1;
+}
+
+/** create mock device
+ * create a mock device entry
+ * @param device device pointer to fill with mock data
+ * @return nothing
+ */
+static void
+create_mock_device (char *devname, device_list_type * device)
+{
+ memset (device, 0, sizeof (device_list_type));
+ device->devname = strdup (devname);
+ device->vendor = 0xdead;
+ device->product = 0xbeef;
+#if defined(HAVE_LIBUSB) || defined(HAVE_LIBUSB_1_0)
+ device->method = sanei_usb_method_libusb;
+#endif
+#ifdef HAVE_USBCALLS
+ device->method = sanei_usb_method_usbcalls;
+#endif
+#if !defined(HAVE_LIBUSB) && !defined(HAVE_LIBUSB_1_0) && !defined(HAVE_USBCALLS)
+ device->method == sanei_usb_method_scanner_driver;
+#endif
+}
+
+/** test store_device
+ * test store_device for corner cases not covered by the
+ * other regular use by sanei_usb_scan_devices
+ * the startiing situation is that the mock device has never
+ * put into device list.
+ * @return 1 on success, else 0
+ */
+static int
+test_store_device (void)
+{
+ int current_number;
+ int expected;
+ int i;
+ int found;
+ device_list_type mock;
+
+ create_mock_device ("mock", &mock);
+
+ /* first test store when there is no more room
+ * to store device */
+ current_number = device_number;
+ device_number = MAX_DEVICES;
+ /* give unused devices a name so strcmp() won't crash. */
+ for (i = current_number; i < MAX_DEVICES; i++)
+ devices[i].devname = "";
+
+ store_device (mock);
+ /* there should be no more devices */
+ if (device_number > MAX_DEVICES)
+ {
+ printf ("ERROR: store past end of device list!\n");
+ return 0;
+ }
+ /* walk device list to be sure mock device hasn't been stored */
+ for (i = 0; i < MAX_DEVICES; i++)
+ {
+ if (devices[i].devname && !strcmp (devices[i].devname, mock.devname))
+ {
+ printf
+ ("ERROR: device stored although there were no place for it!\n");
+ return 0;
+ }
+ }
+
+ /* restore device_number */
+ device_number = current_number;
+ /* reset unused devnames to NULL */
+ for (i = current_number; i < MAX_DEVICES; i++)
+ devices[i].devname = NULL;
+ expected = device_number + 1;
+
+ /* store mock device */
+ store_device (mock);
+ found = 0;
+ for (i = 0; i < MAX_DEVICES && !found; i++)
+ {
+ if (devices[i].devname && !strcmp (devices[i].devname, mock.devname))
+ {
+ found = 1;
+ }
+ }
+ if (device_number != expected || !found)
+ {
+ printf ("ERROR: mock device not stored !\n");
+ return 0;
+ }
+
+ /* scan devices should mark it as missing, and device_number should decrease */
+ sanei_usb_scan_devices ();
+ found = 0;
+ for (i = 0; i < MAX_DEVICES && !found; i++)
+ {
+ if (devices[i].devname
+ && devices[i].missing == 1
+ && !strcmp (devices[i].devname, mock.devname))
+ {
+ found = 1;
+ }
+ }
+ if (device_number != expected || !found)
+ {
+ printf ("ERROR: mock device still present !\n");
+ return 0;
+ }
+
+ /* second scan devices should mark missing to 2 */
+ sanei_usb_scan_devices ();
+ found = 0;
+ for (i = 0; i < MAX_DEVICES && !found; i++)
+ {
+ if (devices[i].devname
+ && devices[i].missing == 2
+ && !strcmp (devices[i].devname, mock.devname))
+ {
+ found = 1;
+ }
+ }
+ if (device_number != expected || !found)
+ {
+ printf ("ERROR: mock device slot not reusable !\n");
+ return 0;
+ }
+
+ /* store mock device again, slot in devices should be reused
+ * and device_number shouldn't change */
+ create_mock_device ("mock2", &mock);
+ store_device (mock);
+ found = 0;
+ for (i = 0; i < MAX_DEVICES && !found; i++)
+ {
+ if (devices[i].devname && !strcmp (devices[i].devname, mock.devname))
+ {
+ found = 1;
+ }
+ }
+ if (device_number != expected || !found)
+ {
+ printf ("ERROR: mock device not stored !\n");
+ return 0;
+ }
+
+ /* last rescan to wipe mock device out */
+ sanei_usb_scan_devices ();
+
+ return 1;
+}
+
+/** return count of opened devices
+ * @return count of opened devices
+ */
+static int
+get_opened (void)
+{
+ int num = 0;
+ int i;
+
+ for (i = 0; i < device_number; i++)
+ {
+ if (devices[i].missing == 0 && devices[i].devname != NULL
+ && devices[i].open == SANE_TRUE)
+ {
+ num++;
+ }
+ }
+ return num;
+}
+
+/** count opened devices
+ * count all opended devices and check it against expected value
+ * @param expected use opened count
+ * @return 1 on success, else 0
+ */
+static int
+count_opened (int expected)
+{
+ int num = get_opened();
+
+ if (num != expected)
+ {
+ printf ("ERROR: %d opened devices, expected %d!\n", num, expected);
+ return 0;
+ }
+ printf ("%d devices still opened.\n", num);
+ return 1;
+}
+
+/** open all devices
+ * loop on all existing devices and open them
+ * @param dn array to store opened device number
+ * @param expected number of devices to be opened
+ * @return 1 on success, else 0
+ */
+static int
+test_open_all (SANE_Int * dn, int expected)
+{
+ int opened = 0;
+ int i;
+ int last;
+ SANE_Status status;
+
+ /* loop on detected devices and open them */
+ last = -1;
+ for (i = 0; i < device_number; i++)
+ {
+ if (devices[i].missing == 0 && devices[i].devname != NULL)
+ {
+ /* open device */
+ status = sanei_usb_open (devices[i].devname, dn + opened);
+ if (status == SANE_STATUS_GOOD)
+ {
+ opened++;
+ last = i;
+ }
+ else
+ {
+ if (status == SANE_STATUS_ACCESS_DENIED ||
+ status == SANE_STATUS_DEVICE_BUSY)
+ {
+ expected--;
+ }
+ else
+ {
+ printf ("ERROR: couldn't open device %s!\n",
+ devices[i].devname);
+ return 0;
+ }
+ }
+ }
+ }
+ printf ("opened %d devices\n", opened);
+
+ /* try to reopen an opened device when there is one */
+ if (last >= 0)
+ {
+ status = sanei_usb_open (devices[last].devname, dn + opened);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: unexpected success when opening %s twice!\n",
+ devices[last].devname);
+ return 0;
+ }
+ }
+
+ /* there should be as many opened devices than detected devices */
+ return count_opened (expected);
+}
+
+/** test opening invalid device
+ * try to open an non existing device
+ * @return 1 on success, else 0
+ */
+static int
+test_open_invalid (void)
+{
+ SANE_Status status;
+ SANE_Int dn;
+
+ status = sanei_usb_open ("invalid device", &dn);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: unexpected success opening invalid device!\n");
+ return 0;
+ }
+ return 1;
+}
+
+/** close all devices
+ * loop on all opened devices and close them
+ * @param dn array of opened device number
+ * @param expected number of devices to be closed
+ * @return 1 on success, else 0
+ */
+static int
+test_close_all (SANE_Int * dn, int expected)
+{
+ int closed = 0;
+ int i;
+
+ /* loop on detected devices and open them */
+ for (i = 0; i < expected; i++)
+ {
+ /* close device */
+ sanei_usb_close (dn[i]);
+ closed++;
+ }
+ printf ("closed %d devices\n", closed);
+
+ /* there should be any more opened devices */
+ return count_opened (0);
+}
+
+
+/** claim all open devices
+ * loop on all opened devices and claim interface 0
+ * @param dn array of opened device number
+ * @param expected number of devices to be claimed
+ * @return 1 on success, else 0
+ */
+static int
+test_claim_all (SANE_Int * dn, int expected)
+{
+ int claimed = 0;
+ int i;
+ SANE_Status status;
+ device_list_type mock;
+
+ claimed = 0;
+ for (i = 0; i < expected; i++)
+ {
+ status = sanei_usb_claim_interface (dn[i], devices[dn[i]].interface_nr);
+ if (status != SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: couldn't claim interface 0 on device %d!\n", dn[i]);
+ }
+ else
+ {
+ claimed++;
+ }
+ }
+ if (claimed != expected)
+ {
+ printf ("ERROR: expected %d claimed interfaces, got %d!\n", expected,
+ claimed);
+ return 0;
+ }
+ printf ("%d devices claimed...\n\n", claimed);
+
+ /* try to claim invalid device entry */
+ status = sanei_usb_claim_interface (device_number, 0);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: could claim interface 0 on invalid device!\n");
+ return 0;
+ }
+
+ /* create a mock device and make it missing by rescanning */
+ create_mock_device ("mock", &mock);
+ store_device (mock);
+ sanei_usb_scan_devices ();
+
+ /* try to claim interface on missing device */
+ status = sanei_usb_claim_interface (device_number - 1, 0);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: could claim interface 0 on invalid device!\n");
+ return 0;
+ }
+
+ /* remove mock device */
+ device_number--;
+ free (devices[device_number].devname);
+ devices[device_number].devname = NULL;
+
+ return 1;
+}
+
+
+/** release all claimed devices
+ * loop on all opened devices and claim interface 0
+ * @param dn array of opened device number
+ * @param expected number of devices to be claimed
+ * @return 1 on success, else 0
+ */
+static int
+test_release_all (SANE_Int * dn, int expected)
+{
+ int released = 0;
+ int i;
+ SANE_Status status;
+ device_list_type mock;
+
+ released = 0;
+ for (i = 0; i < expected; i++)
+ {
+ status =
+ sanei_usb_release_interface (dn[i], devices[dn[i]].interface_nr);
+ if (status != SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: couldn't release interface 0 on device %d!\n",
+ dn[i]);
+ }
+ else
+ {
+ released++;
+ }
+ }
+ if (released != expected)
+ {
+ printf ("ERROR: expected %d released interfaces, got %d!\n", expected,
+ released);
+ return 0;
+ }
+ printf ("%d devices released...\n\n", released);
+
+ /* try to release invalid device entry */
+ status = sanei_usb_release_interface (device_number, 0);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: could release interface 0 on invalid device!\n");
+ return 0;
+ }
+
+ /* create a mock device and make it missing by rescanning */
+ create_mock_device ("mock", &mock);
+ store_device (mock);
+ sanei_usb_scan_devices ();
+
+ /* try to claim interface on missing device */
+ status = sanei_usb_release_interface (device_number - 1, 0);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: could release interface 0 on invalid device!\n");
+ return 0;
+ }
+
+ /* remove mock device */
+ device_number--;
+ free (devices[device_number].devname);
+ devices[device_number].devname = NULL;
+
+ return 1;
+}
+
+/** get id for all devices names
+ * loop on all existing devices and get vendor
+ * and product id by name.
+ * @param expected count
+ * @return 1 on success, else 0
+ */
+static int
+test_vendor_by_devname (void)
+{
+ int i;
+ SANE_Status status;
+ SANE_Word vendor, product;
+ device_list_type mock;
+
+ /* loop on detected devices and open them */
+ for (i = 0; i < device_number; i++)
+ {
+ if (devices[i].missing == 0 && devices[i].devname != NULL)
+ {
+ /* get device id */
+ status = sanei_usb_get_vendor_product_byname (devices[i].devname,
+ &vendor, &product);
+ if (status != SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: couldn't query device %s!\n",
+ devices[i].devname);
+ return 0;
+ }
+ if (vendor == 0 || product == 0)
+ {
+ printf ("ERROR: incomplete device id for %s!\n",
+ devices[i].devname);
+ return 0;
+ }
+ printf ("%s is %04x:%04x\n", devices[i].devname, vendor, product);
+ }
+ }
+
+ /* add mock device */
+ create_mock_device ("mock", &mock);
+ store_device (mock);
+ status = sanei_usb_get_vendor_product_byname ("mock", &vendor, &product);
+ if (status != SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: getting vendor for mock devname!\n");
+ return 0;
+ }
+ if (vendor != mock.vendor || product != mock.product)
+ {
+ printf ("ERROR: wrong vendor/product for mock devname!\n");
+ return 0;
+ }
+ /* remove mock device */
+ device_number--;
+ free (devices[device_number].devname);
+ devices[device_number].devname = NULL;
+
+ /* try go get id for an invalid devname */
+ status = sanei_usb_get_vendor_product_byname ("invalid devname",
+ &vendor, &product);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: unexpected success getting id for invalid devname!\n");
+ return 0;
+ }
+
+ printf ("\n");
+ return 1;
+}
+
+/** get vendor for all devices id
+ * loop on all existing devices and get vendor
+ * and product id.
+ * @param expected count
+ * @return 1 on success, else 0
+ */
+static int
+test_vendor_by_id (void)
+{
+ int i;
+ SANE_Status status;
+ SANE_Word vendor, product;
+ device_list_type mock;
+
+ /* loop on detected devices and open them */
+ for (i = 0; i < device_number; i++)
+ {
+ if (devices[i].missing == 0 && devices[i].devname != NULL)
+ {
+ /* get device id */
+ status = sanei_usb_get_vendor_product (i, &vendor, &product);
+ if (status != SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: couldn't query device %d!\n", i);
+ return 0;
+ }
+ if (vendor == 0 || product == 0)
+ {
+ printf ("ERROR: incomplete device id for %d!\n", i);
+ return 0;
+ }
+ printf ("%d is %04x:%04x\n", i, vendor, product);
+ }
+ }
+
+ /* add mock device */
+ create_mock_device ("mock", &mock);
+ store_device (mock);
+ status =
+ sanei_usb_get_vendor_product (device_number - 1, &vendor, &product);
+ if (status != SANE_STATUS_GOOD)
+ {
+ printf ("ERROR: getting vendor for mock devname!\n");
+ return 0;
+ }
+ if (vendor != mock.vendor || product != mock.product)
+ {
+ printf ("ERROR: wrong vendor/product for mock devname!\n");
+ return 0;
+ }
+ /* remove mock device */
+ device_number--;
+ free (devices[device_number].devname);
+ devices[device_number].devname = NULL;
+
+ /* try go get id for an invalid id */
+ status =
+ sanei_usb_get_vendor_product (device_number + 1, &vendor, &product);
+ if (status == SANE_STATUS_GOOD)
+ {
+ printf
+ ("ERROR: unexpected success getting vendor for invalid devname!\n");
+ return 0;
+ }
+
+ printf ("\n");
+ return 1;
+}
+
+/** test timeout functions : libusb only
+ * @return 1 on success, else 0
+ */
+static int
+test_timeout (void)
+{
+#if defined(HAVE_LIBUSB) || defined(HAVE_LIBUSB_1_0)
+ int timeout = libusb_timeout;
+
+ sanei_usb_set_timeout (5000);
+ if (libusb_timeout != 5000)
+ {
+ printf ("ERROR: failed to set timeout\n");
+ return 1;
+ }
+ sanei_usb_set_timeout (timeout);
+#endif
+ return 1;
+}
+
+/** test device scanning
+ * call sanei_usb_scan_devices, since it has no return code, no real
+ * assert can be done, but at least we can test it doesn't break
+ * other functions or don't leak memory
+ * @return always 1
+ */
+static int
+test_scan_devices (int detected, int opened)
+{
+ int rc;
+
+ printf ("rescanning for devices ...\n");
+ sanei_usb_scan_devices ();
+ rc = count_detected (detected);
+ if (!rc)
+ {
+ printf ("ERROR: scanning devices change detected count!\n");
+ return 0;
+ }
+ rc = count_opened (opened);
+ if (!rc)
+ {
+ printf ("ERROR: scanning devices change opened count!\n");
+ return 0;
+ }
+ printf ("\n");
+ return 1;
+}
+
+
+/**
+ * flag for dummy attach
+ */
+static int dummy_flag;
+
+/**
+ * expected device name during attach
+ */
+static char *expected_device;
+
+/** dummy attach function
+ * dummy attach function
+ * @return resturn SANE_STATUS_GOOD
+ */
+static SANE_Status
+dummy_attach (const char *dev)
+{
+ dummy_flag = (strcmp (expected_device, dev) == 0);
+ if (dummy_flag)
+ {
+ printf ("success attaching to %s...\n", dev);
+ }
+ else
+ {
+ printf ("failed attaching to %s...\n", dev);
+ }
+ return SANE_STATUS_GOOD;
+}
+
+/** test attaching usb device
+ * create a mock device and attach to it, checking
+ * if it is ok
+ * @return 1 on success, else 0
+ */
+static int
+test_attach (void)
+{
+ device_list_type mock;
+
+ /* add mock device and try ot attach to it */
+ dummy_flag = 0;
+ create_mock_device ("mock", &mock);
+ expected_device = mock.devname;
+ store_device (mock);
+ sanei_usb_attach_matching_devices ("usb 0xdead 0xbeef", dummy_attach);
+
+ /* flag must be set */
+ if (dummy_flag != 1)
+ {
+ printf ("ERROR: couldn't attach to 'usb xdead 0xbeef' device!\n");
+ return 0;
+ }
+
+ /* attach by devname */
+ dummy_flag = 0;
+ sanei_usb_attach_matching_devices (mock.devname, dummy_attach);
+ /* flag must be set */
+ if (dummy_flag != 1)
+ {
+ printf ("ERROR: couldn't attach to 'mock' device!\n");
+ return 0;
+ }
+
+ /* attach to bogus device */
+ dummy_flag = 0;
+ sanei_usb_attach_matching_devices ("usb 0x0001 0x0001", dummy_attach);
+
+ /* flag must not be set */
+ if (dummy_flag != 0)
+ {
+ printf ("ERROR: shouldn't be attached to bogus device!\n");
+ return 0;
+ }
+
+ /* attach by bogus devname */
+ sanei_usb_attach_matching_devices ("bogus", dummy_attach);
+
+ /* flag must not be set */
+ if (dummy_flag != 0)
+ {
+ printf ("ERROR: shouldn't be attached to bogus device!\n");
+ return 0;
+ }
+
+ /* remove mock device */
+ device_number--;
+ free (devices[device_number].devname);
+ devices[device_number].devname = NULL;
+ dummy_flag = 0;
+
+ return 1;
+}
+
+int
+main (int argc, char **argv)
+{
+ int detected, opened, i;
+ SANE_Int dn[MAX_DEVICES];
+
+#ifdef HAVE_LIBUSB
+ printf ("\n%s built with old libusb\n\n", argv[0]);
+#endif
+#ifdef HAVE_LIBUSB_1_0
+ printf ("\n%s built with libusb-1.0\n\n", argv[0]);
+#endif
+#ifdef HAVE_USBCALLS
+ printf ("\n%s built with usbcalls\n\n", argv[0]);
+#endif
+#if !defined(HAVE_LIBUSB) && !defined(HAVE_LIBUSB_1_0) && !defined(HAVE_USBCALLS)
+ printf ("\n%s relying on deprecated scanner kernel module\n", argv[0]);
+#endif
+
+ /* start sanei_usb */
+ assert (test_init (1));
+
+ /* test timeout function */
+ assert (test_timeout ());
+
+ /* count available devices */
+ detected = 0;
+ for (i = 0; i < device_number; i++)
+ {
+ if (devices[i].missing == 0 && devices[i].devname != NULL)
+ {
+ detected++;
+ }
+ }
+ printf ("%d devices found.\n", detected);
+
+ /* rescan devices : detected count shouldn't change */
+ assert (test_scan_devices (detected, 0));
+
+ /* test corner cases with mock device */
+ assert (test_store_device ());
+
+ /* get vendor/product id for all available devices devname */
+ assert (test_vendor_by_devname ());
+
+ /* get vendor/product id for all available devices id */
+ assert (test_vendor_by_id ());
+
+ /* open all available devices */
+ assert (test_open_all (dn, detected));
+
+ opened = get_opened();
+
+ /* rescan devices : detected and opened count shouldn't change */
+ assert (test_scan_devices (detected, opened));
+
+ /* try to open an inexisting device */
+ assert (test_open_invalid ());
+
+ /* increase sanei _sub use count */
+ assert (test_init (2));
+
+ /* there should be still as many detected devices */
+ assert (count_detected (detected));
+
+ /* there should be still as many opened devices */
+ assert (count_opened (opened));
+
+ assert (test_exit (1));
+
+ /* there should be still as many opened devices */
+ assert (count_opened (opened));
+
+ /* count devices again , sanei_usb_exit() shouldn't have
+ * change the count */
+ assert (count_detected (detected));
+
+ /* claim all available devices */
+ assert (test_claim_all (dn, opened));
+
+ /* then release them all */
+ assert (test_release_all (dn, opened));
+
+ /* close all opened devices */
+ assert (test_close_all (dn, opened));
+
+ /* check there is no opened device */
+ assert (count_opened (0));
+
+ /* finally free resources */
+ assert (test_exit (0));
+
+ /* check there is no more devices */
+ assert (count_detected (0));
+
+ /* test attach matching device with a mock */
+ assert (test_attach ());
+
+ /* try to call sanei_usb_exit() when it not initialized */
+ assert (test_exit (0));
+
+ /* scan devices when sanei usb is not initialized */
+ assert (test_scan_devices (0, 0));
+
+ /* we re start use of sanei usb so we check we have left it
+ * it he correct state after "closing" it. */
+ printf ("\n============================================================\n");
+ printf ("restart use of sanei usb after having freed all resources...\n\n");
+ assert (test_init (1));
+
+ /* we should have the same initial count of detected devices */
+ assert (count_detected (detected));
+
+ /* finally free resources */
+ assert (test_exit (0));
+
+ /* all the tests are OK ! */
+ return 0;
+}
+
+/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-24 23:54:33 +0000