text: from __future__ import division, print_function, absolute_import
  
  import os
  import sys
  import tempfile
  from io import BytesIO
  
  import numpy as np
  from numpy.testing import (assert_equal, assert_, assert_array_equal,
                             suppress_warnings)
  from pytest import raises as assert_raises, warns as assert_warns
  
  from scipy.io import wavfile
  
  
  def datafile(fn):
      return os.path.join(os.path.dirname(__file__), 'data', fn)
  
  
  def test_read_1():
      for mmap in [False, True]:
          rate, data = wavfile.read(datafile('test-44100Hz-le-1ch-4bytes.wav'),
                                    mmap=mmap)
  
          assert_equal(rate, 44100)
          assert_(np.issubdtype(data.dtype, np.int32))
          assert_equal(data.shape, (4410,))
  
          del data
  
  
  def test_read_2():
      for mmap in [False, True]:
          rate, data = wavfile.read(datafile('test-8000Hz-le-2ch-1byteu.wav'),
                                    mmap=mmap)
          assert_equal(rate, 8000)
          assert_(np.issubdtype(data.dtype, np.uint8))
          assert_equal(data.shape, (800, 2))
  
          del data
  
  def test_read_3():
      for mmap in [False, True]:
          rate, data = wavfile.read(datafile('test-44100Hz-2ch-32bit-float-le.wav'),
                                    mmap=mmap)
          assert_equal(rate, 44100)
          assert_(np.issubdtype(data.dtype, np.float32))
          assert_equal(data.shape, (441, 2))
  
          del data
  
  def test_read_4():
      for mmap in [False, True]:
          with suppress_warnings() as sup:
              sup.filter(wavfile.WavFileWarning,
                         "Chunk .non-data. not understood, skipping it")
              rate, data = wavfile.read(datafile('test-48000Hz-2ch-64bit-float-le-wavex.wav'),
                                        mmap=mmap)
  
          assert_equal(rate, 48000)
          assert_(np.issubdtype(data.dtype, np.float64))
          assert_equal(data.shape, (480, 2))
  
          del data
  
  
  def test_read_5():
      for mmap in [False, True]:
          rate, data = wavfile.read(datafile('test-44100Hz-2ch-32bit-float-be.wav'),
                                    mmap=mmap)
          assert_equal(rate, 44100)
          assert_(np.issubdtype(data.dtype, np.float32))
          assert_(data.dtype.byteorder == '>' or (sys.byteorder == 'big' and
                                                  data.dtype.byteorder == '='))
          assert_equal(data.shape, (441, 2))
  
          del data
  
  
  def test_read_fail():
      for mmap in [False, True]:
          fp = open(datafile('example_1.nc'), 'rb')
          assert_raises(ValueError, wavfile.read, fp, mmap=mmap)
          fp.close()
  
  
  def test_read_early_eof_with_data():
      for mmap in [False, True]:
          with open(datafile('test-44100Hz-le-1ch-4bytes-early-eof.wav'), 'rb') as fp:
              with assert_warns(wavfile.WavFileWarning, match='Reached EOF'):
                  rate, data = wavfile.read(fp, mmap=mmap)
                  assert_(data.size > 0)
                  assert_equal(rate, 44100)
  
          del data
  
  
  def test_read_early_eof():
      for mmap in [False, True]:
          with open(datafile('test-44100Hz-le-1ch-4bytes-early-eof-no-data.wav'), 'rb') as fp:
              with assert_raises(ValueError, match="Unexpected end of file."):
                  wavfile.read(fp, mmap=mmap)
  
  
  def test_read_incomplete_chunk():
      for mmap in [False, True]:
          fp = open(datafile('test-44100Hz-le-1ch-4bytes-incomplete-chunk.wav'), 'rb')
          assert_raises(ValueError, wavfile.read, fp, mmap=mmap)
          fp.close()
  
  
  def _check_roundtrip(realfile, rate, dtype, channels):
      if realfile:
          fd, tmpfile = tempfile.mkstemp(suffix='.wav')
          os.close(fd)
      else:
          tmpfile = BytesIO()
      try:
          data = np.random.rand(100, channels)
          if channels == 1:
              data = data[:,0]
          if dtype.kind == 'f':
              # The range of the float type should be in [-1, 1]
              data = data.astype(dtype)
          else:
              data = (data*128).astype(dtype)
  
          wavfile.write(tmpfile, rate, data)
  
          for mmap in [False, True]:
              rate2, data2 = wavfile.read(tmpfile, mmap=mmap)
  
              assert_equal(rate, rate2)
              assert_(data2.dtype.byteorder in ('<', '=', '|'), msg=data2.dtype)
              assert_array_equal(data, data2)
  
              del data2
      finally:
          if realfile:
              os.unlink(tmpfile)
  
  
  def test_write_roundtrip():
      for realfile in (False, True):
          for dtypechar in ('i', 'u', 'f', 'g', 'q'):
              for size in (1, 2, 4, 8):
                  if size == 1 and dtypechar == 'i':
                      # signed 8-bit integer PCM is not allowed
                      continue
                  if size > 1 and dtypechar == 'u':
                      # unsigned > 8-bit integer PCM is not allowed
                      continue
                  if (size == 1 or size == 2) and dtypechar == 'f':
                      # 8- or 16-bit float PCM is not expected
                      continue
                  if dtypechar in 'gq':
                      # no size allowed for these types
                      if size == 1:
                          size = ''
                      else:
                          continue
  
                  for endianness in ('>', '<'):
                      if size == 1 and endianness == '<':
                          continue
                      for rate in (8000, 32000):
                          for channels in (1, 2, 5):
                              dt = np.dtype('%s%s%s' % (endianness, dtypechar, size))
                              _check_roundtrip(realfile, rate, dt, channels)
  
  