array-api-strict 2.2__py3-none-any.whl → 2.3__py3-none-any.whl

array_api_strict/tests/test_array_object.py

@@ -5,7 +5,7 @@ from numpy.testing import assert_raises, suppress_warnings
 import numpy as np
 import pytest
 
-from .. import ones, asarray, result_type, all, equal
+from .. import ones, arange, reshape, asarray, result_type, all, equal
 from .._array_object import Array, CPU_DEVICE, Device
 from .._dtypes import (
     _all_dtypes,
@@ -45,35 +45,46 @@ def test_validate_index():
     a = ones((3, 4))
 
     # Out of bounds slices are not allowed
-    assert_raises(IndexError, lambda: a[:4])
-    assert_raises(IndexError, lambda: a[:-4])
-    assert_raises(IndexError, lambda: a[:3:-1])
-    assert_raises(IndexError, lambda: a[:-5:-1])
-    assert_raises(IndexError, lambda: a[4:])
-    assert_raises(IndexError, lambda: a[-4:])
-    assert_raises(IndexError, lambda: a[4::-1])
-    assert_raises(IndexError, lambda: a[-4::-1])
-
-    assert_raises(IndexError, lambda: a[...,:5])
-    assert_raises(IndexError, lambda: a[...,:-5])
-    assert_raises(IndexError, lambda: a[...,:5:-1])
-    assert_raises(IndexError, lambda: a[...,:-6:-1])
-    assert_raises(IndexError, lambda: a[...,5:])
-    assert_raises(IndexError, lambda: a[...,-5:])
-    assert_raises(IndexError, lambda: a[...,5::-1])
-    assert_raises(IndexError, lambda: a[...,-5::-1])
+    assert_raises(IndexError, lambda: a[:4, 0])
+    assert_raises(IndexError, lambda: a[:-4, 0])
+    assert_raises(IndexError, lambda: a[:3:-1])  # XXX raises for a wrong reason
+    assert_raises(IndexError, lambda: a[:-5:-1, 0])
+    assert_raises(IndexError, lambda: a[4:, 0])
+    assert_raises(IndexError, lambda: a[-4:, 0])
+    assert_raises(IndexError, lambda: a[4::-1, 0])
+    assert_raises(IndexError, lambda: a[-4::-1, 0])
+
+    assert_raises(IndexError, lambda: a[..., :5])
+    assert_raises(IndexError, lambda: a[..., :-5])
+    assert_raises(IndexError, lambda: a[..., :5:-1])
+    assert_raises(IndexError, lambda: a[..., :-6:-1])
+    assert_raises(IndexError, lambda: a[..., 5:])
+    assert_raises(IndexError, lambda: a[..., -5:])
+    assert_raises(IndexError, lambda: a[..., 5::-1])
+    assert_raises(IndexError, lambda: a[..., -5::-1])
 
     # Boolean indices cannot be part of a larger tuple index
-    assert_raises(IndexError, lambda: a[a[:,0]==1,0])
-    assert_raises(IndexError, lambda: a[a[:,0]==1,...])
-    assert_raises(IndexError, lambda: a[..., a[0]==1])
+    assert_raises(IndexError, lambda: a[a[:, 0] == 1, 0])
+    assert_raises(IndexError, lambda: a[a[:, 0] == 1, ...])
+    assert_raises(IndexError, lambda: a[..., a[0] == 1])
     assert_raises(IndexError, lambda: a[[True, True, True]])
     assert_raises(IndexError, lambda: a[(True, True, True),])
 
-    # Integer array indices are not allowed (except for 0-D)
-    idx = asarray([[0, 1]])
-    assert_raises(IndexError, lambda: a[idx])
-    assert_raises(IndexError, lambda: a[idx,])
+    # Mixing 1D integer array indices with slices, ellipsis or booleans is not allowed
+    idx = asarray([0, 1])
+    assert_raises(IndexError, lambda: a[..., idx])
+    assert_raises(IndexError, lambda: a[:, idx])
+    assert_raises(IndexError, lambda: a[asarray([True, True]), idx])
+
+    # 1D integer array indices must have the same length
+    idx1 = asarray([0, 1])
+    idx2 = asarray([0, 1, 1])
+    assert_raises(IndexError, lambda: a[idx1, idx2])
+
+    # Non-integer array indices are not allowed
+    assert_raises(IndexError, lambda: a[ones(2), 0])
+
+    # Array-likes (lists, tuples) are not allowed as indices
     assert_raises(IndexError, lambda: a[[0, 1]])
     assert_raises(IndexError, lambda: a[(0, 1), (0, 1)])
     assert_raises(IndexError, lambda: a[[0, 1]])
@@ -87,6 +98,45 @@ def test_validate_index():
     assert_raises(IndexError, lambda: a[0,])
     assert_raises(IndexError, lambda: a[0])
     assert_raises(IndexError, lambda: a[:])
+    assert_raises(IndexError, lambda: a[idx])
+
+
+def test_indexing_arrays():
+    # indexing with 1D integer arrays and mixes of integers and 1D integer are allowed
+
+    # 1D array
+    a = arange(5)
+    idx = asarray([1, 0, 1, 2, -1])
+    a_idx = a[idx]
+
+    a_idx_loop = asarray([a[idx[i]] for i in range(idx.shape[0])])
+    assert all(a_idx == a_idx_loop)
+
+    # setitem with arrays is not allowed
+    with assert_raises(IndexError):
+        a[idx] = 42
+
+    # mixed array and integer indexing
+    a = reshape(arange(3*4), (3, 4))
+    idx = asarray([1, 0, 1, 2, -1])
+    a_idx = a[idx, 1]
+
+    a_idx_loop = asarray([a[idx[i], 1] for i in range(idx.shape[0])])
+    assert all(a_idx == a_idx_loop)
+
+    # index with two arrays
+    a_idx = a[idx, idx]
+    a_idx_loop = asarray([a[idx[i], idx[i]] for i in range(idx.shape[0])])
+    assert all(a_idx == a_idx_loop)
+
+    # setitem with arrays is not allowed
+    with assert_raises(IndexError):
+        a[idx, idx] = 42
+
+    # smoke test indexing with ndim > 1 arrays
+    idx = idx[..., None]
+    a[idx, idx]
+
 
 def test_promoted_scalar_inherits_device():
     device1 = Device("device1")
@@ -96,12 +146,68 @@ def test_promoted_scalar_inherits_device():
 
     assert y.device == device1
 
+
+BIG_INT = int(1e30)
+
+def _check_op_array_scalar(dtypes, a, s, func, func_name, BIG_INT=BIG_INT):
+    # Test array op scalar. From the spec, the following combinations
+    # are supported:
+
+    # - Python bool for a bool array dtype,
+    # - a Python int within the bounds of the given dtype for integer array dtypes,
+    # - a Python int or float for real floating-point array dtypes
+    # - a Python int, float, or complex for complex floating-point array dtypes
+
+    # an exception: complex scalar <op> floating array
+    scalar_types_for_float = [float, int]
+    if not (func_name.startswith("__i")
+            or (func_name in ["__floordiv__", "__rfloordiv__", "__mod__", "__rmod__"]
+                and type(s) == complex)
+    ):
+        scalar_types_for_float += [complex]
+
+    if ((dtypes == "all"
+         or dtypes == "numeric" and a.dtype in _numeric_dtypes
+         or dtypes == "real numeric" and a.dtype in _real_numeric_dtypes
+         or dtypes == "integer" and a.dtype in _integer_dtypes
+         or dtypes == "integer or boolean" and a.dtype in _integer_or_boolean_dtypes
+         or dtypes == "boolean" and a.dtype in _boolean_dtypes
+         or dtypes == "floating-point" and a.dtype in _floating_dtypes
+         or dtypes == "real floating-point" and a.dtype in _real_floating_dtypes
+        )
+        # bool is a subtype of int, which is why we avoid
+        # isinstance here.
+        and (a.dtype in _boolean_dtypes and type(s) == bool
+             or a.dtype in _integer_dtypes and type(s) == int
+             or a.dtype in _real_floating_dtypes and type(s) in scalar_types_for_float
+             or a.dtype in _complex_floating_dtypes and type(s) in [complex, float, int]
+        )):
+        if a.dtype in _integer_dtypes and s == BIG_INT:
+            with assert_raises(OverflowError):
+                func(s)
+            return False
+
+        else:
+            # Only test for no error
+            with suppress_warnings() as sup:
+                # ignore warnings from pow(BIG_INT)
+                sup.filter(RuntimeWarning,
+                           "invalid value encountered in power")
+                func(s)
+            return True
+
+    else:
+        with assert_raises(TypeError):
+            func(s)
+        return False
+
+
 def test_operators():
     # For every operator, we test that it works for the required type
     # combinations and raises TypeError otherwise
     binary_op_dtypes = {
         "__add__": "numeric",
-        "__and__": "integer_or_boolean",
+        "__and__": "integer or boolean",
         "__eq__": "all",
         "__floordiv__": "real numeric",
         "__ge__": "real numeric",
@@ -112,12 +218,12 @@ def test_operators():
         "__mod__": "real numeric",
         "__mul__": "numeric",
         "__ne__": "all",
-        "__or__": "integer_or_boolean",
+        "__or__": "integer or boolean",
         "__pow__": "numeric",
         "__rshift__": "integer",
         "__sub__": "numeric",
-        "__truediv__": "floating",
-        "__xor__": "integer_or_boolean",
+        "__truediv__": "floating-point",
+        "__xor__": "integer or boolean",
     }
     # Recompute each time because of in-place ops
     def _array_vals():
@@ -128,8 +234,6 @@ def test_operators():
         for d in _floating_dtypes:
             yield asarray(1.0, dtype=d)
 
-
-    BIG_INT = int(1e30)
     for op, dtypes in binary_op_dtypes.items():
         ops = [op]
         if op not in ["__eq__", "__ne__", "__le__", "__ge__", "__lt__", "__gt__"]:
@@ -139,40 +243,7 @@ def test_operators():
         for s in [1, 1.0, 1j, BIG_INT, False]:
             for _op in ops:
                 for a in _array_vals():
-                    # Test array op scalar. From the spec, the following combinations
-                    # are supported:
-
-                    # - Python bool for a bool array dtype,
-                    # - a Python int within the bounds of the given dtype for integer array dtypes,
-                    # - a Python int or float for real floating-point array dtypes
-                    # - a Python int, float, or complex for complex floating-point array dtypes
-
-                    if ((dtypes == "all"
-                         or dtypes == "numeric" and a.dtype in _numeric_dtypes
-                         or dtypes == "real numeric" and a.dtype in _real_numeric_dtypes
-                         or dtypes == "integer" and a.dtype in _integer_dtypes
-                         or dtypes == "integer_or_boolean" and a.dtype in _integer_or_boolean_dtypes
-                         or dtypes == "boolean" and a.dtype in _boolean_dtypes
-                         or dtypes == "floating" and a.dtype in _floating_dtypes
-                        )
-                        # bool is a subtype of int, which is why we avoid
-                        # isinstance here.
-                        and (a.dtype in _boolean_dtypes and type(s) == bool
-                             or a.dtype in _integer_dtypes and type(s) == int
-                             or a.dtype in _real_floating_dtypes and type(s) in [float, int]
-                             or a.dtype in _complex_floating_dtypes and type(s) in [complex, float, int]
-                        )):
-                        if a.dtype in _integer_dtypes and s == BIG_INT:
-                            assert_raises(OverflowError, lambda: getattr(a, _op)(s))
-                        else:
-                            # Only test for no error
-                            with suppress_warnings() as sup:
-                                # ignore warnings from pow(BIG_INT)
-                                sup.filter(RuntimeWarning,
-                                           "invalid value encountered in power")
-                                getattr(a, _op)(s)
-                    else:
-                        assert_raises(TypeError, lambda: getattr(a, _op)(s))
+                    _check_op_array_scalar(dtypes, a, s, getattr(a, _op), _op)
 
                 # Test array op array.
                 for _op in ops:
@@ -203,10 +274,10 @@ def test_operators():
                                 or (dtypes == "real numeric" and x.dtype in _real_numeric_dtypes and y.dtype in _real_numeric_dtypes)
                                 or (dtypes == "numeric" and x.dtype in _numeric_dtypes and y.dtype in _numeric_dtypes)
                                 or dtypes == "integer" and x.dtype in _integer_dtypes and y.dtype in _integer_dtypes
-                                or dtypes == "integer_or_boolean" and (x.dtype in _integer_dtypes and y.dtype in _integer_dtypes
+                                or dtypes == "integer or boolean" and (x.dtype in _integer_dtypes and y.dtype in _integer_dtypes
                                                                        or x.dtype in _boolean_dtypes and y.dtype in _boolean_dtypes)
                                 or dtypes == "boolean" and x.dtype in _boolean_dtypes and y.dtype in _boolean_dtypes
-                                or dtypes == "floating" and x.dtype in _floating_dtypes and y.dtype in _floating_dtypes
+                                or dtypes == "floating-point" and x.dtype in _floating_dtypes and y.dtype in _floating_dtypes
                             ):
                                 getattr(x, _op)(y)
                             else:
@@ -214,7 +285,7 @@ def test_operators():
 
     unary_op_dtypes = {
         "__abs__": "numeric",
-        "__invert__": "integer_or_boolean",
+        "__invert__": "integer or boolean",
         "__neg__": "numeric",
         "__pos__": "numeric",
     }
@@ -223,7 +294,7 @@ def test_operators():
             if (
                 dtypes == "numeric"
                 and a.dtype in _numeric_dtypes
-                or dtypes == "integer_or_boolean"
+                or dtypes == "integer or boolean"
                 and a.dtype in _integer_or_boolean_dtypes
             ):
                 # Only test for no error
@@ -438,10 +509,10 @@ def test_array_keys_use_private_array():
 def test_array_namespace():
     a = ones((3, 3))
     assert a.__array_namespace__() == array_api_strict
-    assert array_api_strict.__array_api_version__ == "2023.12"
+    assert array_api_strict.__array_api_version__ == "2024.12"
 
     assert a.__array_namespace__(api_version=None) is array_api_strict
-    assert array_api_strict.__array_api_version__ == "2023.12"
+    assert array_api_strict.__array_api_version__ == "2024.12"
 
     assert a.__array_namespace__(api_version="2022.12") is array_api_strict
     assert array_api_strict.__array_api_version__ == "2022.12"
@@ -454,11 +525,12 @@ def test_array_namespace():
     assert array_api_strict.__array_api_version__ == "2021.12"
 
     with pytest.warns(UserWarning):
-        assert a.__array_namespace__(api_version="2024.12") is array_api_strict
-    assert array_api_strict.__array_api_version__ == "2024.12"
+        assert a.__array_namespace__(api_version="2025.12") is array_api_strict
+    assert array_api_strict.__array_api_version__ == "2025.12"
+
 
     pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2021.11"))
-    pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2025.12"))
+    pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2026.12"))
 
 def test_iter():
     pytest.raises(TypeError, lambda: iter(asarray(3)))

array_api_strict/tests/test_creation_functions.py

@@ -236,3 +236,10 @@ def from_dlpack_2023_12(api_version):
     pytest.raises(exception, lambda: from_dlpack(capsule, copy=False))
     pytest.raises(exception, lambda: from_dlpack(capsule, copy=True))
     pytest.raises(exception, lambda: from_dlpack(capsule, copy=None))
+
+
+def test_from_dlpack_default_device():
+    x = asarray([1, 2, 3])
+    y = from_dlpack(x)
+    z = from_dlpack(np.asarray([1, 2, 3]))
+    assert x.device == y.device == z.device == CPU_DEVICE

array_api_strict/tests/test_data_type_functions.py

@@ -6,9 +6,9 @@ from numpy.testing import assert_raises
 import numpy as np
 
 from .._creation_functions import asarray
-from .._data_type_functions import astype, can_cast, isdtype
+from .._data_type_functions import astype, can_cast, isdtype, result_type
 from .._dtypes import (
-    bool, int8, int16, uint8, float64,
+    bool, int8, int16, uint8, float64, int64
 )
 from .._flags import set_array_api_strict_flags
 
@@ -31,15 +31,17 @@ def test_can_cast(from_, to, expected):
 def test_isdtype_strictness():
     assert_raises(TypeError, lambda: isdtype(float64, 64))
     assert_raises(ValueError, lambda: isdtype(float64, 'f8'))
-
     assert_raises(TypeError, lambda: isdtype(float64, (('integral',),)))
+    assert_raises(TypeError, lambda: isdtype(float64, None))
+    assert_raises(TypeError, lambda: isdtype(np.float64, float64))
+    assert_raises(TypeError, lambda: isdtype(asarray(1.0), float64))
+
     with assert_raises(TypeError), warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         isdtype(float64, np.object_)
         assert len(w) == 1
         assert issubclass(w[-1].category, UserWarning)
 
-    assert_raises(TypeError, lambda: isdtype(float64, None))
     with assert_raises(TypeError), warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         isdtype(float64, np.float64)
@@ -68,3 +70,21 @@ def astype_device(api_version):
     else:
         pytest.raises(TypeError, lambda: astype(a, int8, device=None))
         pytest.raises(TypeError, lambda: astype(a, int8, device=a.device))
+
+
+@pytest.mark.parametrize("api_version", ['2023.12', '2024.12'])
+def test_result_type_py_scalars(api_version):
+    if api_version <= '2023.12':
+        set_array_api_strict_flags(api_version=api_version)
+
+        with pytest.raises(TypeError):
+            result_type(int16, 3)
+    else:
+        set_array_api_strict_flags(api_version=api_version)
+
+        assert result_type(int8, 3) == int8
+        assert result_type(uint8, 3) == uint8
+        assert result_type(float64, 3) == float64
+
+        with pytest.raises(TypeError):
+            result_type(int64, True)

array_api_strict/tests/test_elementwise_functions.py

@@ -1,8 +1,8 @@
 from inspect import signature, getmodule
 
-from numpy.testing import assert_raises
+from pytest import raises as assert_raises
+from numpy.testing import suppress_warnings
 
-import pytest
 
 from .. import asarray, _elementwise_functions
 from .._elementwise_functions import bitwise_left_shift, bitwise_right_shift
@@ -19,6 +19,8 @@ from .._dtypes import (
 )
 from .._flags import set_array_api_strict_flags
 
+from .test_array_object import _check_op_array_scalar, BIG_INT
+
 import array_api_strict
 
 
@@ -49,7 +51,7 @@ elementwise_function_input_types = {
     "bitwise_xor": "integer or boolean",
     "ceil": "real numeric",
     "clip": "real numeric",
-    "conj": "complex floating-point",
+    "conj": "numeric",
     "copysign": "real floating-point",
     "cos": "floating-point",
     "cosh": "floating-point",
@@ -85,7 +87,7 @@ elementwise_function_input_types = {
     "not_equal": "all",
     "positive": "numeric",
     "pow": "numeric",
-    "real": "complex floating-point",
+    "real": "numeric",
     "reciprocal": "floating-point",
     "remainder": "real numeric",
     "round": "numeric",
@@ -120,6 +122,7 @@ def test_missing_functions():
     # Ensure the above dictionary is complete.
     import array_api_strict._elementwise_functions as mod
     mod_funcs = [n for n in dir(mod) if getmodule(getattr(mod, n)) is mod]
+    mod_funcs = [n for n in mod_funcs if not n.startswith("_")]
     assert set(mod_funcs) == set(elementwise_function_input_types)
 
 
@@ -130,8 +133,7 @@ def test_function_device_persists():
             yield asarray(1., dtype=d)
 
     # Use the latest version of the standard so all functions are included
-    with pytest.warns(UserWarning):
-        set_array_api_strict_flags(api_version="2024.12")
+    set_array_api_strict_flags(api_version="2024.12")
 
     for func_name, types in elementwise_function_input_types.items():
         dtypes = _dtype_categories[types]
@@ -167,8 +169,7 @@ def test_function_types():
             yield asarray(1.0, dtype=d)
 
     # Use the latest version of the standard so all functions are included
-    with pytest.warns(UserWarning):
-        set_array_api_strict_flags(api_version="2024.12")
+    set_array_api_strict_flags(api_version="2024.12")
 
     for x in _array_vals():
         for func_name, types in elementwise_function_input_types.items():
@@ -202,3 +203,60 @@ def test_bitwise_shift_error():
     assert_raises(
         ValueError, lambda: bitwise_right_shift(asarray([1, 1]), asarray([1, -1]))
     )
+
+
+
+def test_scalars():
+    # mirror test_array_object.py::test_operators()
+    #
+    # Also check that binary functions accept (array, scalar) and (scalar, array)
+    # arguments, and reject (scalar, scalar) arguments.
+
+    # Use the latest version of the standard so that scalars are actually allowed
+    set_array_api_strict_flags(api_version="2024.12")
+
+    def _array_vals():
+        for d in _integer_dtypes:
+            yield asarray(1, dtype=d)
+        for d in _boolean_dtypes:
+            yield asarray(False, dtype=d)
+        for d in _floating_dtypes:
+            yield asarray(1.0, dtype=d)
+
+
+    for func_name, dtypes in elementwise_function_input_types.items():
+        func = getattr(_elementwise_functions, func_name)
+        if nargs(func) != 2:
+            continue
+
+        nocomplex = [
+            'atan2', 'copysign', 'floor_divide', 'hypot', 'logaddexp',  'nextafter',
+            'remainder',
+            'greater', 'less', 'greater_equal', 'less_equal', 'maximum', 'minimum',
+        ]
+
+        for s in [1, 1.0, 1j, BIG_INT, False]:
+            for a in _array_vals():
+                for func1 in [lambda s: func(a, s), lambda s: func(s, a)]:
+
+                    if func_name in nocomplex and type(s) == complex:
+                        allowed = False
+                    else:
+                        allowed = _check_op_array_scalar(dtypes, a, s, func1, func_name)
+
+                    # only check `func(array, scalar) == `func(array, array)` if
+                    # the former is legal under the promotion rules
+                    if allowed:
+                        conv_scalar = a._promote_scalar(s)
+
+                        with suppress_warnings() as sup:
+                            # ignore warnings from pow(BIG_INT)
+                            sup.filter(RuntimeWarning,
+                                       "invalid value encountered in power")
+                            assert func(s, a) == func(conv_scalar, a)
+                            assert func(a, s) == func(a, conv_scalar)
+
+                        with assert_raises(TypeError):
+                            func(s, s)
+
+

array_api_strict/tests/test_flags.py

@@ -19,7 +19,7 @@ import pytest
 def test_flag_defaults():
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2023.12',
+        'api_version': '2024.12',
         'boolean_indexing': True,
         'data_dependent_shapes': True,
         'enabled_extensions': ('linalg', 'fft'),
@@ -36,7 +36,7 @@ def test_reset_flags():
     reset_array_api_strict_flags()
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2023.12',
+        'api_version': '2024.12',
         'boolean_indexing': True,
         'data_dependent_shapes': True,
         'enabled_extensions': ('linalg', 'fft'),
@@ -47,7 +47,7 @@ def test_setting_flags():
     set_array_api_strict_flags(data_dependent_shapes=False)
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2023.12',
+        'api_version': '2024.12',
         'boolean_indexing': True,
         'data_dependent_shapes': False,
         'enabled_extensions': ('linalg', 'fft'),
@@ -55,7 +55,7 @@ def test_setting_flags():
     set_array_api_strict_flags(enabled_extensions=('fft',))
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2023.12',
+        'api_version': '2024.12',
         'boolean_indexing': True,
         'data_dependent_shapes': False,
         'enabled_extensions': ('fft',),
@@ -98,15 +98,26 @@ def test_flags_api_version_2023_12():
     }
 
 def test_flags_api_version_2024_12():
-    # Make sure setting the version to 2024.12 issues a warning.
+    set_array_api_strict_flags(api_version='2024.12')
+    flags = get_array_api_strict_flags()
+    assert flags == {
+        'api_version': '2024.12',
+        'boolean_indexing': True,
+        'data_dependent_shapes': True,
+        'enabled_extensions': ('linalg', 'fft'),
+    }
+
+
+def test_flags_api_version_2025_12():
+    # Make sure setting the version to 2025.12 issues a warning.
     with pytest.warns(UserWarning) as record:
-        set_array_api_strict_flags(api_version='2024.12')
+        set_array_api_strict_flags(api_version='2025.12')
     assert len(record) == 1
-    assert '2024.12' in str(record[0].message)
+    assert '2025.12' in str(record[0].message)
     assert 'draft' in str(record[0].message)
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2024.12',
+        'api_version': '2025.12',
         'boolean_indexing': True,
         'data_dependent_shapes': True,
         'enabled_extensions': ('linalg', 'fft'),
@@ -125,9 +136,12 @@ def test_setting_flags_invalid():
 
 def test_api_version():
     # Test defaults
-    assert xp.__array_api_version__ == '2023.12'
+    assert xp.__array_api_version__ == '2024.12'
 
     # Test setting the version
+    set_array_api_strict_flags(api_version='2023.12')
+    assert xp.__array_api_version__ == '2023.12'
+
     set_array_api_strict_flags(api_version='2022.12')
     assert xp.__array_api_version__ == '2022.12'
 
@@ -307,14 +321,16 @@ api_version_2024_12_examples = {
     'reciprocal': lambda: xp.reciprocal(xp.asarray([2.])),
     'take_along_axis': lambda: xp.take_along_axis(xp.zeros((2, 3)),
                                                   xp.zeros((1, 4), dtype=xp.int64)),
+    'count_nonzero': lambda: xp.count_nonzero(xp.arange(3)),
+    'cumulative_prod': lambda: xp.cumulative_prod(xp.arange(1, 5)),
 }
 
 @pytest.mark.parametrize('func_name', api_version_2024_12_examples.keys())
 def test_api_version_2024_12(func_name):
     func = api_version_2024_12_examples[func_name]
 
-    # By default, these functions should error
-    pytest.raises(RuntimeError, func)
+    # By default, these functions should not error
+    func()
 
     # In 2022.12 and 2023.12, these functions should error
     set_array_api_strict_flags(api_version='2022.12')
@@ -322,11 +338,6 @@ def test_api_version_2024_12(func_name):
     set_array_api_strict_flags(api_version='2023.12')
     pytest.raises(RuntimeError, func)
 
-    # They should not error in 2024.12
-    with pytest.warns(UserWarning):
-        set_array_api_strict_flags(api_version='2024.12')
-    func()
-
     # Test the behavior gets updated properly
     set_array_api_strict_flags(api_version='2023.12')
     pytest.raises(RuntimeError, func)
@@ -433,9 +444,9 @@ def test_environment_variables():
         # ARRAY_API_STRICT_API_VERSION
         ('''\
 import array_api_strict as xp
-assert xp.__array_api_version__ == '2023.12'
+assert xp.__array_api_version__ == '2024.12'
 
-assert xp.get_array_api_strict_flags()['api_version'] == '2023.12'
+assert xp.get_array_api_strict_flags()['api_version'] == '2024.12'
 
 ''', {}),
         *[

array_api_strict/tests/test_manipulation_functions.py

@@ -11,7 +11,7 @@ from .._manipulation_functions import (
 
 
 def test_concat_errors():
-    assert_raises(TypeError, lambda: concat((1, 1), axis=None))
+    assert_raises((TypeError, ValueError), lambda: concat((1, 1), axis=None))
     assert_raises(TypeError, lambda: concat([asarray([1], dtype=int8),
                                              asarray([1], dtype=float64)]))
 

array_api_strict/tests/test_searching_functions.py

@@ -0,0 +1,24 @@
+import pytest
+
+import array_api_strict as xp
+
+from array_api_strict import ArrayAPIStrictFlags
+
+
+def test_where_with_scalars():
+    x = xp.asarray([1, 2, 3, 1])
+
+    # Versions up to and including 2023.12 don't support scalar arguments
+    with ArrayAPIStrictFlags(api_version='2023.12'):
+        with pytest.raises(AttributeError, match="object has no attribute 'dtype'"):
+            xp.where(x == 1, 42, 44)
+
+    # Versions after 2023.12 support scalar arguments
+    x_where = xp.where(x == 1, xp.asarray(42), 44)
+
+    expected = xp.asarray([42, 44, 44, 42])
+    assert xp.all(x_where == expected)
+
+    # The spec does not allow both x1 and x2 to be scalars
+    with pytest.raises(ValueError, match="One of"):
+        xp.where(x == 1, 42, 44)