Test consistency with numpy #78
Labels
enhancement
New feature or request
Comments
|
Oops forgot to share the sample diff on doing this for diff of how you'd modify `test_indexing.py` to utilise the introduced `np` paramterdiff --git a/torch_np/tests/numpy_tests/core/test_indexing.py b/torch_np/tests/numpy_tests/core/test_indexing.py
index ba6ef58..4659813 100644
--- a/torch_np/tests/numpy_tests/core/test_indexing.py
+++ b/torch_np/tests/numpy_tests/core/test_indexing.py
@@ -7,22 +7,22 @@ import re
import pytest
from pytest import raises as assert_raises
+import numpy
+import torch_np
import torch_np as np
# from numpy.core._multiarray_tests import array_indexing # numpy implements this in C
from itertools import product
from torch_np.testing import (
- assert_, assert_equal, assert_raises_regex,
+ assert_, assert_raises_regex,
assert_array_equal, assert_warns, HAS_REFCOUNT, IS_WASM
)
-xfail_neg_step = pytest.mark.xfail(
- reason="torch does not support indexing with negative slice steps"
-)
+neg_step_reason = "torch does not support indexing with negative slice steps"
class TestIndexing:
- def test_index_no_floats(self):
+ def test_index_no_floats(self, np):
a = np.array([[[5]]])
assert_raises(IndexError, lambda: a[0.0])
@@ -58,10 +58,15 @@ class TestIndexing:
# TypeError: slice indices must be integers or None or have an
# __index__ method
#
- assert_raises((IndexError, TypeError), lambda: a[0.0:, 0.0])
- assert_raises((IndexError, TypeError), lambda: a[0.0:, 0.0,:])
-
- def test_slicing_no_floats(self):
+ if np is numpy:
+ error = IndexError
+ else:
+ assert np is torch_np # sanity check
+ error = TypeError
+ assert_raises(error, lambda: a[0.0:, 0.0])
+ assert_raises(error, lambda: a[0.0:, 0.0,:])
+
+ def test_slicing_no_floats(self, np):
a = np.array([[5]])
# start as float.
@@ -92,8 +97,9 @@ class TestIndexing:
# should still get the DeprecationWarning if step = 0.
assert_raises(TypeError, lambda: a[::0.0])
- @pytest.mark.skip(reason="torch allows slicing with non-0d array components")
- def test_index_no_array_to_index(self):
+ def test_index_no_array_to_index(self, np):
+ if np is torch_np:
+ pytest.skip("torch allows slicing with non-0d array components")
# No non-scalar arrays.
a = np.array([[[1]]])
@@ -105,107 +111,114 @@ class TestIndexing:
# array([], shape=(0, 1, 1), dtype=int64)
#
- def test_none_index(self):
+ def test_none_index(self, np):
# `None` index adds newaxis
a = np.array([1, 2, 3])
- assert_equal(a[None], a[np.newaxis])
- assert_equal(a[None].ndim, a.ndim + 1)
+ np.testing.assert_equal(a[None], a[np.newaxis])
+ np.testing.assert_equal(a[None].ndim, a.ndim + 1)
- def test_empty_tuple_index(self):
+ def test_empty_tuple_index(self, np):
# Empty tuple index creates a view
a = np.array([1, 2, 3])
- assert_equal(a[()], a)
+ np.testing.assert_equal(a[()], a)
assert_(a[()].base is a)
a = np.array(0)
- pytest.skip(
- "torch doesn't have scalar types with distinct instancing behaviours"
- )
+ if np is torch_np:
+ pytest.skip(
+ "torch doesn't have scalar types with distinct instancing behaviours"
+ )
assert_(isinstance(a[()], np.int_))
- def test_same_kind_index_casting(self):
+ def test_same_kind_index_casting(self, np):
# Indexes should be cast with same-kind and not safe, even if that
# is somewhat unsafe. So test various different code paths.
index = np.arange(5)
u_index = index.astype(np.uint8) # i.e. cast to default uint indexing dtype
arr = np.arange(10)
- assert_array_equal(arr[index], arr[u_index])
+ np.testing.assert_array_equal(arr[index], arr[u_index])
arr[u_index] = np.arange(5)
- assert_array_equal(arr, np.arange(10))
+ np.testing.assert_array_equal(arr, np.arange(10))
arr = np.arange(10).reshape(5, 2)
- assert_array_equal(arr[index], arr[u_index])
+ np.testing.assert_array_equal(arr[index], arr[u_index])
arr[u_index] = np.arange(5)[:,None]
- pytest.xfail("XXX: repeat() not implemented")
- assert_array_equal(arr, np.arange(5)[:,None].repeat(2, axis=1))
+ if np is torch_np:
+ pytest.xfail("XXX: repeat() not implemented")
+ np.testing.assert_array_equal(arr, np.arange(5)[:,None].repeat(2, axis=1))
arr = np.arange(25).reshape(5, 5)
- assert_array_equal(arr[u_index, u_index], arr[index, index])
+ np.testing.assert_array_equal(arr[u_index, u_index], arr[index, index])
- def test_empty_fancy_index(self):
+ def test_empty_fancy_index(self, np):
# Empty list index creates an empty array
# with the same dtype (but with weird shape)
a = np.array([1, 2, 3])
- assert_equal(a[[]], [])
- assert_equal(a[[]].dtype, a.dtype)
+ np.testing.assert_equal(a[[]], [])
+ np.testing.assert_equal(a[[]].dtype, a.dtype)
b = np.array([], dtype=np.intp)
- assert_equal(a[[]], [])
- assert_equal(a[[]].dtype, a.dtype)
+ np.testing.assert_equal(a[[]], [])
+ np.testing.assert_equal(a[[]].dtype, a.dtype)
b = np.array([])
assert_raises(IndexError, a.__getitem__, b)
- def test_ellipsis_index(self):
+ def test_ellipsis_index(self, np):
a = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
assert_(a[...] is not a)
- assert_equal(a[...], a)
+ np.testing.assert_equal(a[...], a)
# `a[...]` was `a` in numpy <1.9.
assert_(a[...].base is a)
# Slicing with ellipsis can skip an
# arbitrary number of dimensions
- assert_equal(a[0, ...], a[0])
- assert_equal(a[0, ...], a[0,:])
- assert_equal(a[..., 0], a[:, 0])
+ np.testing.assert_equal(a[0, ...], a[0])
+ np.testing.assert_equal(a[0, ...], a[0,:])
+ np.testing.assert_equal(a[..., 0], a[:, 0])
# Slicing with ellipsis always results
# in an array, not a scalar
- assert_equal(a[0, ..., 1], np.array(2))
+ np.testing.assert_equal(a[0, ..., 1], np.array(2))
# Assignment with `(Ellipsis,)` on 0-d arrays
b = np.array(1)
b[(Ellipsis,)] = 2
- assert_equal(b, 2)
+ np.testing.assert_equal(b, 2)
- def test_single_int_index(self):
+ def test_single_int_index(self, np):
# Single integer index selects one row
a = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
- assert_equal(a[0], [1, 2, 3])
- assert_equal(a[-1], [7, 8, 9])
+ np.testing.assert_equal(a[0], [1, 2, 3])
+ np.testing.assert_equal(a[-1], [7, 8, 9])
# Index out of bounds produces IndexError
assert_raises(IndexError, a.__getitem__, 1 << 30)
# Index overflow produces IndexError
# Note torch raises RuntimeError here
- assert_raises((IndexError, RuntimeError), a.__getitem__, 1 << 64)
-
- def test_single_bool_index(self):
+ if np is numpy:
+ error = IndexError
+ else:
+ assert np is torch_np # sanity check
+ error = RuntimeError
+ assert_raises(error, a.__getitem__, 1 << 64)
+
+ def test_single_bool_index(self, np):
# Single boolean index
a = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
- assert_equal(a[np.array(True)], a[None])
- assert_equal(a[np.array(False)], a[None][0:0])
+ np.testing.assert_equal(a[np.array(True)], a[None])
+ np.testing.assert_equal(a[np.array(False)], a[None][0:0])
- def test_boolean_shape_mismatch(self):
+ def test_boolean_shape_mismatch(self, np):
arr = np.ones((5, 4, 3))
index = np.array([True])
@@ -219,17 +232,17 @@ class TestIndexing:
assert_raises(IndexError, arr.__getitem__, (slice(None), index))
- def test_boolean_indexing_onedim(self):
+ def test_boolean_indexing_onedim(self, np):
# Indexing a 2-dimensional array with
# boolean array of length one
a = np.array([[ 0., 0., 0.]])
b = np.array([ True], dtype=bool)
- assert_equal(a[b], a)
+ np.testing.assert_equal(a[b], a)
# boolean assignment
a[b] = 1.
- assert_equal(a, [[1., 1., 1.]])
+ np.testing.assert_equal(a, [[1., 1., 1.]])
- def test_boolean_assignment_value_mismatch(self):
+ def test_boolean_assignment_value_mismatch(self, np):
# A boolean assignment should fail when the shape of the values
# cannot be broadcast to the subscription. (see also gh-3458)
a = np.arange(4)
@@ -237,11 +250,16 @@ class TestIndexing:
def f(a, v):
a[a > -1] = v
- assert_raises((ValueError, TypeError), f, a, [])
- assert_raises((ValueError, TypeError), f, a, [1, 2, 3])
- assert_raises((ValueError, TypeError), f, a[:1], [1, 2, 3])
+ if np is numpy:
+ error = ValueError
+ else:
+ assert np is torch_np # sanity check
+ error = TypeError
+ assert_raises(error, f, a, [])
+ assert_raises(error, f, a, [1, 2, 3])
+ assert_raises(error, f, a[:1], [1, 2, 3])
- def test_boolean_indexing_twodim(self):
+ def test_boolean_indexing_twodim(self, np):
# Indexing a 2-dimensional array with
# 2-dimensional boolean array
a = np.array([[1, 2, 3],
@@ -250,27 +268,28 @@ class TestIndexing:
b = np.array([[ True, False, True],
[False, True, False],
[ True, False, True]])
- assert_equal(a[b], [1, 3, 5, 7, 9])
- assert_equal(a[b[1]], [[4, 5, 6]])
- assert_equal(a[b[0]], a[b[2]])
+ np.testing.assert_equal(a[b], [1, 3, 5, 7, 9])
+ np.testing.assert_equal(a[b[1]], [[4, 5, 6]])
+ np.testing.assert_equal(a[b[0]], a[b[2]])
# boolean assignment
a[b] = 0
- assert_equal(a, [[0, 2, 0],
+ np.testing.assert_equal(a, [[0, 2, 0],
[4, 0, 6],
[0, 8, 0]])
- def test_boolean_indexing_list(self):
+ def test_boolean_indexing_list(self, np):
# Regression test for #13715. It's a use-after-free bug which the
# test won't directly catch, but it will show up in valgrind.
a = np.array([1, 2, 3])
b = [True, False, True]
# Two variants of the test because the first takes a fast path
- assert_equal(a[b], [1, 3])
- assert_equal(a[None, b], [[1, 3]])
+ np.testing.assert_equal(a[b], [1, 3])
+ np.testing.assert_equal(a[None, b], [[1, 3]])
- @xfail_neg_step
- def test_reverse_strides_and_subspace_bufferinit(self):
+ def test_reverse_strides_and_subspace_bufferinit(self, np):
+ if np is torch_np:
+ pytest.xfail(neg_step_reason)
# This tests that the strides are not reversed for simple and
# subspace fancy indexing.
a = np.ones(5)
@@ -279,25 +298,26 @@ class TestIndexing:
a[b] = c
# If the strides are not reversed, the 0 in the arange comes last.
- assert_equal(a[0], 0)
+ np.testing.assert_equal(a[0], 0)
# This also tests that the subspace buffer is initialized:
a = np.ones((5, 2))
c = np.arange(10).reshape(5, 2)[::-1]
a[b, :] = c
- assert_equal(a[0], [0, 1])
+ np.testing.assert_equal(a[0], [0, 1])
- @xfail_neg_step
- def test_reversed_strides_result_allocation(self):
+ def test_reversed_strides_result_allocation(self, np):
+ if np is torch_np:
+ pytest.xfail(neg_step_reason)
# Test a bug when calculating the output strides for a result array
# when the subspace size was 1 (and test other cases as well)
a = np.arange(10)[:, None]
i = np.arange(10)[::-1]
- assert_array_equal(a[i], a[i.copy('C')])
+ np.testing.assert_array_equal(a[i], a[i.copy('C')])
a = np.arange(20).reshape(-1, 2)
- def test_uncontiguous_subspace_assignment(self):
+ def test_uncontiguous_subspace_assignment(self, np):
# During development there was a bug activating a skip logic
# based on ndim instead of size.
a = np.full((3, 4, 2), -1)
@@ -306,28 +326,29 @@ class TestIndexing:
a[[0, 1]] = np.arange(2 * 4 * 2).reshape(2, 4, 2).T
b[[0, 1]] = np.arange(2 * 4 * 2).reshape(2, 4, 2).T.copy()
- assert_equal(a, b)
+ np.testing.assert_equal(a, b)
- @pytest.mark.skip(reason="torch does not limit dims to 32")
- def test_too_many_fancy_indices_special_case(self):
+ def test_too_many_fancy_indices_special_case(self, np):
+ if np is torch_np:
+ pytest.skip("torch does not limit dims to 32")
# Just documents behaviour, this is a small limitation.
a = np.ones((1,) * 32) # 32 is NPY_MAXDIMS
assert_raises(IndexError, a.__getitem__, (np.array([0]),) * 32)
- def test_scalar_array_bool(self):
+ def test_scalar_array_bool(self, np):
# NumPy bools can be used as boolean index (python ones as of yet not)
a = np.array(1)
- assert_equal(a[np.bool_(True)], a[np.array(True)])
- assert_equal(a[np.bool_(False)], a[np.array(False)])
+ np.testing.assert_equal(a[np.bool_(True)], a[np.array(True)])
+ np.testing.assert_equal(a[np.bool_(False)], a[np.array(False)])
# After deprecating bools as integers:
#a = np.array([0,1,2])
- #assert_equal(a[True, :], a[None, :])
- #assert_equal(a[:, True], a[:, None])
+ #np.testing.assert_equal(a[True, :], a[None, :])
+ #np.testing.assert_equal(a[:, True], a[:, None])
#
#assert_(not np.may_share_memory(a, a[True, :]))
- def test_everything_returns_views(self):
+ def test_everything_returns_views(self, np):
# Before `...` would return a itself.
a = np.arange(5)
@@ -335,12 +356,12 @@ class TestIndexing:
assert_(a is not a[...])
assert_(a is not a[:])
- def test_broaderrors_indexing(self):
+ def test_broaderrors_indexing(self, np):
a = np.zeros((5, 5))
assert_raises(IndexError, a.__getitem__, ([0, 1], [0, 1, 2]))
assert_raises(IndexError, a.__setitem__, ([0, 1], [0, 1, 2]), 0)
- def test_trivial_fancy_out_of_bounds(self):
+ def test_trivial_fancy_out_of_bounds(self, np):
a = np.zeros(5)
ind = np.ones(20, dtype=np.intp)
ind[-1] = 10
@@ -351,12 +372,12 @@ class TestIndexing:
assert_raises(IndexError, a.__getitem__, ind)
assert_raises((IndexError, RuntimeError), a.__setitem__, ind, 0)
- def test_trivial_fancy_not_possible(self):
+ def test_trivial_fancy_not_possible(self, np):
# Test that the fast path for trivial assignment is not incorrectly
# used when the index is not contiguous or 1D, see also gh-11467.
a = np.arange(6)
idx = np.arange(6, dtype=np.intp).reshape(2, 1, 3)[:, :, 0]
- assert_array_equal(a[idx], idx)
+ np.testing.assert_array_equal(a[idx], idx)
# this case must not go into the fast path, note that idx is
# a non-contiuguous none 1D array here.
@@ -364,10 +385,11 @@ class TestIndexing:
res = np.arange(6)
res[0] = -1
res[3] = -1
- assert_array_equal(a, res)
+ np.testing.assert_array_equal(a, res)
- @pytest.mark.xfail(reason="XXX: recarray stuff is TBD")
- def test_subclass_writeable(self):
+ def test_subclass_writeable(self, np):
+ if np is torch_np:
+ pytest.xfail("XXX: recarray stuff is TBD")
d = np.rec.array([('NGC1001', 11), ('NGC1002', 1.), ('NGC1003', 1.)],
dtype=[('target', 'S20'), ('V_mag', '>f4')])
ind = np.array([False, True, True], dtype=bool)
@@ -377,7 +399,7 @@ class TestIndexing:
assert_(d[...].flags.writeable)
assert_(d[0].flags.writeable)
- def test_memory_order(self):
+ def test_memory_order(self, np):
# This is not necessary to preserve. Memory layouts for
# more complex indices are not as simple.
a = np.arange(10)
@@ -388,7 +410,7 @@ class TestIndexing:
a = a.reshape(-1, 1)
assert_(a[b, 0].flags.f_contiguous)
- def test_small_regressions(self):
+ def test_small_regressions(self, np):
# Reference count of intp for index checks
a = np.array([0])
if HAS_REFCOUNT:
@@ -402,9 +424,9 @@ class TestIndexing:
np.array([1], dtype=np.uint8), 1)
if HAS_REFCOUNT:
- assert_equal(sys.getrefcount(np.dtype(np.intp)), refcount)
+ np.testing.assert_equal(sys.getrefcount(np.dtype(np.intp)), refcount)
- def test_tuple_subclass(self):
+ def test_tuple_subclass(self, np):
arr = np.ones((5, 5))
# A tuple subclass should also be an nd-index
@@ -416,32 +438,33 @@ class TestIndexing:
# Unlike the non nd-index:
assert_(arr[index,].shape != (1,))
- @pytest.mark.xfail(reason="XXX: low-prio behaviour to support")
- def test_broken_sequence_not_nd_index(self):
+ def test_broken_sequence_not_nd_index(self, np):
+ if np is torch_np:
+ pytest.xfail("XXX: low-prio behaviour to support")
# See https://github.com/numpy/numpy/issues/5063
# If we have an object which claims to be a sequence, but fails
# on item getting, this should not be converted to an nd-index (tuple)
# If this object happens to be a valid index otherwise, it should work
# This object here is very dubious and probably bad though:
class SequenceLike:
- def __index__(self):
+ def __index__(self, np):
return 0
- def __len__(self):
+ def __len__(self, np):
return 1
def __getitem__(self, item):
raise IndexError('Not possible')
arr = np.arange(10)
- assert_array_equal(arr[SequenceLike()], arr[SequenceLike(),])
+ np.testing.assert_array_equal(arr[SequenceLike()], arr[SequenceLike(),])
# also test that field indexing does not segfault
# for a similar reason, by indexing a structured array
arr = np.zeros((1,), dtype=[('f1', 'i8'), ('f2', 'i8')])
- assert_array_equal(arr[SequenceLike()], arr[SequenceLike(),])
+ np.testing.assert_array_equal(arr[SequenceLike()], arr[SequenceLike(),])
- def test_indexing_array_weird_strides(self):
+ def test_indexing_array_weird_strides(self, np):
# See also gh-6221
# the shapes used here come from the issue and create the correct
# size for the iterator buffering size.
@@ -451,13 +474,14 @@ class TestIndexing:
ind = np.broadcast_to(ind, (10, 55, 4, 4))
# single advanced index case
- assert_array_equal(x[ind], x[ind.copy()])
+ np.testing.assert_array_equal(x[ind], x[ind.copy()])
# higher dimensional advanced index
zind = np.zeros(4, dtype=np.intp)
- assert_array_equal(x2[ind, zind], x2[ind.copy(), zind])
+ np.testing.assert_array_equal(x2[ind, zind], x2[ind.copy(), zind])
- @xfail_neg_step
- def test_indexing_array_negative_strides(self):
+ def test_indexing_array_negative_strides(self, np):
+ if np is torch_np:
+ pytest.xfail(neg_step_reason)
# From gh-8264,
# core dumps if negative strides are used in iteration
arro = np.zeros((4, 4))
@@ -465,7 +489,7 @@ class TestIndexing:
slices = (slice(None), [0, 1, 2, 3])
arr[slices] = 10
- assert_array_equal(arr, 10.)
+ np.testing.assert_array_equal(arr, 10.)
@pytest.mark.parametrize("index",
[True, False, np.array([0])])
@@ -475,7 +499,7 @@ class TestIndexing:
# These are limitations based on the number of arguments we can process.
# For `num=32` (and all boolean cases), the result is actually define;
# but the use of NpyIter (NPY_MAXARGS) limits it for technical reasons.
- if not (isinstance(index, np.ndarray) and original_ndim < num):
+ if np is torch_np and not (isinstance(index, np.ndarray) and original_ndim < num):
# unskipped cases fail because of assigning too many indices
pytest.skip("torch does not limit dims to 32")
arr = np.ones((1,) * original_ndim)
@@ -485,16 +509,17 @@ class TestIndexing:
arr[(index,) * num] = 1.
- def test_nontuple_ndindex(self):
+ def test_nontuple_ndindex(self, np):
a = np.arange(25).reshape((5, 5))
- assert_equal(a[[0, 1]], np.array([a[0], a[1]]))
- assert_equal(a[[0, 1], [0, 1]], np.array([0, 6]))
- pytest.skip(
- "torch happily consumes non-tuple sequences with multi-axis "
- "indices (i.e. slices) as an index, whereas NumPy invalidates "
- "them, assumedly to keep things simple. This invalidation "
- "behaviour is just too niche to bother emulating."
- )
+ np.testing.assert_equal(a[[0, 1]], np.array([a[0], a[1]]))
+ np.testing.assert_equal(a[[0, 1], [0, 1]], np.array([0, 6]))
+ if np is torch_np:
+ pytest.skip(
+ "torch happily consumes non-tuple sequences with multi-axis "
+ "indices (i.e. slices) as an index, whereas NumPy invalidates "
+ "them, assumedly to keep things simple. This invalidation "
+ "behaviour is just too niche to bother emulating."
+ )
assert_raises(IndexError, a.__getitem__, [slice(None)])
@@ -503,7 +528,7 @@ class TestBroadcastedAssignments:
a[ind] = val
return a
- def test_prepending_ones(self):
+ def test_prepending_ones(self, np):
a = np.zeros((3, 2))
a[...] = np.ones((1, 3, 2))
@@ -513,7 +538,7 @@ class TestBroadcastedAssignments:
# Fancy without subspace (with broadcasting)
a[[[0], [1], [2]], [0, 1]] = np.ones((1, 3, 2))
- def test_prepend_not_one(self):
+ def test_prepend_not_one(self, np):
assign = self.assign
s_ = np.s_
a = np.zeros(5)
@@ -523,7 +548,7 @@ class TestBroadcastedAssignments:
assert_raises((ValueError, RuntimeError), assign, a, s_[[1, 2, 3],], np.ones((2, 1)))
assert_raises((ValueError, RuntimeError), assign, a, s_[[[1], [2]],], np.ones((2,2,1)))
- def test_simple_broadcasting_errors(self):
+ def test_simple_broadcasting_errors(self, np):
assign = self.assign
s_ = np.s_
a = np.zeros((5, 1))
@@ -552,16 +577,18 @@ class TestBroadcastedAssignments:
)
assert re.search(fr"[\(\[]{r_inner_shape}[\]\)]$", str(e.value))
- @pytest.mark.xfail(reason="XXX: deal with awkward put-like set operations")
- def test_index_is_larger(self):
+ def test_index_is_larger(self, np):
+ if np is torch_np:
+ pytest.xfail("XXX: deal with awkward put-like set operations")
# Simple case of fancy index broadcasting of the index.
a = np.zeros((5, 5))
a[[[0], [1], [2]], [0, 1, 2]] = [2, 3, 4]
assert_((a[:3, :3] == [2, 3, 4]).all())
- @xfail_neg_step
- def test_broadcast_subspace(self):
+ def test_broadcast_subspace(self, np):
+ if np is torch_np:
+ pytest.xfail(neg_step_reason)
a = np.zeros((100, 100))
v = np.arange(100)[:,None]
b = np.arange(100)[::-1]
@@ -570,10 +597,11 @@ class TestBroadcastedAssignments:
class TestFancyIndexingCast:
- @pytest.mark.xfail(
- reason="XXX: low-prio to support assigning complex values on floating arrays"
- )
- def test_boolean_index_cast_assign(self):
+ def test_boolean_index_cast_assign(self, np):
+ if np is torch_np:
+ pytest.xfail(
+ "XXX: low-prio to support assigning complex values on floating arrays"
+ )
# Setup the boolean index and float arrays.
shape = (8, 63)
bool_index = np.zeros(shape).astype(bool)
@@ -582,17 +610,17 @@ class TestFancyIndexingCast:
# Assigning float is fine.
zero_array[bool_index] = np.array([1])
- assert_equal(zero_array[0, 1], 1)
+ np.testing.assert_equal(zero_array[0, 1], 1)
# Fancy indexing works, although we get a cast warning.
assert_warns(np.ComplexWarning,
zero_array.__setitem__, ([0], [1]), np.array([2 + 1j]))
- assert_equal(zero_array[0, 1], 2) # No complex part
+ np.testing.assert_equal(zero_array[0, 1], 2) # No complex part
# Cast complex to float, throwing away the imaginary portion.
assert_warns(np.ComplexWarning,
zero_array.__setitem__, bool_index, np.array([1j]))
- assert_equal(zero_array[0, 1], 0)
+ np.testing.assert_equal(zero_array[0, 1], 0)
@pytest.mark.xfail(reason="XXX: requires broadcast() and broadcast_to()")
class TestMultiIndexingAutomated:
@@ -617,7 +645,7 @@ class TestMultiIndexingAutomated:
"""
- def setup_method(self):
+ def setup_method(self, np):
self.a = np.arange(np.prod([3, 1, 5, 6])).reshape(3, 1, 5, 6)
self.b = np.empty((3, 0, 5, 6))
self.complex_indices = ['skip', Ellipsis,
@@ -904,7 +932,7 @@ class TestMultiIndexingAutomated:
assert_raises(type(e), arr.__getitem__, index)
assert_raises(type(e), arr.__setitem__, index, 0)
if HAS_REFCOUNT:
- assert_equal(prev_refcount, sys.getrefcount(arr))
+ np.testing.assert_equal(prev_refcount, sys.getrefcount(arr))
return
self._compare_index_result(arr, index, mimic_get, no_copy)
@@ -928,7 +956,7 @@ class TestMultiIndexingAutomated:
assert_raises(type(e), arr.__getitem__, index)
assert_raises(type(e), arr.__setitem__, index, 0)
if HAS_REFCOUNT:
- assert_equal(prev_refcount, sys.getrefcount(arr))
+ np.testing.assert_equal(prev_refcount, sys.getrefcount(arr))
return
self._compare_index_result(arr, index, mimic_get, no_copy)
@@ -939,7 +967,7 @@ class TestMultiIndexingAutomated:
pytest.skip("torch does not support subclassing")
arr = arr.copy()
indexed_arr = arr[index]
- assert_array_equal(indexed_arr, mimic_get)
+ np.testing.assert_array_equal(indexed_arr, mimic_get)
# Check if we got a view, unless its a 0-sized or 0-d array.
# (then its not a view, and that does not matter)
if indexed_arr.size != 0 and indexed_arr.ndim != 0:
@@ -948,9 +976,9 @@ class TestMultiIndexingAutomated:
if HAS_REFCOUNT:
if no_copy:
# refcount increases by one:
- assert_equal(sys.getrefcount(arr), 3)
+ np.testing.assert_equal(sys.getrefcount(arr), 3)
else:
- assert_equal(sys.getrefcount(arr), 2)
+ np.testing.assert_equal(sys.getrefcount(arr), 2)
# Test non-broadcast setitem:
b = arr.copy()
@@ -960,17 +988,17 @@ class TestMultiIndexingAutomated:
if no_copy and indexed_arr.ndim != 0:
# change indexed_arr in-place to manipulate original:
indexed_arr += 1000
- assert_array_equal(arr, b)
+ np.testing.assert_array_equal(arr, b)
return
# Use the fact that the array is originally an arange:
arr.flat[indexed_arr.ravel()] += 1000
- assert_array_equal(arr, b)
+ np.testing.assert_array_equal(arr, b)
- def test_boolean(self):
+ def test_boolean(self, np):
a = np.array(5)
- assert_equal(a[np.array(True)], 5)
+ np.testing.assert_equal(a[np.array(True)], 5)
a[np.array(True)] = 1
- assert_equal(a, 1)
+ np.testing.assert_equal(a, 1)
# NOTE: This is different from normal broadcasting, as
# arr[boolean_array] works like in a multi index. Which means
# it is aligned to the left. This is probably correct for
@@ -983,7 +1011,7 @@ class TestMultiIndexingAutomated:
self._check_multi_index(
self.a, (np.zeros_like(self.a, dtype=bool)[None, ...],))
- def test_multidim(self):
+ def test_multidim(self, np):
# Automatically test combinations with complex indexes on 2nd (or 1st)
# spot and the simple ones in one other spot.
with warnings.catch_warnings():
@@ -1013,7 +1041,7 @@ class TestMultiIndexingAutomated:
assert_raises(IndexError, self.a.__getitem__, (0, 0, [1], 0, 0))
assert_raises(IndexError, self.a.__setitem__, (0, 0, [1], 0, 0), 0)
- def test_1d(self):
+ def test_1d(self, np):
a = np.arange(10)
for index in self.complex_indices:
self._check_single_index(a, index)
@@ -1025,7 +1053,7 @@ class TestFloatNonIntegerArgument:
and ``a[0.5]``, or other functions like ``array.reshape(1., -1)``.
"""
- def test_valid_indexing(self):
+ def test_valid_indexing(self, np):
# These should raise no errors.
a = np.array([[[5]]])
@@ -1035,7 +1063,7 @@ class TestFloatNonIntegerArgument:
a[:, 0,:]
a[:,:,:]
- def test_valid_slicing(self):
+ def test_valid_slicing(self, np):
# These should raise no errors.
a = np.array([[[5]]])
@@ -1048,21 +1076,19 @@ class TestFloatNonIntegerArgument:
a[:2:2]
a[1:2:2]
- def test_non_integer_argument_errors(self):
+ def test_non_integer_argument_errors(self, np):
a = np.array([[5]])
assert_raises(TypeError, np.reshape, a, (1., 1., -1))
assert_raises(TypeError, np.reshape, a, (np.array(1.), -1))
- pytest.xfail("XXX: take not implemented")
+ if np is torch_np:
+ pytest.xfail("XXX: take not implemented")
assert_raises(TypeError, np.take, a, [0], 1.)
assert_raises(TypeError, np.take, a, [0], np.float64(1.))
- @pytest.mark.skip(
- reason=(
- "torch doesn't have scalar types with distinct element-wise behaviours"
- )
- )
- def test_non_integer_sequence_multiplication(self):
+ def test_non_integer_sequence_multiplication(self, np):
+ if np is torch_np:
+ pytest.skip("torch doesn't have scalar types with distinct element-wise behaviours")
# NumPy scalar sequence multiply should not work with non-integers
def mult(a, b):
return a * b
@@ -1071,7 +1097,7 @@ class TestFloatNonIntegerArgument:
# following should be OK
mult([1], np.int_(3))
- def test_reduce_axis_float_index(self):
+ def test_reduce_axis_float_index(self, np):
d = np.zeros((3,3,3))
assert_raises(TypeError, np.min, d, 0.5)
assert_raises(TypeError, np.min, d, (0.5, 1))
@@ -1081,7 +1107,7 @@ class TestFloatNonIntegerArgument:
class TestBooleanIndexing:
# Using a boolean as integer argument/indexing is an error.
- def test_bool_as_int_argument_errors(self):
+ def test_bool_as_int_argument_errors(self, np):
a = np.array([[[1]]])
assert_raises(TypeError, np.reshape, a, (True, -1))
@@ -1089,21 +1115,23 @@ class TestBooleanIndexing:
# array is thus also deprecated, but not with the same message:
assert_warns(DeprecationWarning, operator.index, np.True_)
- pytest.xfail("XXX: take not implemented")
+ if np is torch_np:
+ pytest.xfail("XXX: take not implemented")
assert_raises(TypeError, np.take, args=(a, [0], False))
- pytest.skip("torch consumes boolean tensors as ints, no bother raising here")
+ if np is torch_np:
+ pytest.skip("torch consumes boolean tensors as ints, no bother raising here")
assert_raises(TypeError, np.reshape, a, (np.bool_(True), -1))
assert_raises(TypeError, operator.index, np.array(True))
- def test_boolean_indexing_weirdness(self):
+ def test_boolean_indexing_weirdness(self, np):
# Weird boolean indexing things
a = np.ones((2, 3, 4))
assert a[False, True, ...].shape == (0, 2, 3, 4)
assert a[True, [0, 1], True, True, [1], [[2]]].shape == (1, 2)
assert_raises(IndexError, lambda: a[False, [0, 1], ...])
- def test_boolean_indexing_fast_path(self):
+ def test_boolean_indexing_fast_path(self, np):
# These used to either give the wrong error, or incorrectly give no
# error.
a = np.ones((3, 3))
@@ -1134,20 +1162,23 @@ class TestArrayToIndexDeprecation:
"""Creating an index from array not 0-D is an error.
"""
- def test_array_to_index_error(self):
+ def test_array_to_index_error(self, np):
# so no exception is expected. The raising is effectively tested above.
a = np.array([[[1]]])
- pytest.xfail("XXX: take not implemented")
+ if np is torch_np:
+ pytest.xfail("XXX: take not implemented")
assert_raises(TypeError, np.take, a, [0], a)
- pytest.skip(
- "Multi-dimensional tensors are indexable just as long as they only "
- "contain a single element, no bother raising here"
- )
+ if np is torch_np:
+ pytest.skip(
+ "Multi-dimensional tensors are indexable just as long as they only "
+ "contain a single element, no bother raising here"
+ )
assert_raises(TypeError, operator.index, np.array([1]))
- pytest.skip("torch consumes tensors as ints, no bother raising here")
+ if np is torch_np:
+ pytest.skip("torch consumes tensors as ints, no bother raising here")
assert_raises(TypeError, np.reshape, a, (a, -1))
@@ -1158,14 +1189,13 @@ class TestNonIntegerArrayLike:
an integer.
"""
- @pytest.mark.skip(
- reason=(
- "torch consumes floats by way of falling back on its deprecated "
- "__index__ behaviour, no bother raising here"
- )
- )
@pytest.mark.filterwarnings("ignore::DeprecationWarning")
- def test_basic(self):
+ def test_basic(self, np):
+ if np is torch_np:
+ pytest.skip(
+ "torch consumes floats by way of falling back on its deprecated "
+ "__index__ behaviour, no bother raising here"
+ )
a = np.arange(10)
assert_raises(IndexError, a.__getitem__, [0.5, 1.5])
@@ -1179,13 +1209,12 @@ class TestMultipleEllipsisError:
"""An index can only have a single ellipsis.
"""
- @pytest.mark.xfail(
- reason=(
- "torch currently consumes multiple ellipsis, no bother raising "
- "here. See https://github.com/pytorch/pytorch/issues/59787#issue-917252204"
- )
- )
- def test_basic(self):
+ def test_basic(self, np):
+ if np is torch_np:
+ pytest.xfail(
+ "torch currently consumes multiple ellipsis, no bother raising "
+ "here. See https://github.com/pytorch/pytorch/issues/59787#issue-917252204"
+ )
a = np.arange(10)
assert_raises(IndexError, lambda: a[..., ...])
assert_raises(IndexError, a.__getitem__, ((Ellipsis,) * 2,))As mentioned it's a bit finnicky as you have to check So IMO probably not something we'd want to rework our existing tests for, but instead use just when we want to sanity check things as-and-when desired. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
#77 puts a nice scaffolding for being able to toggle the context for individual tests between the original numpy and torch_np. Let's think how to best organize this sort of testing.
The text was updated successfully, but these errors were encountered: