text: from __future__ import division, absolute_import, print_function
  
  import pickle
  import sys
  import platform
  import gc
  import copy
  import warnings
  import tempfile
  from os import path
  from io import BytesIO
  
  import numpy as np
  from numpy.testing import (
          run_module_suite, TestCase, assert_, assert_equal,
          assert_almost_equal, assert_array_equal, assert_array_almost_equal,
          assert_raises, assert_warns, dec
          )
  from numpy.testing.utils import _assert_valid_refcount, WarningManager
  from numpy.compat import asbytes, asunicode, asbytes_nested, long, sixu
  
  rlevel = 1
  
  class TestRegression(TestCase):
      def test_invalid_round(self,level=rlevel):
          """Ticket #3"""
          v = 4.7599999999999998
          assert_array_equal(np.array([v]),np.array(v))
  
      def test_mem_empty(self,level=rlevel):
          """Ticket #7"""
          np.empty((1,),dtype=[('x',np.int64)])
  
      def test_pickle_transposed(self,level=rlevel):
          """Ticket #16"""
          a = np.transpose(np.array([[2,9],[7,0],[3,8]]))
          f = BytesIO()
          pickle.dump(a,f)
          f.seek(0)
          b = pickle.load(f)
          f.close()
          assert_array_equal(a,b)
  
      def test_typeNA(self,level=rlevel):
          """Ticket #31"""
          assert_equal(np.typeNA[np.int64],'Int64')
          assert_equal(np.typeNA[np.uint64],'UInt64')
  
      def test_dtype_names(self,level=rlevel):
          """Ticket #35"""
          dt = np.dtype([(('name','label'),np.int32,3)])
  
      def test_reduce(self,level=rlevel):
          """Ticket #40"""
          assert_almost_equal(np.add.reduce([1.,.5],dtype=None), 1.5)
  
      def test_zeros_order(self,level=rlevel):
          """Ticket #43"""
          np.zeros([3], int, 'C')
          np.zeros([3], order='C')
          np.zeros([3], int, order='C')
  
      def test_asarray_with_order(self,level=rlevel):
          """Check that nothing is done when order='F' and array C/F-contiguous"""
          a = np.ones(2)
          assert_(a is np.asarray(a, order='F'))
  
      def test_ravel_with_order(self,level=rlevel):
          """Check that ravel works when order='F' and array C/F-contiguous"""
          a = np.ones(2)
          assert_(not a.ravel('F').flags.owndata)
  
      def test_sort_bigendian(self,level=rlevel):
          """Ticket #47"""
          a = np.linspace(0, 10, 11)
          c = a.astype(np.dtype('<f8'))
          c.sort()
          assert_array_almost_equal(c, a)
  
      def test_negative_nd_indexing(self,level=rlevel):
          """Ticket #49"""
          c = np.arange(125).reshape((5,5,5))
          origidx = np.array([-1, 0, 1])
          idx = np.array(origidx)
          c[idx]
          assert_array_equal(idx, origidx)
  
      def test_char_dump(self,level=rlevel):
          """Ticket #50"""
          f = BytesIO()
          ca = np.char.array(np.arange(1000,1010),itemsize=4)
          ca.dump(f)
          f.seek(0)
          ca = np.load(f)
          f.close()
  
      def test_noncontiguous_fill(self,level=rlevel):
          """Ticket #58."""
          a = np.zeros((5,3))
          b = a[:,:2,]
          def rs():
              b.shape = (10,)
          self.assertRaises(AttributeError,rs)
  
      def test_bool(self,level=rlevel):
          """Ticket #60"""
          x = np.bool_(1)
  
      def test_indexing1(self,level=rlevel):
          """Ticket #64"""
          descr = [('x', [('y', [('z', 'c16', (2,)),]),]),]
          buffer = ((([6j,4j],),),)
          h = np.array(buffer, dtype=descr)
          h['x']['y']['z']
  
      def test_indexing2(self,level=rlevel):
          """Ticket #65"""
          descr = [('x', 'i4', (2,))]
          buffer = ([3,2],)
          h = np.array(buffer, dtype=descr)
          h['x']
  
      def test_round(self,level=rlevel):
          """Ticket #67"""
          x = np.array([1+2j])
          assert_almost_equal(x**(-1), [1/(1+2j)])
  
      def test_scalar_compare(self,level=rlevel):
          """Ticket #72"""
          a = np.array(['test', 'auto'])
          assert_array_equal(a == 'auto', np.array([False,True]))
          self.assertTrue(a[1] == 'auto')
          self.assertTrue(a[0] != 'auto')
          b = np.linspace(0, 10, 11)
          self.assertTrue(b != 'auto')
          self.assertTrue(b[0] != 'auto')
  
      def test_unicode_swapping(self,level=rlevel):
          """Ticket #79"""
          ulen = 1
          ucs_value = sixu('\U0010FFFF')
          ua = np.array([[[ucs_value*ulen]*2]*3]*4, dtype='U%s' % ulen)
          ua2 = ua.newbyteorder()
  
      def test_object_array_fill(self,level=rlevel):
          """Ticket #86"""
          x = np.zeros(1, 'O')
          x.fill([])
  
      def test_mem_dtype_align(self,level=rlevel):
          """Ticket #93"""
          self.assertRaises(TypeError,np.dtype,
                                {'names':['a'],'formats':['foo']},align=1)
  
      @dec.knownfailureif((sys.version_info[0] >= 3) or
                          (sys.platform == "win32" and platform.architecture()[0] == "64bit"),
                          "numpy.intp('0xff', 16) not supported on Py3, "
                          "as it does not inherit from Python int")
      def test_intp(self,level=rlevel):
          """Ticket #99"""
          i_width = np.int_(0).nbytes*2 - 1
          np.intp('0x' + 'f'*i_width,16)
          self.assertRaises(OverflowError,np.intp,'0x' + 'f'*(i_width+1),16)
          self.assertRaises(ValueError,np.intp,'0x1',32)
          assert_equal(255,np.intp('0xFF',16))
          assert_equal(1024,np.intp(1024))
  
      def test_endian_bool_indexing(self,level=rlevel):
          """Ticket #105"""
          a = np.arange(10.,dtype='>f8')
          b = np.arange(10.,dtype='<f8')
          xa = np.where((a>2) & (a<6))
          xb = np.where((b>2) & (b<6))
          ya = ((a>2) & (a<6))
          yb = ((b>2) & (b<6))
          assert_array_almost_equal(xa,ya.nonzero())
          assert_array_almost_equal(xb,yb.nonzero())
          assert_(np.all(a[ya] > 0.5))
          assert_(np.all(b[yb] > 0.5))
  
      def test_endian_where(self,level=rlevel):
          """GitHuB issue #369"""
          net = np.zeros(3, dtype='>f4')
          net[1] = 0.00458849
          net[2] = 0.605202
          max_net = net.max()
          test = np.where(net <= 0., max_net, net)
          correct = np.array([ 0.60520202,  0.00458849,  0.60520202])
          assert_array_almost_equal(test, correct)
  
      def test_endian_recarray(self,level=rlevel):
          """Ticket #2185"""
          dt = np.dtype([
                 ('head', '>u4'),
                 ('data', '>u4', 2),
              ])
          buf = np.recarray(1, dtype=dt)
          buf[0]['head'] = 1
          buf[0]['data'][:] = [1,1]
  
          h = buf[0]['head']
          d = buf[0]['data'][0]
          buf[0]['head'] = h
          buf[0]['data'][0] = d
          assert_(buf[0]['head'] == 1)
  
      def test_mem_dot(self,level=rlevel):
          """Ticket #106"""
          x = np.random.randn(0,1)
          y = np.random.randn(10,1)
          # Dummy array to detect bad memory access:
          _z = np.ones(10)
          _dummy = np.empty((0, 10))
          z = np.lib.stride_tricks.as_strided(_z, _dummy.shape, _dummy.strides)
          np.dot(x, np.transpose(y), out=z)
          assert_equal(_z, np.ones(10))
          # Do the same for the built-in dot:
          np.core.multiarray.dot(x, np.transpose(y), out=z)
          assert_equal(_z, np.ones(10))
  
      def test_arange_endian(self,level=rlevel):
          """Ticket #111"""
          ref = np.arange(10)
          x = np.arange(10,dtype='<f8')
          assert_array_equal(ref,x)
          x = np.arange(10,dtype='>f8')
          assert_array_equal(ref,x)
  
  #    Longfloat support is not consistent enough across
  #     platforms for this test to be meaningful.
  #    def test_longfloat_repr(self,level=rlevel):
  #        """Ticket #112"""
  #        if np.longfloat(0).itemsize > 8:
  #            a = np.exp(np.array([1000],dtype=np.longfloat))
  #            assert_(str(a)[1:9] == str(a[0])[:8])
  
      def test_argmax(self,level=rlevel):
          """Ticket #119"""
          a = np.random.normal(0,1,(4,5,6,7,8))
          for i in range(a.ndim):
              aargmax = a.argmax(i)
  
      def test_mem_divmod(self,level=rlevel):
          """Ticket #126"""
          for i in range(10):
              divmod(np.array([i])[0],10)
  
  
      def test_hstack_invalid_dims(self,level=rlevel):
          """Ticket #128"""
          x = np.arange(9).reshape((3,3))
          y = np.array([0,0,0])
          self.assertRaises(ValueError,np.hstack,(x,y))
  
      def test_squeeze_type(self,level=rlevel):
          """Ticket #133"""
          a = np.array([3])
          b = np.array(3)
          assert_(type(a.squeeze()) is np.ndarray)
          assert_(type(b.squeeze()) is np.ndarray)
  
      def test_add_identity(self,level=rlevel):
          """Ticket #143"""
          assert_equal(0,np.add.identity)
  
      def test_numpy_float_python_long_addition(self):
          # Check that numpy float and python longs can be added correctly.
          a = np.float_(23.) + 2**135
          assert_equal(a, 23. + 2**135)
  
      def test_binary_repr_0(self,level=rlevel):
          """Ticket #151"""
          assert_equal('0',np.binary_repr(0))
  
      def test_rec_iterate(self,level=rlevel):
          """Ticket #160"""
          descr = np.dtype([('i',int),('f',float),('s','|S3')])
          x = np.rec.array([(1,1.1,'1.0'),
                           (2,2.2,'2.0')],dtype=descr)
          x[0].tolist()
          [i for i in x[0]]
  
      def test_unicode_string_comparison(self,level=rlevel):
          """Ticket #190"""
          a = np.array('hello',np.unicode_)
          b = np.array('world')
          a == b
  
      def test_tostring_FORTRANORDER_discontiguous(self,level=rlevel):
          """Fix in r2836"""
          # Create discontiguous Fortran-ordered array
          x = np.array(np.random.rand(3,3),order='F')[:,:2]
          assert_array_almost_equal(x.ravel(),np.fromstring(x.tostring()))
  
      def test_flat_assignment(self,level=rlevel):
          """Correct behaviour of ticket #194"""
          x = np.empty((3,1))
          x.flat = np.arange(3)
          assert_array_almost_equal(x,[[0],[1],[2]])
          x.flat = np.arange(3,dtype=float)
          assert_array_almost_equal(x,[[0],[1],[2]])
  
      def test_broadcast_flat_assignment(self,level=rlevel):
          """Ticket #194"""
          x = np.empty((3,1))
          def bfa(): x[:] = np.arange(3)
          def bfb(): x[:] = np.arange(3,dtype=float)
          self.assertRaises(ValueError, bfa)
          self.assertRaises(ValueError, bfb)
  
      def test_nonarray_assignment(self):
          # See also Issue gh-2870, test for nonarray assignment
          # and equivalent unsafe casted array assignment
          a = np.arange(10)
          b = np.ones(10, dtype=bool)
          r = np.arange(10)
          def assign(a, b, c):
              a[b] = c
          assert_raises(ValueError, assign, a, b, np.nan)
          a[b] = np.array(np.nan) # but not this.
          assert_raises(ValueError, assign, a, r, np.nan)
          a[r] = np.array(np.nan)
  
      def test_unpickle_dtype_with_object(self,level=rlevel):
          """Implemented in r2840"""
          dt = np.dtype([('x',int),('y',np.object_),('z','O')])
          f = BytesIO()
          pickle.dump(dt,f)
          f.seek(0)
          dt_ = pickle.load(f)
          f.close()
          assert_equal(dt,dt_)
  
      def test_mem_array_creation_invalid_specification(self,level=rlevel):
          """Ticket #196"""
          dt = np.dtype([('x',int),('y',np.object_)])
          # Wrong way
          self.assertRaises(ValueError, np.array, [1,'object'], dt)
          # Correct way
          np.array([(1,'object')],dt)
  
      def test_recarray_single_element(self,level=rlevel):
          """Ticket #202"""
          a = np.array([1,2,3],dtype=np.int32)
          b = a.copy()
          r = np.rec.array(a,shape=1,formats=['3i4'],names=['d'])
          assert_array_equal(a,b)
          assert_equal(a,r[0][0])
  
      def test_zero_sized_array_indexing(self,level=rlevel):
          """Ticket #205"""
          tmp = np.array([])
          def index_tmp(): tmp[np.array(10)]
          self.assertRaises(IndexError, index_tmp)
  
      def test_chararray_rstrip(self,level=rlevel):
          """Ticket #222"""
          x = np.chararray((1,),5)
          x[0] = asbytes('a   ')
          x = x.rstrip()
          assert_equal(x[0], asbytes('a'))
  
      def test_object_array_shape(self,level=rlevel):
          """Ticket #239"""
          assert_equal(np.array([[1,2],3,4],dtype=object).shape, (3,))
          assert_equal(np.array([[1,2],[3,4]],dtype=object).shape, (2,2))
          assert_equal(np.array([(1,2),(3,4)],dtype=object).shape, (2,2))
          assert_equal(np.array([],dtype=object).shape, (0,))
          assert_equal(np.array([[],[],[]],dtype=object).shape, (3,0))
          assert_equal(np.array([[3,4],[5,6],None],dtype=object).shape, (3,))
  
      def test_mem_around(self,level=rlevel):
          """Ticket #243"""
          x = np.zeros((1,))
          y = [0]
          decimal = 6
          np.around(abs(x-y),decimal) <= 10.0**(-decimal)
  
      def test_character_array_strip(self,level=rlevel):
          """Ticket #246"""
          x = np.char.array(("x","x ","x  "))
          for c in x: assert_equal(c,"x")
  
      def test_lexsort(self,level=rlevel):
          """Lexsort memory error"""
          v = np.array([1,2,3,4,5,6,7,8,9,10])
          assert_equal(np.lexsort(v),0)
  
      def test_pickle_dtype(self,level=rlevel):
          """Ticket #251"""
          pickle.dumps(np.float)
  
      def test_swap_real(self, level=rlevel):
          """Ticket #265"""
          assert_equal(np.arange(4,dtype='>c8').imag.max(),0.0)
          assert_equal(np.arange(4,dtype='<c8').imag.max(),0.0)
          assert_equal(np.arange(4,dtype='>c8').real.max(),3.0)
          assert_equal(np.arange(4,dtype='<c8').real.max(),3.0)
  
      def test_object_array_from_list(self, level=rlevel):
          """Ticket #270"""
          a = np.array([1,'A',None])
  
      def test_multiple_assign(self, level=rlevel):
          """Ticket #273"""
          a = np.zeros((3,1),int)
          a[[1,2]] = 1
  
      def test_empty_array_type(self, level=rlevel):
          assert_equal(np.array([]).dtype, np.zeros(0).dtype)
  
      def test_void_copyswap(self, level=rlevel):
          dt = np.dtype([('one', '<i4'),('two', '<i4')])
          x = np.array((1,2), dtype=dt)
          x = x.byteswap()
          assert_(x['one'] > 1 and x['two'] > 2)
  
      def test_method_args(self, level=rlevel):
          # Make sure methods and functions have same default axis
          # keyword and arguments
          funcs1= ['argmax', 'argmin', 'sum', ('product', 'prod'),
                   ('sometrue', 'any'),
                   ('alltrue', 'all'), 'cumsum', ('cumproduct', 'cumprod'),
                   'ptp', 'cumprod', 'prod', 'std', 'var', 'mean',
                   'round', 'min', 'max', 'argsort', 'sort']
          funcs2 = ['compress', 'take', 'repeat']
  
          for func in funcs1:
              arr = np.random.rand(8,7)
              arr2 = arr.copy()
              if isinstance(func, tuple):
                  func_meth = func[1]
                  func = func[0]
              else:
                  func_meth = func
              res1 = getattr(arr, func_meth)()
              res2 = getattr(np, func)(arr2)
              if res1 is None:
                  assert_(abs(arr-res2).max() < 1e-8, func)
              else:
                  assert_(abs(res1-res2).max() < 1e-8, func)
  
          for func in funcs2:
              arr1 = np.random.rand(8,7)
              arr2 = np.random.rand(8,7)
              res1 = None
              if func == 'compress':
                  arr1 = arr1.ravel()
                  res1 = getattr(arr2, func)(arr1)
              else:
                  arr2 = (15*arr2).astype(int).ravel()
              if res1 is None:
                  res1 = getattr(arr1, func)(arr2)
              res2 = getattr(np, func)(arr1, arr2)
              assert_(abs(res1-res2).max() < 1e-8, func)
  
      def test_mem_lexsort_strings(self, level=rlevel):
          """Ticket #298"""
          lst = ['abc','cde','fgh']
          np.lexsort((lst,))
  
      def test_fancy_index(self, level=rlevel):
          """Ticket #302"""
          x = np.array([1,2])[np.array([0])]
          assert_equal(x.shape,(1,))
  
      def test_recarray_copy(self, level=rlevel):
          """Ticket #312"""
          dt = [('x',np.int16),('y',np.float64)]
          ra = np.array([(1,2.3)], dtype=dt)
          rb = np.rec.array(ra, dtype=dt)
          rb['x'] = 2.
          assert_(ra['x'] != rb['x'])
  
      def test_rec_fromarray(self, level=rlevel):
          """Ticket #322"""
          x1 = np.array([[1,2],[3,4],[5,6]])
          x2 = np.array(['a','dd','xyz'])
          x3 = np.array([1.1,2,3])
          np.rec.fromarrays([x1,x2,x3], formats="(2,)i4,a3,f8")
  
      def test_object_array_assign(self, level=rlevel):
          x = np.empty((2,2),object)
          x.flat[2] = (1,2,3)
          assert_equal(x.flat[2],(1,2,3))
  
      def test_ndmin_float64(self, level=rlevel):
          """Ticket #324"""
          x = np.array([1,2,3],dtype=np.float64)
          assert_equal(np.array(x,dtype=np.float32,ndmin=2).ndim,2)
          assert_equal(np.array(x,dtype=np.float64,ndmin=2).ndim,2)
  
      def test_ndmin_order(self, level=rlevel):
          """Issue #465 and related checks"""
          assert_(np.array([1,2], order='C', ndmin=3).flags.c_contiguous)
          assert_(np.array([1,2], order='F', ndmin=3).flags.f_contiguous)
          assert_(np.array(np.ones((2,2), order='F'), ndmin=3).flags.f_contiguous)
          assert_(np.array(np.ones((2,2), order='C'), ndmin=3).flags.c_contiguous)
  
      def test_mem_axis_minimization(self, level=rlevel):
          """Ticket #327"""
          data = np.arange(5)
          data = np.add.outer(data,data)
  
      def test_mem_float_imag(self, level=rlevel):
          """Ticket #330"""
          np.float64(1.0).imag
  
      def test_dtype_tuple(self, level=rlevel):
          """Ticket #334"""
          assert_(np.dtype('i4') == np.dtype(('i4',())))
  
      def test_dtype_posttuple(self, level=rlevel):
          """Ticket #335"""
          np.dtype([('col1', '()i4')])
  
      def test_numeric_carray_compare(self, level=rlevel):
          """Ticket #341"""
          assert_equal(np.array(['X'], 'c'), asbytes('X'))
  
      def test_string_array_size(self, level=rlevel):
          """Ticket #342"""
          self.assertRaises(ValueError,
                                np.array,[['X'],['X','X','X']],'|S1')
  
      def test_dtype_repr(self, level=rlevel):
          """Ticket #344"""
          dt1=np.dtype(('uint32', 2))
          dt2=np.dtype(('uint32', (2,)))
          assert_equal(dt1.__repr__(), dt2.__repr__())
  
      def test_reshape_order(self, level=rlevel):
          """Make sure reshape order works."""
          a = np.arange(6).reshape(2,3,order='F')
          assert_equal(a,[[0,2,4],[1,3,5]])
          a = np.array([[1,2],[3,4],[5,6],[7,8]])
          b = a[:,1]
          assert_equal(b.reshape(2,2,order='F'), [[2,6],[4,8]])
  
      def test_reshape_zero_strides(self, level=rlevel):
          """Issue #380, test reshaping of zero strided arrays"""
          a = np.ones(1)
          a = np.lib.stride_tricks.as_strided(a, shape=(5,), strides=(0,))
          assert_(a.reshape(5,1).strides[0] == 0)
  
      def test_reshape_zero_size(self, level=rlevel):
          """Github Issue #2700, setting shape failed for 0-sized arrays"""
          a = np.ones((0,2))
          a.shape = (-1,2)
  
      # Cannot test if NPY_RELAXED_STRIDES_CHECKING changes the strides.
      # With NPY_RELAXED_STRIDES_CHECKING the test becomes superfluous.
      @dec.skipif(np.ones(1).strides[0] == np.iinfo(np.intp).max)
      def test_reshape_trailing_ones_strides(self):
          # Github issue gh-2949, bad strides for trailing ones of new shape
          a = np.zeros(12, dtype=np.int32)[::2] # not contiguous
          strides_c = (16, 8, 8, 8)
          strides_f = (8, 24, 48, 48)
          assert_equal(a.reshape(3, 2, 1, 1).strides, strides_c)
          assert_equal(a.reshape(3, 2, 1, 1, order='F').strides, strides_f)
          assert_equal(np.array(0, dtype=np.int32).reshape(1,1).strides, (4,4))
  
      def test_repeat_discont(self, level=rlevel):
          """Ticket #352"""
          a = np.arange(12).reshape(4,3)[:,2]
          assert_equal(a.repeat(3), [2,2,2,5,5,5,8,8,8,11,11,11])
  
      def test_array_index(self, level=rlevel):
          """Make sure optimization is not called in this case."""
          a = np.array([1,2,3])
          a2 = np.array([[1,2,3]])
          assert_equal(a[np.where(a==3)], a2[np.where(a2==3)])
  
      def test_object_argmax(self, level=rlevel):
          a = np.array([1,2,3],dtype=object)
          assert_(a.argmax() == 2)
  
      def test_recarray_fields(self, level=rlevel):
          """Ticket #372"""
          dt0 = np.dtype([('f0','i4'),('f1','i4')])
          dt1 = np.dtype([('f0','i8'),('f1','i8')])
          for a in [np.array([(1,2),(3,4)],"i4,i4"),
                    np.rec.array([(1,2),(3,4)],"i4,i4"),
                    np.rec.array([(1,2),(3,4)]),
                    np.rec.fromarrays([(1,2),(3,4)],"i4,i4"),
                    np.rec.fromarrays([(1,2),(3,4)])]:
              assert_(a.dtype in [dt0,dt1])
  
      def test_random_shuffle(self, level=rlevel):
          """Ticket #374"""
          a = np.arange(5).reshape((5,1))
          b = a.copy()
          np.random.shuffle(b)
          assert_equal(np.sort(b, axis=0),a)
  
      def test_refcount_vdot(self, level=rlevel):
          """Changeset #3443"""
          _assert_valid_refcount(np.vdot)
  
      def test_startswith(self, level=rlevel):
          ca = np.char.array(['Hi','There'])
          assert_equal(ca.startswith('H'),[True,False])
  
      def test_noncommutative_reduce_accumulate(self, level=rlevel):
          """Ticket #413"""
          tosubtract = np.arange(5)
          todivide = np.array([2.0, 0.5, 0.25])
          assert_equal(np.subtract.reduce(tosubtract), -10)
          assert_equal(np.divide.reduce(todivide), 16.0)
          assert_array_equal(np.subtract.accumulate(tosubtract),
              np.array([0, -1, -3, -6, -10]))
          assert_array_equal(np.divide.accumulate(todivide),
              np.array([2., 4., 16.]))
  
      def test_convolve_empty(self, level=rlevel):
          """Convolve should raise an error for empty input array."""
          self.assertRaises(ValueError,np.convolve,[],[1])
          self.assertRaises(ValueError,np.convolve,[1],[])
  
      def test_multidim_byteswap(self, level=rlevel):
          """Ticket #449"""
          r=np.array([(1,(0,1,2))], dtype="i2,3i2")
          assert_array_equal(r.byteswap(),
                             np.array([(256,(0,256,512))],r.dtype))
  
      def test_string_NULL(self, level=rlevel):
          """Changeset 3557"""
          assert_equal(np.array("a\x00\x0b\x0c\x00").item(),
                       'a\x00\x0b\x0c')
  
      def test_junk_in_string_fields_of_recarray(self, level=rlevel):
          """Ticket #483"""
          r = np.array([[asbytes('abc')]], dtype=[('var1', '|S20')])
          assert_(asbytes(r['var1'][0][0]) == asbytes('abc'))
  
      def test_take_output(self, level=rlevel):
          """Ensure that 'take' honours output parameter."""
          x = np.arange(12).reshape((3,4))
          a = np.take(x,[0,2],axis=1)
          b = np.zeros_like(a)
          np.take(x,[0,2],axis=1,out=b)
          assert_array_equal(a,b)
  
      def test_take_object_fail(self):
          # Issue gh-3001
          d = 123.
          a = np.array([d, 1], dtype=object)
          ref_d = sys.getrefcount(d)
          try:
              a.take([0, 100])
          except IndexError:
              pass
          assert_(ref_d == sys.getrefcount(d))
  
      def test_array_str_64bit(self, level=rlevel):
          """Ticket #501"""
          s = np.array([1, np.nan],dtype=np.float64)
          errstate = np.seterr(all='raise')
          try:
              sstr = np.array_str(s)
          finally:
              np.seterr(**errstate)
  
      def test_frompyfunc_endian(self, level=rlevel):
          """Ticket #503"""
          from math import radians
          uradians = np.frompyfunc(radians, 1, 1)
          big_endian = np.array([83.4, 83.5], dtype='>f8')
          little_endian = np.array([83.4, 83.5], dtype='<f8')
          assert_almost_equal(uradians(big_endian).astype(float),
                              uradians(little_endian).astype(float))
  
      def test_mem_string_arr(self, level=rlevel):
          """Ticket #514"""
          s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
          t = []
          np.hstack((t, s ))
  
      def test_arr_transpose(self, level=rlevel):
          """Ticket #516"""
          x = np.random.rand(*(2,)*16)
          y = x.transpose(list(range(16)))
  
      def test_string_mergesort(self, level=rlevel):
          """Ticket #540"""
          x = np.array(['a']*32)
          assert_array_equal(x.argsort(kind='m'), np.arange(32))
  
      def test_argmax_byteorder(self, level=rlevel):
          """Ticket #546"""
          a = np.arange(3, dtype='>f')
          assert_(a[a.argmax()] == a.max())
  
      def test_rand_seed(self, level=rlevel):
          """Ticket #555"""
          for l in np.arange(4):
              np.random.seed(l)
  
      def test_mem_deallocation_leak(self, level=rlevel):
          """Ticket #562"""
          a = np.zeros(5,dtype=float)
          b = np.array(a,dtype=float)
          del a, b
  
      def test_mem_on_invalid_dtype(self):
          "Ticket #583"
          self.assertRaises(ValueError, np.fromiter, [['12',''],['13','']], str)
  
      def test_dot_negative_stride(self, level=rlevel):
          """Ticket #588"""
          x = np.array([[1,5,25,125.,625]])
          y = np.array([[20.],[160.],[640.],[1280.],[1024.]])
          z = y[::-1].copy()
          y2 = y[::-1]
          assert_equal(np.dot(x,z),np.dot(x,y2))
  
      def test_object_casting(self, level=rlevel):
          # This used to trigger the object-type version of
          # the bitwise_or operation, because float64 -> object
          # casting succeeds
          def rs():
              x = np.ones([484,286])
              y = np.zeros([484,286])
              x |= y
          self.assertRaises(TypeError,rs)
  
      def test_unicode_scalar(self, level=rlevel):
          """Ticket #600"""
          x = np.array(["DROND", "DROND1"], dtype="U6")
          el = x[1]
          new = pickle.loads(pickle.dumps(el))
          assert_equal(new, el)
  
      def test_arange_non_native_dtype(self, level=rlevel):
          """Ticket #616"""
          for T in ('>f4','<f4'):
              dt = np.dtype(T)
              assert_equal(np.arange(0,dtype=dt).dtype,dt)
              assert_equal(np.arange(0.5,dtype=dt).dtype,dt)
              assert_equal(np.arange(5,dtype=dt).dtype,dt)
  
      def test_bool_indexing_invalid_nr_elements(self, level=rlevel):
          s = np.ones(10,dtype=float)
          x = np.array((15,),dtype=float)
          def ia(x,s,v): x[(s>0)]=v
          self.assertRaises(ValueError,ia,x,s,np.zeros(9,dtype=float))
          self.assertRaises(ValueError,ia,x,s,np.zeros(11,dtype=float))
  
      def test_mem_scalar_indexing(self, level=rlevel):
          """Ticket #603"""
          x = np.array([0],dtype=float)
          index = np.array(0,dtype=np.int32)
          x[index]
  
      def test_binary_repr_0_width(self, level=rlevel):
          assert_equal(np.binary_repr(0,width=3),'000')
  
      def test_fromstring(self, level=rlevel):
          assert_equal(np.fromstring("12:09:09", dtype=int, sep=":"),
                       [12,9,9])
  
      def test_searchsorted_variable_length(self, level=rlevel):
          x = np.array(['a','aa','b'])
          y = np.array(['d','e'])
          assert_equal(x.searchsorted(y), [3,3])
  
      def test_string_argsort_with_zeros(self, level=rlevel):
          """Check argsort for strings containing zeros."""
          x = np.fromstring("\x00\x02\x00\x01", dtype="|S2")
          assert_array_equal(x.argsort(kind='m'), np.array([1,0]))
          assert_array_equal(x.argsort(kind='q'), np.array([1,0]))
  
      def test_string_sort_with_zeros(self, level=rlevel):
          """Check sort for strings containing zeros."""
          x = np.fromstring("\x00\x02\x00\x01", dtype="|S2")
          y = np.fromstring("\x00\x01\x00\x02", dtype="|S2")
          assert_array_equal(np.sort(x, kind="q"), y)
  
      def test_copy_detection_zero_dim(self, level=rlevel):
          """Ticket #658"""
          np.indices((0,3,4)).T.reshape(-1,3)
  
      def test_flat_byteorder(self, level=rlevel):
          """Ticket #657"""
          x = np.arange(10)
          assert_array_equal(x.astype('>i4'),x.astype('<i4').flat[:])
          assert_array_equal(x.astype('>i4').flat[:],x.astype('<i4'))
  
      def test_uint64_from_negative(self, level=rlevel) :
          assert_equal(np.uint64(-2), np.uint64(18446744073709551614))
  
      def test_sign_bit(self, level=rlevel):
          x = np.array([0,-0.0,0])
          assert_equal(str(np.abs(x)),'[ 0.  0.  0.]')
  
      def test_flat_index_byteswap(self, level=rlevel):
          for dt in (np.dtype('<i4'),np.dtype('>i4')):
              x = np.array([-1,0,1],dtype=dt)
              assert_equal(x.flat[0].dtype, x[0].dtype)
  
      def test_copy_detection_corner_case(self, level=rlevel):
          """Ticket #658"""
          np.indices((0,3,4)).T.reshape(-1,3)
  
      # Cannot test if NPY_RELAXED_STRIDES_CHECKING changes the strides.
      # With NPY_RELAXED_STRIDES_CHECKING the test becomes superfluous,
      # 0-sized reshape itself is tested elsewhere.
      @dec.skipif(np.ones(1).strides[0] == np.iinfo(np.intp).max)
      def test_copy_detection_corner_case2(self, level=rlevel):
          """Ticket #771: strides are not set correctly when reshaping 0-sized
          arrays"""
          b = np.indices((0,3,4)).T.reshape(-1,3)
          assert_equal(b.strides, (3 * b.itemsize, b.itemsize))
  
      def test_object_array_refcounting(self, level=rlevel):
          """Ticket #633"""
          if not hasattr(sys, 'getrefcount'):
              return
  
          # NB. this is probably CPython-specific
  
          cnt = sys.getrefcount
  
          a = object()
          b = object()
          c = object()
  
          cnt0_a = cnt(a)
          cnt0_b = cnt(b)
          cnt0_c = cnt(c)
  
          # -- 0d -> 1d broadcasted slice assignment
  
          arr = np.zeros(5, dtype=np.object_)
  
          arr[:] = a
          assert_equal(cnt(a), cnt0_a + 5)
  
          arr[:] = b
          assert_equal(cnt(a), cnt0_a)
          assert_equal(cnt(b), cnt0_b + 5)
  
          arr[:2] = c
          assert_equal(cnt(b), cnt0_b + 3)
          assert_equal(cnt(c), cnt0_c + 2)
  
          del arr
  
          # -- 1d -> 2d broadcasted slice assignment
  
          arr  = np.zeros((5, 2), dtype=np.object_)
          arr0 = np.zeros(2, dtype=np.object_)
  
          arr0[0] = a
          assert_(cnt(a) == cnt0_a + 1)
          arr0[1] = b
          assert_(cnt(b) == cnt0_b + 1)
  
          arr[:,:] = arr0
          assert_(cnt(a) == cnt0_a + 6)
          assert_(cnt(b) == cnt0_b + 6)
  
          arr[:,0] = None
          assert_(cnt(a) == cnt0_a + 1)
  
          del arr, arr0
  
          # -- 2d copying + flattening
  
          arr  = np.zeros((5, 2), dtype=np.object_)
  
          arr[:,0] = a
          arr[:,1] = b
          assert_(cnt(a) == cnt0_a + 5)
          assert_(cnt(b) == cnt0_b + 5)
  
          arr2 = arr.copy()
          assert_(cnt(a) == cnt0_a + 10)
          assert_(cnt(b) == cnt0_b + 10)
  
          arr2 = arr[:,0].copy()
          assert_(cnt(a) == cnt0_a + 10)
          assert_(cnt(b) == cnt0_b + 5)
  
          arr2 = arr.flatten()
          assert_(cnt(a) == cnt0_a + 10)
          assert_(cnt(b) == cnt0_b + 10)
  
          del arr, arr2
  
          # -- concatenate, repeat, take, choose
  
          arr1 = np.zeros((5, 1), dtype=np.object_)
          arr2 = np.zeros((5, 1), dtype=np.object_)
  
          arr1[...] = a
          arr2[...] = b
          assert_(cnt(a) == cnt0_a + 5)
          assert_(cnt(b) == cnt0_b + 5)
  
          arr3 = np.concatenate((arr1, arr2))
          assert_(cnt(a) == cnt0_a + 5 + 5)
          assert_(cnt(b) == cnt0_b + 5 + 5)
  
          arr3 = arr1.repeat(3, axis=0)
          assert_(cnt(a) == cnt0_a + 5 + 3*5)
  
          arr3 = arr1.take([1,2,3], axis=0)
          assert_(cnt(a) == cnt0_a + 5 + 3)
  
          x = np.array([[0],[1],[0],[1],[1]], int)
          arr3 = x.choose(arr1, arr2)
          assert_(cnt(a) == cnt0_a + 5 + 2)
          assert_(cnt(b) == cnt0_b + 5 + 3)
  
      def test_mem_custom_float_to_array(self, level=rlevel):
          """Ticket 702"""
          class MyFloat(object):
              def __float__(self):
                  return 1.0
  
          tmp = np.atleast_1d([MyFloat()])
          tmp2 = tmp.astype(float)
  
      def test_object_array_refcount_self_assign(self, level=rlevel):
          """Ticket #711"""
          class VictimObject(object):
              deleted = False
              def __del__(self):
                  self.deleted = True
          d = VictimObject()
          arr = np.zeros(5, dtype=np.object_)
          arr[:] = d
          del d
          arr[:] = arr # refcount of 'd' might hit zero here
          assert_(not arr[0].deleted)
          arr[:] = arr # trying to induce a segfault by doing it again...
          assert_(not arr[0].deleted)
  
      def test_mem_fromiter_invalid_dtype_string(self, level=rlevel):
          x = [1,2,3]
          self.assertRaises(ValueError,
                                np.fromiter, [xi for xi in x], dtype='S')
  
      def test_reduce_big_object_array(self, level=rlevel):
          """Ticket #713"""
          oldsize = np.setbufsize(10*16)
          a = np.array([None]*161, object)
          assert_(not np.any(a))
          np.setbufsize(oldsize)
  
      def test_mem_0d_array_index(self, level=rlevel):
          """Ticket #714"""
          np.zeros(10)[np.array(0)]
  
      def test_floats_from_string(self, level=rlevel):
          """Ticket #640, floats from string"""
          fsingle = np.single('1.234')
          fdouble = np.double('1.234')
          flongdouble = np.longdouble('1.234')
          assert_almost_equal(fsingle, 1.234)
          assert_almost_equal(fdouble, 1.234)
          assert_almost_equal(flongdouble, 1.234)
  
      def test_nonnative_endian_fill(self, level=rlevel):
          """ Non-native endian arrays were incorrectly filled with scalars before
          r5034.
          """
          if sys.byteorder == 'little':
              dtype = np.dtype('>i4')
          else:
              dtype = np.dtype('<i4')
          x = np.empty([1], dtype=dtype)
          x.fill(1)
          assert_equal(x, np.array([1], dtype=dtype))
  
      def test_dot_alignment_sse2(self, level=rlevel):
          """Test for ticket #551, changeset r5140"""
          x = np.zeros((30,40))
          y = pickle.loads(pickle.dumps(x))
          # y is now typically not aligned on a 8-byte boundary
          z = np.ones((1, y.shape[0]))
          # This shouldn't cause a segmentation fault:
          np.dot(z, y)
  
      def test_astype_copy(self, level=rlevel):
          """Ticket #788, changeset r5155"""
          # The test data file was generated by scipy.io.savemat.
          # The dtype is float64, but the isbuiltin attribute is 0.
          data_dir = path.join(path.dirname(__file__), 'data')
          filename = path.join(data_dir, "astype_copy.pkl")
          if sys.version_info[0] >= 3:
              f = open(filename, 'rb')
              xp = pickle.load(f, encoding='latin1')
              f.close()
          else:
              f = open(filename)
              xp = pickle.load(f)
              f.close()
          xpd = xp.astype(np.float64)
          assert_((xp.__array_interface__['data'][0] !=
                  xpd.__array_interface__['data'][0]))
  
      def test_compress_small_type(self, level=rlevel):
          """Ticket #789, changeset 5217.
          """
          # compress with out argument segfaulted if cannot cast safely
          import numpy as np
          a = np.array([[1, 2], [3, 4]])
          b = np.zeros((2, 1), dtype = np.single)
          try:
              a.compress([True, False], axis = 1, out = b)
              raise AssertionError("compress with an out which cannot be " \
                                   "safely casted should not return "\
                                   "successfully")
          except TypeError:
              pass
  
      def test_attributes(self, level=rlevel):
          """Ticket #791
          """
          class TestArray(np.ndarray):
              def __new__(cls, data, info):
                  result = np.array(data)
                  result = result.view(cls)
                  result.info = info
                  return result
              def __array_finalize__(self, obj):
                  self.info = getattr(obj, 'info', '')
          dat = TestArray([[1,2,3,4],[5,6,7,8]],'jubba')
          assert_(dat.info == 'jubba')
          dat.resize((4,2))
          assert_(dat.info == 'jubba')
          dat.sort()
          assert_(dat.info == 'jubba')
          dat.fill(2)
          assert_(dat.info == 'jubba')
          dat.put([2,3,4],[6,3,4])
          assert_(dat.info == 'jubba')
          dat.setfield(4, np.int32,0)
          assert_(dat.info == 'jubba')
          dat.setflags()
          assert_(dat.info == 'jubba')
          assert_(dat.all(1).info == 'jubba')
          assert_(dat.any(1).info == 'jubba')
          assert_(dat.argmax(1).info == 'jubba')
          assert_(dat.argmin(1).info == 'jubba')
          assert_(dat.argsort(1).info == 'jubba')
          assert_(dat.astype(TestArray).info == 'jubba')
          assert_(dat.byteswap().info == 'jubba')
          assert_(dat.clip(2,7).info == 'jubba')
          assert_(dat.compress([0,1,1]).info == 'jubba')
          assert_(dat.conj().info == 'jubba')
          assert_(dat.conjugate().info == 'jubba')
          assert_(dat.copy().info == 'jubba')
          dat2 = TestArray([2, 3, 1, 0],'jubba')
          choices = [[0, 1, 2, 3], [10, 11, 12, 13],
                     [20, 21, 22, 23], [30, 31, 32, 33]]
          assert_(dat2.choose(choices).info == 'jubba')
          assert_(dat.cumprod(1).info == 'jubba')
          assert_(dat.cumsum(1).info == 'jubba')
          assert_(dat.diagonal().info == 'jubba')
          assert_(dat.flatten().info == 'jubba')
          assert_(dat.getfield(np.int32,0).info == 'jubba')
          assert_(dat.imag.info == 'jubba')
          assert_(dat.max(1).info == 'jubba')
          assert_(dat.mean(1).info == 'jubba')
          assert_(dat.min(1).info == 'jubba')
          assert_(dat.newbyteorder().info == 'jubba')
          assert_(dat.nonzero()[0].info == 'jubba')
          assert_(dat.nonzero()[1].info == 'jubba')
          assert_(dat.prod(1).info == 'jubba')
          assert_(dat.ptp(1).info == 'jubba')
          assert_(dat.ravel().info == 'jubba')
          assert_(dat.real.info == 'jubba')
          assert_(dat.repeat(2).info == 'jubba')
          assert_(dat.reshape((2,4)).info == 'jubba')
          assert_(dat.round().info == 'jubba')
          assert_(dat.squeeze().info == 'jubba')
          assert_(dat.std(1).info == 'jubba')
          assert_(dat.sum(1).info == 'jubba')
          assert_(dat.swapaxes(0,1).info == 'jubba')
          assert_(dat.take([2,3,5]).info == 'jubba')
          assert_(dat.transpose().info == 'jubba')
          assert_(dat.T.info == 'jubba')
          assert_(dat.var(1).info == 'jubba')
          assert_(dat.view(TestArray).info == 'jubba')
  
      def test_recarray_tolist(self, level=rlevel):
          """Ticket #793, changeset r5215
          """
          # Comparisons fail for NaN, so we can't use random memory
          # for the test.
          buf = np.zeros(40, dtype=np.int8)
          a = np.recarray(2, formats="i4,f8,f8", names="id,x,y", buf=buf)
          b = a.tolist()
          assert_( a[0].tolist() == b[0])
          assert_( a[1].tolist() == b[1])
  
      def test_nonscalar_item_method(self):
          # Make sure that .item() fails graciously when it should
          a = np.arange(5)
          assert_raises(ValueError, a.item)
  
      def test_char_array_creation(self, level=rlevel):
          a = np.array('123', dtype='c')
          b = np.array(asbytes_nested(['1','2','3']))
          assert_equal(a,b)
  
      def test_unaligned_unicode_access(self, level=rlevel) :
          """Ticket #825"""
          for i in range(1,9) :
              msg = 'unicode offset: %d chars'%i
              t = np.dtype([('a','S%d'%i),('b','U2')])
              x = np.array([(asbytes('a'),sixu('b'))], dtype=t)
              if sys.version_info[0] >= 3:
                  assert_equal(str(x), "[(b'a', 'b')]", err_msg=msg)
              else:
                  assert_equal(str(x), "[('a', u'b')]", err_msg=msg)
  
      def test_sign_for_complex_nan(self, level=rlevel):
          """Ticket 794."""
          olderr = np.seterr(invalid='ignore')
          try:
              C = np.array([-np.inf, -2+1j, 0, 2-1j, np.inf, np.nan])
              have = np.sign(C)
              want = np.array([-1+0j, -1+0j, 0+0j, 1+0j, 1+0j, np.nan])
              assert_equal(have, want)
          finally:
              np.seterr(**olderr)
  
      def test_for_equal_names(self, level=rlevel):
          """Ticket #674"""
          dt = np.dtype([('foo', float), ('bar', float)])
          a = np.zeros(10, dt)
          b = list(a.dtype.names)
          b[0] = "notfoo"
          a.dtype.names = b
          assert_(a.dtype.names[0] == "notfoo")
          assert_(a.dtype.names[1] == "bar")
  
      def test_for_object_scalar_creation(self, level=rlevel):
          """Ticket #816"""
          a = np.object_()
          b = np.object_(3)
          b2 = np.object_(3.0)
          c = np.object_([4,5])
          d = np.object_([None, {}, []])
          assert_(a is None)
          assert_(type(b) is int)
          assert_(type(b2) is float)
          assert_(type(c) is np.ndarray)
          assert_(c.dtype == object)
          assert_(d.dtype == object)
  
      def test_array_resize_method_system_error(self):
          """Ticket #840 - order should be an invalid keyword."""
          x = np.array([[0,1],[2,3]])
          self.assertRaises(TypeError, x.resize, (2,2), order='C')
  
      def test_for_zero_length_in_choose(self, level=rlevel):
          "Ticket #882"
          a = np.array(1)
          self.assertRaises(ValueError, lambda x: x.choose([]), a)
  
      def test_array_ndmin_overflow(self):
          "Ticket #947."
          self.assertRaises(ValueError, lambda: np.array([1], ndmin=33))
  
      def test_errobj_reference_leak(self, level=rlevel):
          """Ticket #955"""
          old_err = np.seterr(all="ignore")
          try:
              z = int(0)
              p = np.int32(-1)
  
              gc.collect()
              n_before = len(gc.get_objects())
              z**p  # this shouldn't leak a reference to errobj
              gc.collect()
              n_after = len(gc.get_objects())
              assert_(n_before >= n_after, (n_before, n_after))
          finally:
              np.seterr(**old_err)
  
      def test_void_scalar_with_titles(self, level=rlevel):
          """No ticket"""
          data = [('john', 4), ('mary', 5)]
          dtype1 = [(('source:yy', 'name'), 'O'), (('source:xx', 'id'), int)]
          arr = np.array(data, dtype=dtype1)
          assert_(arr[0][0] == 'john')
          assert_(arr[0][1] == 4)
  
      def test_void_scalar_constructor(self):
          #Issue #1550
  
          #Create test string data, construct void scalar from data and assert
          #that void scalar contains original data.
          test_string = np.array("test")
          test_string_void_scalar = np.core.multiarray.scalar(
              np.dtype(("V",test_string.dtype.itemsize)), test_string.tostring())
  
          assert_(test_string_void_scalar.view(test_string.dtype) == test_string)
  
          #Create record scalar, construct from data and assert that
          #reconstructed scalar is correct.
          test_record = np.ones((), "i,i")
          test_record_void_scalar = np.core.multiarray.scalar(
              test_record.dtype, test_record.tostring())
  
          assert_(test_record_void_scalar == test_record)
  
          #Test pickle and unpickle of void and record scalars
          assert_(pickle.loads(pickle.dumps(test_string)) == test_string)
          assert_(pickle.loads(pickle.dumps(test_record)) == test_record)
  
      def test_blasdot_uninitialized_memory(self):
          """Ticket #950"""
          for m in [0, 1, 2]:
              for n in [0, 1, 2]:
                  for k in range(3):
                      # Try to ensure that x->data contains non-zero floats
                      x = np.array([123456789e199], dtype=np.float64)
                      x.resize((m, 0))
                      y = np.array([123456789e199], dtype=np.float64)
                      y.resize((0, n))
  
                      # `dot` should just return zero (m,n) matrix
                      z = np.dot(x, y)
                      assert_(np.all(z == 0))
                      assert_(z.shape == (m, n))
  
      def test_zeros(self):
          """Regression test for #1061."""
          # Set a size which cannot fit into a 64 bits signed integer
          sz = 2 ** 64
          good = 'Maximum allowed dimension exceeded'
          try:
              np.empty(sz)
          except ValueError as e:
              if not str(e) == good:
                  self.fail("Got msg '%s', expected '%s'" % (e, good))
          except Exception as e:
              self.fail("Got exception of type %s instead of ValueError" % type(e))
  
      def test_huge_arange(self):
          """Regression test for #1062."""
          # Set a size which cannot fit into a 64 bits signed integer
          sz = 2 ** 64
          good = 'Maximum allowed size exceeded'
          try:
              a = np.arange(sz)
              self.assertTrue(np.size == sz)
          except ValueError as e:
              if not str(e) == good:
                  self.fail("Got msg '%s', expected '%s'" % (e, good))
          except Exception as e:
              self.fail("Got exception of type %s instead of ValueError" % type(e))
  
      def test_fromiter_bytes(self):
          """Ticket #1058"""
          a = np.fromiter(list(range(10)), dtype='b')
          b = np.fromiter(list(range(10)), dtype='B')
          assert_(np.alltrue(a == np.array([0,1,2,3,4,5,6,7,8,9])))
          assert_(np.alltrue(b == np.array([0,1,2,3,4,5,6,7,8,9])))
  
      def test_array_from_sequence_scalar_array(self):
          """Ticket #1078: segfaults when creating an array with a sequence of 0d
          arrays."""
          a = np.array((np.ones(2), np.array(2)))
          assert_equal(a.shape, (2,))
          assert_equal(a.dtype, np.dtype(object))
          assert_equal(a[0], np.ones(2))
          assert_equal(a[1], np.array(2))
  
          a = np.array(((1,), np.array(1)))
          assert_equal(a.shape, (2,))
          assert_equal(a.dtype, np.dtype(object))
          assert_equal(a[0], (1,))
          assert_equal(a[1], np.array(1))
  
      def test_array_from_sequence_scalar_array2(self):
          """Ticket #1081: weird array with strange input..."""
          t = np.array([np.array([]), np.array(0, object)])
          assert_equal(t.shape, (2,))
          assert_equal(t.dtype, np.dtype(object))
  
      def test_array_too_big(self):
          """Ticket #1080."""
          assert_raises(ValueError, np.zeros, [975]*7, np.int8)
          assert_raises(ValueError, np.zeros, [26244]*5, np.int8)
  
      def test_dtype_keyerrors_(self):
          """Ticket #1106."""
          dt = np.dtype([('f1', np.uint)])
          assert_raises(KeyError, dt.__getitem__, "f2")
          assert_raises(IndexError, dt.__getitem__, 1)
          assert_raises(ValueError, dt.__getitem__, 0.0)
  
      def test_lexsort_buffer_length(self):
          """Ticket #1217, don't segfault."""
          a = np.ones(100, dtype=np.int8)
          b = np.ones(100, dtype=np.int32)
          i = np.lexsort((a[::-1], b))
          assert_equal(i, np.arange(100, dtype=np.int))
  
      def test_object_array_to_fixed_string(self):
          """Ticket #1235."""
          a = np.array(['abcdefgh', 'ijklmnop'], dtype=np.object_)
          b = np.array(a, dtype=(np.str_, 8))
          assert_equal(a, b)
          c = np.array(a, dtype=(np.str_, 5))
          assert_equal(c, np.array(['abcde', 'ijklm']))
          d = np.array(a, dtype=(np.str_, 12))
          assert_equal(a, d)
          e = np.empty((2, ), dtype=(np.str_, 8))
          e[:] = a[:]
          assert_equal(a, e)
  
      def test_unicode_to_string_cast(self):
          """Ticket #1240."""
          a = np.array(
                  [   [sixu('abc'), sixu('\u03a3')],
                      [sixu('asdf'), sixu('erw')]
                  ], dtype='U')
          def fail():
              b = np.array(a, 'S4')
          self.assertRaises(UnicodeEncodeError, fail)
  
      def test_mixed_string_unicode_array_creation(self):
          a = np.array(['1234', sixu('123')])
          assert_(a.itemsize == 16)
          a = np.array([sixu('123'), '1234'])
          assert_(a.itemsize == 16)
          a = np.array(['1234', sixu('123'), '12345'])
          assert_(a.itemsize == 20)
          a = np.array([sixu('123'), '1234', sixu('12345')])
          assert_(a.itemsize == 20)
          a = np.array([sixu('123'), '1234', sixu('1234')])
          assert_(a.itemsize == 16)
  
      def test_misaligned_objects_segfault(self):
          """Ticket #1198 and #1267"""
          a1 = np.zeros((10,), dtype='O,c')
          a2 = np.array(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'], 'S10')
          a1['f0'] = a2
          r = repr(a1)
          np.argmax(a1['f0'])
          a1['f0'][1] = "FOO"
          a1['f0'] = "FOO"
          a3 = np.array(a1['f0'], dtype='S')
          np.nonzero(a1['f0'])
          a1.sort()
          a4 = copy.deepcopy(a1)
  
      def test_misaligned_scalars_segfault(self):
          """Ticket #1267"""
          s1 = np.array(('a', 'Foo'), dtype='c,O')
          s2 = np.array(('b', 'Bar'), dtype='c,O')
          s1['f1'] = s2['f1']
          s1['f1'] = 'Baz'
  
      def test_misaligned_dot_product_objects(self):
          """Ticket #1267"""
          # This didn't require a fix, but it's worth testing anyway, because
          # it may fail if .dot stops enforcing the arrays to be BEHAVED
          a = np.array([[(1, 'a'), (0, 'a')], [(0, 'a'), (1, 'a')]], dtype='O,c')
          b = np.array([[(4, 'a'), (1, 'a')], [(2, 'a'), (2, 'a')]], dtype='O,c')
          np.dot(a['f0'], b['f0'])
  
      def test_byteswap_complex_scalar(self):
          """Ticket #1259 and gh-441"""
          for dtype in [np.dtype('<'+t) for t in np.typecodes['Complex']]:
              z = np.array([2.2-1.1j], dtype)
              x = z[0] # always native-endian
              y = x.byteswap()
              if x.dtype.byteorder == z.dtype.byteorder:
                  # little-endian machine
                  assert_equal(x, np.fromstring(y.tostring(), dtype=dtype.newbyteorder()))
              else:
                  # big-endian machine
                  assert_equal(x, np.fromstring(y.tostring(), dtype=dtype))
              # double check real and imaginary parts:
              assert_equal(x.real, y.real.byteswap())
              assert_equal(x.imag, y.imag.byteswap())
  
      def test_structured_arrays_with_objects1(self):
          """Ticket #1299"""
          stra = 'aaaa'
          strb = 'bbbb'
          x = np.array([[(0,stra),(1,strb)]], 'i8,O')
          x[x.nonzero()] = x.ravel()[:1]
          assert_(x[0,1] == x[0,0])
  
      def test_structured_arrays_with_objects2(self):
          """Ticket #1299 second test"""
          stra = 'aaaa'
          strb = 'bbbb'
          numb = sys.getrefcount(strb)
          numa = sys.getrefcount(stra)
          x = np.array([[(0,stra),(1,strb)]], 'i8,O')
          x[x.nonzero()] = x.ravel()[:1]
          assert_(sys.getrefcount(strb) == numb)
          assert_(sys.getrefcount(stra) == numa + 2)
  
      def test_duplicate_title_and_name(self):
          """Ticket #1254"""
          def func():
              x = np.dtype([(('a', 'a'), 'i'), ('b', 'i')])
          self.assertRaises(ValueError, func)
  
      def test_signed_integer_division_overflow(self):
          """Ticket #1317."""
          def test_type(t):
              min = np.array([np.iinfo(t).min])
              min //= -1
  
          old_err = np.seterr(divide="ignore")
          try:
              for t in (np.int8, np.int16, np.int32, np.int64, np.int, np.long):
                  test_type(t)
          finally:
              np.seterr(**old_err)
  
      def test_buffer_hashlib(self):
          try:
              from hashlib import md5
          except ImportError:
              from md5 import new as md5
  
          x = np.array([1,2,3], dtype=np.dtype('<i4'))
          assert_equal(md5(x).hexdigest(), '2a1dd1e1e59d0a384c26951e316cd7e6')
  
      def test_numeric_handleError(self):
          """Ticket #1405"""
          from numpy import numarray
          # Just make sure this doesn't throw an exception
          numarray.handleError(0, "")
  
      def test_0d_string_scalar(self):
          # Bug #1436; the following should succeed
          np.asarray('x', '>c')
  
      def test_log1p_compiler_shenanigans(self):
          # Check if log1p is behaving on 32 bit intel systems.
          assert_(np.isfinite(np.log1p(np.exp2(-53))))
  
      def test_fromiter_comparison(self, level=rlevel):
          a = np.fromiter(list(range(10)), dtype='b')
          b = np.fromiter(list(range(10)), dtype='B')
          assert_(np.alltrue(a == np.array([0,1,2,3,4,5,6,7,8,9])))
          assert_(np.alltrue(b == np.array([0,1,2,3,4,5,6,7,8,9])))
  
      def test_fromstring_crash(self):
          # Ticket #1345: the following should not cause a crash
          np.fromstring(asbytes('aa, aa, 1.0'), sep=',')
  
      def test_ticket_1539(self):
          dtypes = [x for x in np.typeDict.values()
                    if (issubclass(x, np.number)
                        and not issubclass(x, np.timedelta64))]
          a = np.array([], dtypes[0])
          failures = []
          for x in dtypes:
              b = a.astype(x)
              for y in dtypes:
                  c = a.astype(y)
                  try:
                      np.dot(b, c)
                  except TypeError as e:
                      failures.append((x, y))
          if failures:
              raise AssertionError("Failures: %r" % failures)
  
      def test_ticket_1538(self):
          x = np.finfo(np.float32)
          for name in 'eps epsneg max min resolution tiny'.split():
              assert_equal(type(getattr(x, name)), np.float32,
                           err_msg=name)
  
      def test_ticket_1434(self):
          # Check that the out= argument in var and std has an effect
          data = np.array(((1,2,3),(4,5,6),(7,8,9)))
          out = np.zeros((3,))
  
          ret = data.var(axis=1, out=out)
          assert_(ret is out)
          assert_array_equal(ret, data.var(axis=1))
  
          ret = data.std(axis=1, out=out)
          assert_(ret is out)
          assert_array_equal(ret, data.std(axis=1))
  
      def test_complex_nan_maximum(self):
          cnan = complex(0, np.nan)
          assert_equal(np.maximum(1, cnan), cnan)
  
      def test_subclass_int_tuple_assignment(self):
          # ticket #1563
          class Subclass(np.ndarray):
              def __new__(cls,i):
                  return np.ones((i,)).view(cls)
          x = Subclass(5)
          x[(0,)] = 2 # shouldn't raise an exception
          assert_equal(x[0], 2)
  
      def test_ufunc_no_unnecessary_views(self):
          # ticket #1548
          class Subclass(np.ndarray):
              pass
          x = np.array([1,2,3]).view(Subclass)
          y = np.add(x, x, x)
          assert_equal(id(x), id(y))
  
      def test_take_refcount(self):
          # ticket #939
          a = np.arange(16, dtype=np.float)
          a.shape = (4,4)
          lut = np.ones((5 + 3, 4), np.float)
          rgba = np.empty(shape=a.shape + (4,), dtype=lut.dtype)
          c1 = sys.getrefcount(rgba)
          try:
              lut.take(a, axis=0, mode='clip', out=rgba)
          except TypeError:
              pass
          c2 = sys.getrefcount(rgba)
          assert_equal(c1, c2)
  
      def test_fromfile_tofile_seeks(self):
          # On Python 3, tofile/fromfile used to get (#1610) the Python
          # file handle out of sync
          f0 = tempfile.NamedTemporaryFile()
          f = f0.file
          f.write(np.arange(255, dtype='u1').tostring())
  
          f.seek(20)
          ret = np.fromfile(f, count=4, dtype='u1')
          assert_equal(ret, np.array([20, 21, 22, 23], dtype='u1'))
          assert_equal(f.tell(), 24)
  
          f.seek(40)
          np.array([1, 2, 3], dtype='u1').tofile(f)
          assert_equal(f.tell(), 43)
  
          f.seek(40)
          data = f.read(3)
          assert_equal(data, asbytes("\x01\x02\x03"))
  
          f.seek(80)
          f.read(4)
          data = np.fromfile(f, dtype='u1', count=4)
          assert_equal(data, np.array([84, 85, 86, 87], dtype='u1'))
  
          f.close()
  
      def test_complex_scalar_warning(self):
          for tp in [np.csingle, np.cdouble, np.clongdouble]:
              x = tp(1+2j)
              assert_warns(np.ComplexWarning, float, x)
              warn_ctx = WarningManager()
              warn_ctx.__enter__()
              try:
                  warnings.simplefilter('ignore')
                  assert_equal(float(x), float(x.real))
              finally:
                  warn_ctx.__exit__()
  
      def test_complex_scalar_complex_cast(self):
          for tp in [np.csingle, np.cdouble, np.clongdouble]:
              x = tp(1+2j)
              assert_equal(complex(x), 1+2j)
  
      def test_complex_boolean_cast(self):
          """Ticket #2218"""
          for tp in [np.csingle, np.cdouble, np.clongdouble]:
              x = np.array([0, 0+0.5j, 0.5+0j], dtype=tp)
              assert_equal(x.astype(bool), np.array([0, 1, 1], dtype=bool))
              assert_(np.any(x))
              assert_(np.all(x[1:]))
  
      def test_uint_int_conversion(self):
          x = 2**64 - 1
          assert_equal(int(np.uint64(x)), x)
  
      def test_duplicate_field_names_assign(self):
          ra = np.fromiter(((i*3, i*2) for i in range(10)), dtype='i8,f8')
          ra.dtype.names = ('f1', 'f2')
          rep = repr(ra) # should not cause a segmentation fault
          assert_raises(ValueError, setattr, ra.dtype, 'names', ('f1', 'f1'))
  
      def test_eq_string_and_object_array(self):
          # From e-mail thread "__eq__ with str and object" (Keith Goodman)
          a1 = np.array(['a', 'b'], dtype=object)
          a2 = np.array(['a', 'c'])
          assert_array_equal(a1 == a2, [True, False])
          assert_array_equal(a2 == a1, [True, False])
  
      def test_nonzero_byteswap(self):
          a = np.array([0x80000000, 0x00000080, 0], dtype=np.uint32)
          a.dtype = np.float32
          assert_equal(a.nonzero()[0], [1])
          a = a.byteswap().newbyteorder()
          assert_equal(a.nonzero()[0], [1]) # [0] if nonzero() ignores swap
  
      def test_find_common_type_boolean(self):
          # Ticket #1695
          assert_(np.find_common_type([],['?','?']) == '?')
  
      def test_empty_mul(self):
          a = np.array([1.])
          a[1:1] *= 2
          assert_equal(a, [1.])
  
      def test_array_side_effect(self):
          assert_equal(np.dtype('S10').itemsize, 10)
  
          A = np.array([['abc', 2], ['long   ', '0123456789']], dtype=np.string_)
  
          # This was throwing an exception because in ctors.c,
          # discover_itemsize was calling PyObject_Length without checking
          # the return code.  This failed to get the length of the number 2,
          # and the exception hung around until something checked
          # PyErr_Occurred() and returned an error.
          assert_equal(np.dtype('S10').itemsize, 10)
  
      def test_any_float(self):
          # all and any for floats
          a = np.array([0.1, 0.9])
          assert_(np.any(a))
          assert_(np.all(a))
  
      def test_large_float_sum(self):
          a = np.arange(10000, dtype='f')
          assert_equal(a.sum(dtype='d'), a.astype('d').sum())
  
      def test_ufunc_casting_out(self):
          a = np.array(1.0, dtype=np.float32)
          b = np.array(1.0, dtype=np.float64)
          c = np.array(1.0, dtype=np.float32)
          np.add(a, b, out=c)
          assert_equal(c, 2.0)
  
      def test_array_scalar_contiguous(self):
          # Array scalars are both C and Fortran contiguous
          assert_(np.array(1.0).flags.c_contiguous)
          assert_(np.array(1.0).flags.f_contiguous)
          assert_(np.array(np.float32(1.0)).flags.c_contiguous)
          assert_(np.array(np.float32(1.0)).flags.f_contiguous)
  
      def test_squeeze_contiguous(self):
          """Similar to GitHub issue #387"""
          a = np.zeros((1,2)).squeeze()
          b = np.zeros((2,2,2), order='F')[:,:,::2].squeeze()
          assert_(a.flags.c_contiguous)
          assert_(a.flags.f_contiguous)
          assert_(b.flags.f_contiguous)
  
      def test_reduce_contiguous(self):
          """GitHub issue #387"""
          a = np.add.reduce(np.zeros((2,1,2)), (0,1))
          b = np.add.reduce(np.zeros((2,1,2)), 1)
          assert_(a.flags.c_contiguous)
          assert_(a.flags.f_contiguous)
          assert_(b.flags.c_contiguous)
  
      def test_object_array_self_reference(self):
          # Object arrays with references to themselves can cause problems
          a = np.array(0, dtype=object)
          a[()] = a
          assert_raises(TypeError, int, a)
          assert_raises(TypeError, long, a)
          assert_raises(TypeError, float, a)
          assert_raises(TypeError, oct, a)
          assert_raises(TypeError, hex, a)
  
          # This was causing a to become like the above
          a = np.array(0, dtype=object)
          a[...] += 1
          assert_equal(a, 1)
  
      def test_zerosize_accumulate(self):
          "Ticket #1733"
          x = np.array([[42, 0]], dtype=np.uint32)
          assert_equal(np.add.accumulate(x[:-1,0]), [])
  
      def test_objectarray_setfield(self):
          # Setfield directly manipulates the raw array data,
          # so is invalid for object arrays.
          x = np.array([1,2,3], dtype=object)
          assert_raises(RuntimeError, x.setfield, 4, np.int32, 0)
  
      def test_setting_rank0_string(self):
          "Ticket #1736"
          s1 = asbytes("hello1")
          s2 = asbytes("hello2")
          a = np.zeros((), dtype="S10")
          a[()] = s1
          assert_equal(a, np.array(s1))
          a[()] = np.array(s2)
          assert_equal(a, np.array(s2))
  
          a = np.zeros((), dtype='f4')
          a[()] = 3
          assert_equal(a, np.array(3))
          a[()] = np.array(4)
          assert_equal(a, np.array(4))
  
      def test_string_astype(self):
          "Ticket #1748"
          s1 = asbytes('black')
          s2 = asbytes('white')
          s3 = asbytes('other')
          a = np.array([[s1],[s2],[s3]])
          assert_equal(a.dtype, np.dtype('S5'))
          b = a.astype(np.dtype('S0'))
          assert_equal(b.dtype, np.dtype('S5'))
  
      def test_ticket_1756(self):
          """Ticket #1756 """
          s = asbytes('0123456789abcdef')
          a = np.array([s]*5)
          for i in range(1,17):
              a1 = np.array(a, "|S%d"%i)
              a2 = np.array([s[:i]]*5)
              assert_equal(a1, a2)
  
      def test_fields_strides(self):
          "Ticket #1760"
          r=np.fromstring('abcdefghijklmnop'*4*3, dtype='i4,(2,3)u2')
          assert_equal(r[0:3:2]['f1'], r['f1'][0:3:2])
          assert_equal(r[0:3:2]['f1'][0], r[0:3:2][0]['f1'])
          assert_equal(r[0:3:2]['f1'][0][()], r[0:3:2][0]['f1'][()])
          assert_equal(r[0:3:2]['f1'][0].strides, r[0:3:2][0]['f1'].strides)
  
      def test_alignment_update(self):
          """Check that alignment flag is updated on stride setting"""
          a = np.arange(10)
          assert_(a.flags.aligned)
          a.strides = 3
          assert_(not a.flags.aligned)
  
      def test_ticket_1770(self):
          "Should not segfault on python 3k"
          import numpy as np
          try:
              a = np.zeros((1,), dtype=[('f1', 'f')])
              a['f1'] = 1
              a['f2'] = 1
          except ValueError:
              pass
          except:
              raise AssertionError
  
      def test_ticket_1608(self):
          "x.flat shouldn't modify data"
          x = np.array([[1,2],[3,4]]).T
          y = np.array(x.flat)
          assert_equal(x, [[1,3],[2,4]])
  
      def test_pickle_string_overwrite(self):
          import re
  
          data = np.array([1], dtype='b')
          blob = pickle.dumps(data, protocol=1)
          data = pickle.loads(blob)
  
          # Check that loads does not clobber interned strings
          s = re.sub("a(.)", "\x01\\1", "a_")
          assert_equal(s[0], "\x01")
          data[0] = 0xbb
          s = re.sub("a(.)", "\x01\\1", "a_")
          assert_equal(s[0], "\x01")
  
      def test_pickle_bytes_overwrite(self):
          if sys.version_info[0] >= 3:
              data = np.array([1], dtype='b')
              data = pickle.loads(pickle.dumps(data))
              data[0] = 0xdd
              bytestring = "\x01  ".encode('ascii')
              assert_equal(bytestring[0:1], '\x01'.encode('ascii'))
  
      def test_structured_type_to_object(self):
          a_rec = np.array([(0,1), (3,2)], dtype='i4,i8')
          a_obj = np.empty((2,), dtype=object)
          a_obj[0] = (0,1)
          a_obj[1] = (3,2)
          # astype records -> object
          assert_equal(a_rec.astype(object), a_obj)
          # '=' records -> object
          b = np.empty_like(a_obj)
          b[...] = a_rec
          assert_equal(b, a_obj)
          # '=' object -> records
          b = np.empty_like(a_rec)
          b[...] = a_obj
          assert_equal(b, a_rec)
  
      def test_assign_obj_listoflists(self):
          # Ticket # 1870
          # The inner list should get assigned to the object elements
          a = np.zeros(4, dtype=object)
          b = a.copy()
          a[0] = [1]
          a[1] = [2]
          a[2] = [3]
          a[3] = [4]
          b[...] = [[1], [2], [3], [4]]
          assert_equal(a, b)
          # The first dimension should get broadcast
          a = np.zeros((2,2), dtype=object)
          a[...] = [[1,2]]
          assert_equal(a, [[1,2], [1,2]])
  
      def test_memoryleak(self):
          # Ticket #1917 - ensure that array data doesn't leak
          for i in range(1000):
              # 100MB times 1000 would give 100GB of memory usage if it leaks
              a = np.empty((100000000,), dtype='i1')
              del a
  
      def test_ufunc_reduce_memoryleak(self):
          a = np.arange(6)
          acnt = sys.getrefcount(a)
          res = np.add.reduce(a)
          assert_equal(sys.getrefcount(a), acnt)
  
      def test_search_sorted_invalid_arguments(self):
          # Ticket #2021, should not segfault.
          x = np.arange(0, 4, dtype='datetime64[D]')
          assert_raises(TypeError, x.searchsorted, 1)
  
      def test_string_truncation(self):
          # Ticket #1990 - Data can be truncated in creation of an array from a
          # mixed sequence of numeric values and strings
          for val in [True, 1234, 123.4, complex(1, 234)]:
              for tostr in [asunicode, asbytes]:
                  b = np.array([val, tostr('xx')])
                  assert_equal(tostr(b[0]), tostr(val))
                  b = np.array([tostr('xx'), val])
                  assert_equal(tostr(b[1]), tostr(val))
  
                  # test also with longer strings
                  b = np.array([val, tostr('xxxxxxxxxx')])
                  assert_equal(tostr(b[0]), tostr(val))
                  b = np.array([tostr('xxxxxxxxxx'), val])
                  assert_equal(tostr(b[1]), tostr(val))
  
      def test_string_truncation_ucs2(self):
          # Ticket #2081. Python compiled with two byte unicode
          # can lead to truncation if itemsize is not properly
          # adjusted for Numpy's four byte unicode.
          if sys.version_info[0] >= 3:
              a = np.array(['abcd'])
          else:
              a = np.array([sixu('abcd')])
          assert_equal(a.dtype.itemsize, 16)
  
      def test_unique_stable(self):
          # Ticket #2063 must always choose stable sort for argsort to
          # get consistent results
          v = np.array(([0]*5 + [1]*6 + [2]*6)*4)
          res = np.unique(v, return_index=True)
          tgt = (np.array([0, 1, 2]), np.array([ 0,  5, 11]))
          assert_equal(res, tgt)
  
      def test_unicode_alloc_dealloc_match(self):
          # Ticket #1578, the mismatch only showed up when running
          # python-debug for python versions >= 2.7, and then as
          # a core dump and error message.
          a = np.array(['abc'], dtype=np.unicode)[0]
          del a
  
      def test_refcount_error_in_clip(self):
          # Ticket #1588
          a = np.zeros((2,), dtype='>i2').clip(min=0)
          x = a + a
          # This used to segfault:
          y = str(x)
          # Check the final string:
          assert_(y == "[0 0]")
  
      def test_searchsorted_wrong_dtype(self):
          # Ticket #2189, it used to segfault, so we check that it raises the
          # proper exception.
          a = np.array([('a', 1)], dtype='S1, int')
          assert_raises(TypeError, np.searchsorted, a, 1.2)
          # Ticket #2066, similar problem:
          dtype = np.format_parser(['i4', 'i4'], [], [])
          a = np.recarray((2, ), dtype)
          assert_raises(TypeError, np.searchsorted, a, 1)
  
      def test_complex64_alignment(self):
          # Issue gh-2668 (trac 2076), segfault on sparc due to misalignment
          dtt = np.complex64
          arr = np.arange(10, dtype=dtt)
          # 2D array
          arr2 = np.reshape(arr, (2, 5))
          # Fortran write followed by (C or F) read caused bus error
          data_str = arr2.tostring('F')
          data_back = np.ndarray(arr2.shape,
                                arr2.dtype,
                                buffer=data_str,
                                order='F')
          assert_array_equal(arr2, data_back)
  
      def test_structured_count_nonzero(self):
          arr = np.array([0, 1]).astype('i4, (2)i4')[:1]
          count = np.count_nonzero(arr)
          assert_equal(count, 0)
  
      def test_copymodule_preserves_f_contiguity(self):
          a = np.empty((2, 2), order='F')
          b = copy.copy(a)
          c = copy.deepcopy(a)
          assert_(b.flags.fortran)
          assert_(b.flags.f_contiguous)
          assert_(c.flags.fortran)
          assert_(c.flags.f_contiguous)
  
      def test_setArrayFromSequence_fails(self):
          arr = np.array([[1,2,3],[4,5,6]])
          def f(a):
              a[:,1] = []
          assert_raises(ValueError, f, arr)
  
  
  if __name__ == "__main__":
      run_module_suite()
  