usb1.testUSB1: Do not allocate libusb transfers in tests.

From 1.0.25, calling libusb_free_transfer without having assigned it to
a device segfaults. This is not a supported call sequence, so hook into
{,de}allocation functions during affected test methods, and use this to
check their consistency.

Author: vpelletier

usb1/testUSB1.py

@@ -16,10 +16,13 @@
 
 # pylint: disable=invalid-name, missing-docstring, too-many-public-methods
 
-from ctypes import pointer
+from ctypes import pointer, sizeof
+import functools
+import gc
 import itertools
 import sys
 import unittest
+import weakref
 import usb1
 from . import libusb1
 
@@ -38,7 +41,50 @@ def open(self):
                 'usb1.USBContext() fails - no USB bus on system ?'
             )
 
+def checkTransferAllocCount(func):
+    @functools.wraps(func)
+    def wrapper(self, *args, **kw):
+        before = self.transfer_alloc_count
+        libusb_free_transfer = libusb1.libusb_free_transfer
+        libusb_alloc_transfer = libusb1.libusb_alloc_transfer
+        try:
+            libusb1.libusb_free_transfer = self._fakeFreeTransfer
+            libusb1.libusb_alloc_transfer = self._fakeAllocTransfer
+            print('running')
+            result = func(self, *args, **kw)
+            print('done')
+        finally:
+            libusb1.libusb_free_transfer = libusb_free_transfer
+            libusb1.libusb_alloc_transfer = libusb_alloc_transfer
+        gc.collect()
+        self.assertEqual(self.transfer_alloc_count, before)
+        return result
+    return wrapper
+
 class USBTransferTests(unittest.TestCase):
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        usb1.loadLibrary()
+        self.transfer_alloc_count = 0
+
+    def _fakeFreeTransfer(self, _):
+        self.transfer_alloc_count -= 1
+
+    def _fakeAllocTransfer(self, isochronous_count):
+        self.transfer_alloc_count += 1
+        buffer = bytearray(
+            sizeof(
+                libusb1.libusb_transfer,
+            ) + sizeof(
+                libusb1.libusb_iso_packet_descriptor,
+            ) * max(0, isochronous_count - 1),
+        )
+        transfer = libusb1.libusb_transfer.from_buffer(buffer)
+        # Keep a reference (in the finalizer itself) to the buffer for as long
+        # as transfer is alive.
+        weakref.finalize(transfer, lambda _: None, buffer)
+        return pointer(transfer)
+
     @staticmethod
     def getTransfer(iso_packets=0):
         # Dummy handle
@@ -66,6 +112,7 @@ def testHasCapability():
         """
         usb1.hasCapability(usb1.CAP_HAS_CAPABILITY)
 
+    @checkTransferAllocCount
     def testSetControl(self):
         """
         Simplest test: feed some data, must not raise.
@@ -129,20 +176,23 @@ def callback(transfer):
         # No callback
         setter(endpoint, buff)
 
+    @checkTransferAllocCount
     def testSetBulk(self):
         """
         Simplest test: feed some data, must not raise.
         Also, test setBuffer/getBuffer.
         """
         self._testTransferSetter(self.getTransfer(), 'setBulk')
 
+    @checkTransferAllocCount
     def testSetInterrupt(self):
         """
         Simplest test: feed some data, must not raise.
         Also, test setBuffer/getBuffer.
         """
         self._testTransferSetter(self.getTransfer(), 'setInterrupt')
 
+    @checkTransferAllocCount
     def testSetIsochronous(self):
         """
         Simplest test: feed some data, must not raise.
@@ -174,6 +224,7 @@ def testSetIsochronous(self):
             buff,
         )
 
+    @checkTransferAllocCount
     def testSetGetCallback(self):
         transfer = self.getTransfer()
         def callback(transfer):