from __future__ import division, absolute_import, print_function

import copy

import pickle

import sys

import platform

import gc

import warnings

import tempfile

from os import path

from io import BytesIO

from itertools import chain

import numpy as np

from numpy.testing import (

        run_module_suite, assert_, assert_equal, IS_PYPY,

        assert_almost_equal, assert_array_equal, assert_array_almost_equal,

        assert_raises, assert_warns, dec, suppress_warnings,

        _assert_valid_refcount, HAS_REFCOUNT,

        )

from numpy.compat import asbytes, asunicode, long

try:

    RecursionError

except NameError:

    RecursionError = RuntimeError  # python < 3.5

class TestRegression(object):

    def test_invalid_round(self):

        # Ticket #3

        v = 4.7599999999999998

        assert_array_equal(np.array([v]), np.array(v))

    def test_mem_empty(self):

        # Ticket #7

        np.empty((1,), dtype=[('x', np.int64)])

    def test_pickle_transposed(self):

        # 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):

        # Ticket #31

        assert_equal(np.typeNA[np.int64], 'Int64')

        assert_equal(np.typeNA[np.uint64], 'UInt64')

    def test_dtype_names(self):

        # Ticket #35

        # Should succeed

        np.dtype([(('name', 'label'), np.int32, 3)])

    def test_reduce(self):

        # Ticket #40

        assert_almost_equal(np.add.reduce([1., .5], dtype=None), 1.5)

    def test_zeros_order(self):

        # Ticket #43

        np.zeros([3], int, 'C')

        np.zeros([3], order='C')

        np.zeros([3], int, order='C')

    def test_asarray_with_order(self):

        # 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):

        # 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):

        # Ticket #47

        a = np.linspace(0, 10, 11)

        c = a.astype(np.dtype('

        c.sort()

        assert_array_almost_equal(c, a)

    def test_negative_nd_indexing(self):

        # 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):

        # Ticket #50

        f = BytesIO()

        ca = np.char.array(np.arange(1000, 1010), itemsize=4)

        ca.dump(f)

        f.seek(0)

        ca = np.load(f, allow_pickle=True)

        f.close()

    def test_noncontiguous_fill(self):

        # Ticket #58.

        a = np.zeros((5, 3))

        b = a[:, :2,]

        def rs():

            b.shape = (10,)

        assert_raises(AttributeError, rs)

    def test_bool(self):

        # Ticket #60

        np.bool_(1)  # Should succeed

    def test_indexing1(self):

        # 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):

        # Ticket #65

        descr = [('x', 'i4', (2,))]

        buffer = ([3, 2],)

        h = np.array(buffer, dtype=descr)

        h['x']

    def test_round(self):

        # Ticket #67

        x = np.array([1+2j])

        assert_almost_equal(x**(-1), [1/(1+2j)])

    def test_scalar_compare(self):

        # Trac Ticket #72

        # https://github.com/numpy/numpy/issues/565

        a = np.array(['test', 'auto'])

        assert_array_equal(a == 'auto', np.array([False, True]))

        assert_(a[1] == 'auto')

        assert_(a[0] != 'auto')

        b = np.linspace(0, 10, 11)

        # This should return true for now, but will eventually raise an error:

        with suppress_warnings() as sup:

            sup.filter(FutureWarning)

            assert_(b != 'auto')

        assert_(b[0] != 'auto')

    def test_unicode_swapping(self):

        # Ticket #79

        ulen = 1

        ucs_value = u'\U0010FFFF'

        ua = np.array([[[ucs_value*ulen]*2]*3]*4, dtype='U%s' % ulen)

        ua.newbyteorder()  # Should succeed.

    def test_object_array_fill(self):

        # Ticket #86

        x = np.zeros(1, 'O')

        x.fill([])

    def test_mem_dtype_align(self):

        # Ticket #93

        assert_raises(TypeError, np.dtype,

                              {'names':['a'], 'formats':['foo']}, align=1)

    def test_endian_bool_indexing(self):

        # Ticket #105

        a = np.arange(10., dtype='>f8')

        b = np.arange(10., dtype='

        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):

        # 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):

        # 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):

        # 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):

        # Ticket #111

        ref = np.arange(10)

        x = np.arange(10, dtype='

        assert_array_equal(ref, x)

        x = np.arange(10, dtype='>f8')

        assert_array_equal(ref, x)

    def test_argmax(self):

        # Ticket #119

        a = np.random.normal(0, 1, (4, 5, 6, 7, 8))

        for i in range(a.ndim):

            a.argmax(i)  # Should succeed

    def test_mem_divmod(self):

        # Ticket #126

        for i in range(10):

            divmod(np.array([i])[0], 10)

    def test_hstack_invalid_dims(self):

        # Ticket #128

        x = np.arange(9).reshape((3, 3))

        y = np.array([0, 0, 0])

        assert_raises(ValueError, np.hstack, (x, y))

    def test_squeeze_type(self):

        # 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):

        # 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):

        # Ticket #151

        assert_equal('0', np.binary_repr(0))

    def test_rec_iterate(self):

        # 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):

        # Ticket #190

        a = np.array('hello', np.unicode_)

        b = np.array('world')

        a == b

    def test_tobytes_FORTRANORDER_discontiguous(self):

        # Fix in r2836

        # Create non-contiguous Fortran ordered array

        x = np.array(np.random.rand(3, 3), order='F')[:, :2]

        assert_array_almost_equal(x.ravel(), np.frombuffer(x.tobytes()))

    def test_flat_assignment(self):

        # 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):

        # Ticket #194

        x = np.empty((3, 1))

        def bfa():

            x[:] = np.arange(3)

        def bfb():

            x[:] = np.arange(3, dtype=float)

        assert_raises(ValueError, bfa)

        assert_raises(ValueError, bfb)

    def test_nonarray_assignment(self):

        # See also Issue gh-2870, test for non-array 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):

        # 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):

        # Ticket #196

        dt = np.dtype([('x', int), ('y', np.object_)])

        # Wrong way

        assert_raises(ValueError, np.array, [1, 'object'], dt)

        # Correct way

        np.array([(1, 'object')], dt)

    def test_recarray_single_element(self):

        # 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):

        # Ticket #205

        tmp = np.array([])

        def index_tmp():

            tmp[np.array(10)]

        assert_raises(IndexError, index_tmp)

    def test_chararray_rstrip(self):

        # Ticket #222

        x = np.chararray((1,), 5)

        x[0] = b'a   '

        x = x.rstrip()

        assert_equal(x[0], b'a')

    def test_object_array_shape(self):

        # 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):

        # 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):

        # Ticket #246

        x = np.char.array(("x", "x ", "x  "))

        for c in x:

            assert_equal(c, "x")

    def test_lexsort(self):

        # Lexsort memory error

        v = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

        assert_equal(np.lexsort(v), 0)

    def test_lexsort_invalid_sequence(self):

        # Issue gh-4123

        class BuggySequence(object):

            def __len__(self):

                return 4

            def __getitem__(self, key):

                raise KeyError

        assert_raises(KeyError, np.lexsort, BuggySequence())

    def test_pickle_py2_bytes_encoding(self):

        # Check that arrays and scalars pickled on Py2 are

        # unpickleable on Py3 using encoding='bytes'

        test_data = [

            # (original, py2_pickle)

            (np.unicode_('\u6f2c'),

             b"cnumpy.core.multiarray\nscalar\np0\n(cnumpy\ndtype\np1\n"

             b"(S'U1'\np2\nI0\nI1\ntp3\nRp4\n(I3\nS'<'\np5\nNNNI4\nI4\n"

             b"I0\ntp6\nbS',o\\x00\\x00'\np7\ntp8\nRp9\n."),

            (np.array([9e123], dtype=np.float64),

             b"cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\n"

             b"p1\n(I0\ntp2\nS'b'\np3\ntp4\nRp5\n(I1\n(I1\ntp6\ncnumpy\ndtype\n"

             b"p7\n(S'f8'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS'<'\np11\nNNNI-1\nI-1\n"

             b"I0\ntp12\nbI00\nS'O\\x81\\xb7Z\\xaa:\\xabY'\np13\ntp14\nb."),

            (np.array([(9e123,)], dtype=[('name', float)]),

             b"cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\np1\n"

             b"(I0\ntp2\nS'b'\np3\ntp4\nRp5\n(I1\n(I1\ntp6\ncnumpy\ndtype\np7\n"

             b"(S'V8'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS'|'\np11\nN(S'name'\np12\ntp13\n"

             b"(dp14\ng12\n(g7\n(S'f8'\np15\nI0\nI1\ntp16\nRp17\n(I3\nS'<'\np18\nNNNI-1\n"

             b"I-1\nI0\ntp19\nbI0\ntp20\nsI8\nI1\nI0\ntp21\n"

             b"bI00\nS'O\\x81\\xb7Z\\xaa:\\xabY'\np22\ntp23\nb."),

        ]

        if sys.version_info[:2] >= (3, 4):

            # encoding='bytes' was added in Py3.4

            for original, data in test_data:

                result = pickle.loads(data, encoding='bytes')

                assert_equal(result, original)

                if isinstance(result, np.ndarray) and result.dtype.names:

                    for name in result.dtype.names:

                        assert_(isinstance(name, str))

    def test_pickle_dtype(self):

        # Ticket #251

        pickle.dumps(float)

    def test_swap_real(self):

        # Ticket #265

        assert_equal(np.arange(4, dtype='>c8').imag.max(), 0.0)

        assert_equal(np.arange(4, dtype='

        assert_equal(np.arange(4, dtype='>c8').real.max(), 3.0)

        assert_equal(np.arange(4, dtype='

    def test_object_array_from_list(self):

        # Ticket #270

        assert_(np.array([1, 'A', None]).shape == (3,))

    def test_multiple_assign(self):

        # Ticket #273

        a = np.zeros((3, 1), int)

        a[[1, 2]] = 1

    def test_empty_array_type(self):

        assert_equal(np.array([]).dtype, np.zeros(0).dtype)

    def test_void_copyswap(self):

        dt = np.dtype([('one', '

        x = np.array((1, 2), dtype=dt)

        x = x.byteswap()

        assert_(x['one'] > 1 and x['two'] > 2)

    def test_method_args(self):

        # 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:

                res1 = arr

            if res1.dtype.kind in 'uib':

                assert_((res1 == res2).all(), 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):

        # Ticket #298

        lst = ['abc', 'cde', 'fgh']

        np.lexsort((lst,))

    def test_fancy_index(self):

        # Ticket #302

        x = np.array([1, 2])[np.array([0])]

        assert_equal(x.shape, (1,))

    def test_recarray_copy(self):

        # 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):

        # 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):

        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):

        # 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):

        # 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):

        # Ticket #327

        data = np.arange(5)

        data = np.add.outer(data, data)

    def test_mem_float_imag(self):

        # Ticket #330

        np.float64(1.0).imag

    def test_dtype_tuple(self):

        # Ticket #334

        assert_(np.dtype('i4') == np.dtype(('i4', ())))

    def test_dtype_posttuple(self):

        # Ticket #335

        np.dtype([('col1', '()i4')])

    def test_numeric_carray_compare(self):

        # Ticket #341

        assert_equal(np.array(['X'], 'c'), b'X')

    def test_string_array_size(self):

        # Ticket #342

        assert_raises(ValueError,

                              np.array, [['X'], ['X', 'X', 'X']], '|S1')

    def test_dtype_repr(self):

        # Ticket #344

        dt1 = np.dtype(('uint32', 2))

        dt2 = np.dtype(('uint32', (2,)))

        assert_equal(dt1.__repr__(), dt2.__repr__())

    def test_reshape_order(self):

        # 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):

        # 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):

        # 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):

        # 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):

        # 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):

        a = np.array([1, 2, 3], dtype=object)

        assert_(a.argmax() == 2)

    def test_recarray_fields(self):

        # 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):

        # 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):

        # Changeset #3443

        _assert_valid_refcount(np.vdot)

    def test_startswith(self):

        ca = np.char.array(['Hi', 'There'])

        assert_equal(ca.startswith('H'), [True, False])

    def test_noncommutative_reduce_accumulate(self):

        # 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):

        # Convolve should raise an error for empty input array.

        assert_raises(ValueError, np.convolve, [], [1])

        assert_raises(ValueError, np.convolve, [1], [])

    def test_multidim_byteswap(self):

        # 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):

        # 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):

        # Ticket #483

        r = np.array([[b'abc']], dtype=[('var1', '|S20')])

        assert_(asbytes(r['var1'][0][0]) == b'abc')

    def test_take_output(self):

        # 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)

        if HAS_REFCOUNT:

            ref_d = sys.getrefcount(d)

        try:

            a.take([0, 100])

        except IndexError:

            pass

        if HAS_REFCOUNT:

            assert_(ref_d == sys.getrefcount(d))

    def test_array_str_64bit(self):

        # Ticket #501

        s = np.array([1, np.nan], dtype=np.float64)

        with np.errstate(all='raise'):

            np.array_str(s)  # Should succeed

    def test_frompyfunc_endian(self):

        # 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='

        assert_almost_equal(uradians(big_endian).astype(float),

                            uradians(little_endian).astype(float))

    def test_mem_string_arr(self):

        # Ticket #514

        s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

        t = []

        np.hstack((t, s))

    def test_arr_transpose(self):

        # Ticket #516

        x = np.random.rand(*(2,)*16)

        x.transpose(list(range(16)))  # Should succeed

    def test_string_mergesort(self):

        # Ticket #540

        x = np.array(['a']*32)

        assert_array_equal(x.argsort(kind='m'), np.arange(32))

    def test_argmax_byteorder(self):

        # Ticket #546

        a = np.arange(3, dtype='>f')

        assert_(a[a.argmax()] == a.max())

    def test_rand_seed(self):

        # Ticket #555

        for l in np.arange(4):

            np.random.seed(l)

    def test_mem_deallocation_leak(self):

        # 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"

        assert_raises(ValueError, np.fromiter, [['12', ''], ['13', '']], str)

    def test_dot_negative_stride(self):

        # 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):

        # 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

        assert_raises(TypeError, rs)

    def test_unicode_scalar(self):

        # 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):

        # Ticket #616

        for T in ('>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_flat_indexing_invalid_nr_elements(self):

        s = np.ones(10, dtype=float)

        x = np.array((15,), dtype=float)

        def ia(x, s, v):

            x[(s > 0)] = v

        assert_raises(IndexError, ia, x, s, np.zeros(9, dtype=float))

        assert_raises(IndexError, ia, x, s, np.zeros(11, dtype=float))

        # Old special case (different code path):

        assert_raises(ValueError, ia, x.flat, s, np.zeros(9, dtype=float))

        assert_raises(ValueError, ia, x.flat, s, np.zeros(11, dtype=float))

    def test_mem_scalar_indexing(self):

        # Ticket #603

        x = np.array([0], dtype=float)

        index = np.array(0, dtype=np.int32)

        x[index]

    def test_binary_repr_0_width(self):

        assert_equal(np.binary_repr(0, width=3), '000')

    def test_fromstring(self):

        assert_equal(np.fromstring("12:09:09", dtype=int, sep=":"),

                     [12, 9, 9])

    def test_searchsorted_variable_length(self):

        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):

        # Check argsort for strings containing zeros.

        x = np.frombuffer(b"\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):

        # Check sort for strings containing zeros.

        x = np.frombuffer(b"\x00\x02\x00\x01", dtype="|S2")

        y = np.frombuffer(b"\x00\x01\x00\x02", dtype="|S2")

        assert_array_equal(np.sort(x, kind="q"), y)

    def test_copy_detection_zero_dim(self):

        # Ticket #658

        np.indices((0, 3, 4)).T.reshape(-1, 3)

    def test_flat_byteorder(self):

        # Ticket #657

        x = np.arange(10)

        assert_array_equal(x.astype('>i4'), x.astype('

        assert_array_equal(x.astype('>i4').flat[:], x.astype('

    def test_sign_bit(self):

        x = np.array([0, -0.0, 0])

        assert_equal(str(np.abs(x)), '[0. 0. 0.]')

    def test_flat_index_byteswap(self):

        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):

        # 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):

        # 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):

        # Ticket #633

        if not hasattr(sys, 'getrefcount'):

            return

        # NB. this is probably CPython-specific

        cnt = sys.getrefcount

        a = object()

        b = object()