def test_main():
try:
dsp = ossaudiodev.open('w')
except (ossaudiodev.error, IOError), msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
test_support.run_unittest(__name__)
python类ENODEV的实例源码
def gettype(idx):
"""
returns the type of the device
:param idx: rfkill index
:returns: the type of the device
"""
fin = None
try:
fin = open(os.path.join(spath,"rfkill{0}".format(idx),'type'),'r')
return fin.read().strip()
except IOError:
raise pyric.error(errno.ENODEV,"No device at {0}".format(idx))
finally:
if fin: fin.close()
def __init__(self, path=None):
self.dev = None
self.lock = threading.Lock()
if path and not self.open(path):
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
def listen(self, target, timeout):
"""Listen for *timeout* seconds to become initialized as a
*target*. The *target* must be one of :class:`nfc.clf.TTA`,
:class:`nfc.clf.TTB`, :class:`nfc.clf.TTF`, or
:class:`nfc.clf.DEP` (note that target type support depends on
the hardware capabilities). The return value is :const:`None`
if *timeout* elapsed without activation or a tuple (target,
command) where target is the activated target (which may
differ from the requested target, see below) and command is
the first command received from the initiator.
If an activated target is returned, the target type and
attributes may differ from the *target* requested. This is
especically true if activation as a :class:`nfc.clf.DEP`
target is requested but the contactless frontend does not have
a hardware implementation of the data exchange protocol and
returns a :class:`nfc.clf.TTA` or :class:`nfc.clf.TTF` target
instead.
.. note:: This is a direct interface to the
driver and not needed if :meth:`connect` is used.
"""
if self.dev is None:
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
with self.lock:
log.debug("listen for {0:.3f} sec as target {1}"
.format(timeout, target))
if type(target) is TTA:
return self.dev.listen_tta(target, timeout)
if type(target) is TTB:
return self.dev.listen_ttb(target, timeout)
if type(target) is TTF:
return self.dev.listen_ttf(target, timeout)
if type(target) is DEP:
return self.dev.listen_dep(target, timeout)
def __init__(self, transport):
self.transport = transport
for speed in (230400, 9600, 19200, 38400, 57600, 115200):
log.debug("try serial baud rate {0} kbps".format(speed))
self.transport.tty = self.transport.serial.Serial(
self.transport.tty.port, baudrate=speed, timeout=0.1)
log.debug("read arygon firmware version")
self.transport.tty.write("0av")
version = self.transport.tty.readline()
if version.startswith("FF0000"):
log.debug("Arygon Reader {0}".format(version.strip()[-4:]))
self.transport.tty.timeout = 1.0
self.transport.tty.writeTimeout = 1.0
log.debug("set mcu-tama speed to 230.4 kbps")
self.transport.tty.write("0at05")
if self.transport.tty.readline().strip() != "FF000000":
log.debug("failed to set mcu-tama speed")
break
if self.transport.tty.baudrate != 230400:
log.debug("set mcu-host speed to 230.4 kbps")
self.transport.tty.write("0ah05")
if self.transport.tty.readline().strip() != "FF000000":
log.debug("failed to set mcu-host speed")
break
time.sleep(0.5)
self.transport.tty.close()
self.transport.tty = self.transport.serial.Serial(
self.transport.tty.port, baudrate=230400,
timeout=1.0, writeTimeout=1.0)
return super(Chipset, self).__init__(transport)
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
def test_main():
try:
dsp = ossaudiodev.open('w')
except (ossaudiodev.error, IOError) as msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
support.run_unittest(__name__)
def test_main():
try:
dsp = linuxaudiodev.open('w')
except linuxaudiodev.error, msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT, errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
run_unittest(LinuxAudioDevTests)
def test_main():
try:
dsp = ossaudiodev.open('w')
except (ossaudiodev.error, IOError), msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
test_support.run_unittest(__name__)
def test_main():
try:
dsp = ossaudiodev.open('w')
except (ossaudiodev.error, OSError) as msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
support.run_unittest(__name__)
def test_main():
try:
dsp = linuxaudiodev.open('w')
except linuxaudiodev.error, msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT, errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
run_unittest(LinuxAudioDevTests)
def test_main():
try:
dsp = ossaudiodev.open('w')
except (ossaudiodev.error, IOError), msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
test_support.run_unittest(__name__)
def open(self, filename, *args, **kwargs):
"""
Attempt an open, but if the file is /dev/net/tun and it does not exist,
translate the error into L{SkipTest} so that tests that require
platform support for tuntap devices are skipped instead of failed.
"""
try:
return super(TestRealSystem, self).open(filename, *args, **kwargs)
except OSError as e:
# The device file may simply be missing. The device file may also
# exist but be unsupported by the kernel.
if e.errno in (ENOENT, ENODEV) and filename == b"/dev/net/tun":
raise SkipTest("Platform lacks /dev/net/tun")
raise
def test_main():
try:
dsp = ossaudiodev.open('w')
except (ossaudiodev.error, OSError) as msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
dsp.close()
support.run_unittest(__name__)
def get_interface_ip(sock: socket.socket, ifname: str) -> str:
"""Obtain an IP address for a network interface, as a string."""
ifreq_tuple = (ifname.encode('utf-8')[:15], socket.AF_INET, b'\x00' * 14)
ifreq = struct.pack(b'16sH14s', *ifreq_tuple)
try:
info = fcntl.ioctl(sock, SIOCGIFADDR, ifreq)
except OSError as e:
if e.errno == errno.ENODEV:
raise InterfaceNotFound(
"Interface not found: '%s'." % ifname)
elif e.errno == errno.EADDRNOTAVAIL:
raise IPAddressNotAvailable(
"No IP address found on interface '%s'." % ifname)
else:
raise IPAddressNotAvailable(
"Failed to get IP address for '%s': %s." % (
ifname, strerror(e.errno)))
else:
# Parse the `struct ifreq` that comes back from the ioctl() call.
# 16x --> char ifr_name[IFNAMSIZ];
# ... next is a union of structures; we're interested in the
# `sockaddr_in` that is returned from this particular ioctl().
# 2x --> short sin_family;
# 2x --> unsigned short sin_port;
# 4s --> struct in_addr sin_addr;
# 8x --> char sin_zero[8];
addr, = struct.unpack(b'16x2x2x4s8x', info)
ip = socket.inet_ntoa(addr)
return ip
def init(transport):
transport.open(transport.port, 115200)
transport.tty.write("0av") # read version
response = transport.tty.readline()
if response.startswith("FF00000600V"):
log.debug("Arygon Reader AxxB Version %s", response[11:].strip())
transport.tty.timeout = 0.5
transport.tty.write("0at05")
if transport.tty.readline().startswith("FF0000"):
log.debug("MCU/TAMA communication set to 230400 bps")
transport.tty.write("0ah05")
if transport.tty.readline().startswith("FF0000"):
log.debug("MCU/HOST communication set to 230400 bps")
transport.tty.baudrate = 230400
transport.tty.timeout = 0.1
time.sleep(0.1)
chipset = ChipsetB(transport, logger=log)
device = DeviceB(chipset, logger=log)
device._vendor_name = "Arygon"
device._device_name = "ADRB"
return device
transport.open(transport.port, 9600)
transport.tty.write("0av") # read version
response = transport.tty.readline()
if response.startswith("FF00000600V"):
log.debug("Arygon Reader AxxA Version %s", response[11:].strip())
transport.tty.timeout = 0.5
transport.tty.write("0at05")
if transport.tty.readline().startswith("FF0000"):
log.debug("MCU/TAMA communication set to 230400 bps")
transport.tty.write("0ah05")
if transport.tty.readline().startswith("FF0000"):
log.debug("MCU/HOST communication set to 230400 bps")
transport.tty.baudrate = 230400
transport.tty.timeout = 0.1
time.sleep(0.1)
chipset = ChipsetA(transport, logger=log)
device = DeviceA(chipset, logger=log)
device._vendor_name = "Arygon"
device._device_name = "ADRA"
return device
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
def open(self, usb_bus, dev_adr):
self.usb_dev = None
self.usb_out = None
self.usb_inp = None
for dev in self.context.getDeviceList(skip_on_error=True):
if ((dev.getBusNumber() == usb_bus and
dev.getDeviceAddress() == dev_adr)):
break
else:
log.error("no device {0} on bus {1}".format(dev_adr, usb_bus))
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
try:
first_setting = dev.iterSettings().next()
except StopIteration:
log.error("no usb configuration settings, please replug device")
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
def transfer_type(x):
return x & libusb.TRANSFER_TYPE_MASK
def endpoint_dir(x):
return x & libusb.ENDPOINT_DIR_MASK
for endpoint in first_setting.iterEndpoints():
ep_addr = endpoint.getAddress()
ep_attr = endpoint.getAttributes()
if transfer_type(ep_attr) == libusb.TRANSFER_TYPE_BULK:
if endpoint_dir(ep_addr) == libusb.ENDPOINT_IN:
if not self.usb_inp:
self.usb_inp = endpoint
if endpoint_dir(ep_addr) == libusb.ENDPOINT_OUT:
if not self.usb_out:
self.usb_out = endpoint
if not (self.usb_inp and self.usb_out):
log.error("no bulk endpoints for read and write")
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
try:
# workaround the PN533's buggy USB implementation
self._manufacturer_name = dev.getManufacturer()
self._product_name = dev.getProduct()
except libusb.USBErrorIO:
self._manufacturer_name = None
self._product_name = None
try:
self.usb_dev = dev.open()
self.usb_dev.claimInterface(0)
except libusb.USBErrorAccess:
raise IOError(errno.EACCES, os.strerror(errno.EACCES))
except libusb.USBErrorBusy:
raise IOError(errno.EBUSY, os.strerror(errno.EBUSY))
except libusb.USBErrorNoDevice:
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
def play_sound_file(self, data, rate, ssize, nchannels):
try:
dsp = ossaudiodev.open('w')
except IOError as msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
# at least check that these methods can be invoked
dsp.bufsize()
dsp.obufcount()
dsp.obuffree()
dsp.getptr()
dsp.fileno()
# Make sure the read-only attributes work.
self.assertFalse(dsp.closed)
self.assertEqual(dsp.name, "/dev/dsp")
self.assertEqual(dsp.mode, "w", "bad dsp.mode: %r" % dsp.mode)
# And make sure they're really read-only.
for attr in ('closed', 'name', 'mode'):
try:
setattr(dsp, attr, 42)
except (TypeError, AttributeError):
pass
else:
self.fail("dsp.%s not read-only" % attr)
# Compute expected running time of sound sample (in seconds).
expected_time = float(len(data)) / (ssize/8) / nchannels / rate
# set parameters based on .au file headers
dsp.setparameters(AFMT_S16_NE, nchannels, rate)
self.assertTrue(abs(expected_time - 3.51) < 1e-2, expected_time)
t1 = time.time()
dsp.write(data)
dsp.close()
t2 = time.time()
elapsed_time = t2 - t1
percent_diff = (abs(elapsed_time - expected_time) / expected_time) * 100
self.assertTrue(percent_diff <= 10.0,
"elapsed time (%s) > 10%% off of expected time (%s)" %
(elapsed_time, expected_time))
def play_sound_file(self, data, rate, ssize, nchannels):
try:
dsp = ossaudiodev.open('w')
except IOError, msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
# at least check that these methods can be invoked
dsp.bufsize()
dsp.obufcount()
dsp.obuffree()
dsp.getptr()
dsp.fileno()
# Make sure the read-only attributes work.
self.assertFalse(dsp.closed)
self.assertEqual(dsp.name, "/dev/dsp")
self.assertEqual(dsp.mode, "w", "bad dsp.mode: %r" % dsp.mode)
# And make sure they're really read-only.
for attr in ('closed', 'name', 'mode'):
try:
setattr(dsp, attr, 42)
except TypeError:
pass
else:
self.fail("dsp.%s not read-only" % attr)
# Compute expected running time of sound sample (in seconds).
expected_time = float(len(data)) / (ssize//8) / nchannels / rate
# set parameters based on .au file headers
dsp.setparameters(AFMT_S16_NE, nchannels, rate)
self.assertTrue(abs(expected_time - 3.51) < 1e-2, expected_time)
t1 = time.time()
dsp.write(data)
dsp.close()
t2 = time.time()
elapsed_time = t2 - t1
percent_diff = (abs(elapsed_time - expected_time) / expected_time) * 100
self.assertTrue(percent_diff <= 10.0,
"elapsed time > 10% off of expected time")
def play_sound_file(self, data, rate, ssize, nchannels):
try:
dsp = ossaudiodev.open('w')
except IOError, msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
# at least check that these methods can be invoked
dsp.bufsize()
dsp.obufcount()
dsp.obuffree()
dsp.getptr()
dsp.fileno()
# Make sure the read-only attributes work.
self.assertFalse(dsp.closed)
self.assertEqual(dsp.name, "/dev/dsp")
self.assertEqual(dsp.mode, "w", "bad dsp.mode: %r" % dsp.mode)
# And make sure they're really read-only.
for attr in ('closed', 'name', 'mode'):
try:
setattr(dsp, attr, 42)
except TypeError:
pass
else:
self.fail("dsp.%s not read-only" % attr)
# Compute expected running time of sound sample (in seconds).
expected_time = float(len(data)) / (ssize//8) / nchannels / rate
# set parameters based on .au file headers
dsp.setparameters(AFMT_S16_NE, nchannels, rate)
self.assertTrue(abs(expected_time - 3.51) < 1e-2, expected_time)
t1 = time.time()
dsp.write(data)
dsp.close()
t2 = time.time()
elapsed_time = t2 - t1
percent_diff = (abs(elapsed_time - expected_time) / expected_time) * 100
self.assertTrue(percent_diff <= 10.0,
"elapsed time > 10% off of expected time")
def play_sound_file(self, data, rate, ssize, nchannels):
try:
dsp = ossaudiodev.open('w')
except IOError as msg:
if msg.args[0] in (errno.EACCES, errno.ENOENT,
errno.ENODEV, errno.EBUSY):
raise unittest.SkipTest(msg)
raise
# at least check that these methods can be invoked
dsp.bufsize()
dsp.obufcount()
dsp.obuffree()
dsp.getptr()
dsp.fileno()
# Make sure the read-only attributes work.
self.assertFalse(dsp.closed)
self.assertEqual(dsp.name, "/dev/dsp")
self.assertEqual(dsp.mode, "w", "bad dsp.mode: %r" % dsp.mode)
# And make sure they're really read-only.
for attr in ('closed', 'name', 'mode'):
try:
setattr(dsp, attr, 42)
except (TypeError, AttributeError):
pass
else:
self.fail("dsp.%s not read-only" % attr)
# Compute expected running time of sound sample (in seconds).
expected_time = float(len(data)) / (ssize/8) / nchannels / rate
# set parameters based on .au file headers
dsp.setparameters(AFMT_S16_NE, nchannels, rate)
self.assertTrue(abs(expected_time - 3.51) < 1e-2, expected_time)
t1 = time.time()
dsp.write(data)
dsp.close()
t2 = time.time()
elapsed_time = t2 - t1
percent_diff = (abs(elapsed_time - expected_time) / expected_time) * 100
self.assertTrue(percent_diff <= 10.0,
"elapsed time (%s) > 10%% off of expected time (%s)" %
(elapsed_time, expected_time))
