Skip extension tests if the respective extension is not found or is passed via --disable-extensions - #29

xp = <module 'array_api_tests._array_module' from '/Users/aaronmeurer/Documents/array-api-tests/array_api_tests/_array_module.py'>, dtype = dtype('bool')
shape = <function accept.<locals>.matrix_shapes at 0x113aef8b0>

    def _arrays(
        xp: Any,
        dtype: Union[DataType, str, st.SearchStrategy[DataType], st.SearchStrategy[str]],
        shape: Union[int, Shape, st.SearchStrategy[Shape]],
        *,
        elements: Optional[st.SearchStrategy] = None,
        fill: Optional[st.SearchStrategy[Any]] = None,
        unique: bool = False,
    ) -> st.SearchStrategy:
        """Returns a strategy for :xp-ref:`arrays <array_object.html>`.

        * ``dtype`` may be a :xp-ref:`valid dtype <data_types.html>` object or name,
          or a strategy that generates such values.
        * ``shape`` may be an integer >= 0, a tuple of such integers, or a strategy
          that generates such values.
        * ``elements`` is a strategy for values to put in the array. If ``None``
          then a suitable value will be inferred based on the dtype, which may give
          any legal value (including e.g. NaN for floats). If a mapping, it will be
          passed as ``**kwargs`` to :func:`from_dtype()` when inferring based on the dtype.
        * ``fill`` is a strategy that may be used to generate a single background
          value for the array. If ``None``, a suitable default will be inferred
          based on the other arguments. If set to
          :func:`~hypothesis.strategies.nothing` then filling behaviour will be
          disabled entirely and every element will be generated independently.
        * ``unique`` specifies if the elements of the array should all be distinct
          from one another; if fill is also set, the only valid values for fill to
          return are NaN values.  Note that Hypothesis always allows multiple NaN
          values, even though `xp.unique() might only return a single NaN.
          <https://data-apis.org/array-api/latest/API_specification/set_functions.html#objects-in-api>`__

        Arrays of specified ``dtype`` and ``shape`` are generated for example
        like this:

        .. code-block:: pycon

          >>> from numpy import array_api as xp
          >>> xps.arrays(xp, xp.int8, (2, 3)).example()
          Array([[-8,  6,  3],
                 [-6,  4,  6]], dtype=int8)

        Specifying element boundaries by a :obj:`python:dict` of the kwargs to pass
        to :func:`from_dtype` will ensure ``dtype`` bounds will be respected.

        .. code-block:: pycon

          >>> xps.arrays(xp, xp.int8, 3, elements={"min_value": 10}).example()
          Array([125, 13, 79], dtype=int8)

        Refer to :doc:`What you can generate and how <data>` for passing
        your own elements strategy.

        .. code-block:: pycon

          >>> xps.arrays(xp, xp.float32, 3, elements=floats(0, 1, width=32)).example()
          Array([ 0.88974794,  0.77387938,  0.1977879 ], dtype=float32)

        Array values are generated in two parts:

        1. A single value is drawn from the fill strategy and is used to create a
           filled array.
        2. Some subset of the coordinates of the array are populated with a value
           drawn from the elements strategy (or its inferred form).

        You can set ``fill`` to :func:`~hypothesis.strategies.nothing` if you want
        to disable this behaviour and draw a value for every element.

        By default ``arrays`` will attempt to infer the correct fill behaviour: if
        ``unique`` is also ``True``, no filling will occur. Otherwise, if it looks
        safe to reuse the values of elements across multiple coordinates (this will
        be the case for any inferred strategy, and for most of the builtins, but is
        not the case for mutable values or strategies built with flatmap, map,
        composite, etc.) then it will use the elements strategy as the fill, else it
        will default to having no fill.

        Having a fill helps Hypothesis craft high quality examples, but its
        main importance is when the array generated is large: Hypothesis is
        primarily designed around testing small examples. If you have arrays with
        hundreds or more elements, having a fill value is essential if you want
        your tests to run in reasonable time.
        """
        check_xp_attributes(
            xp, ["asarray", "zeros", "full", "all", "isnan", "isfinite", "reshape"]
        )

        if isinstance(dtype, st.SearchStrategy):
            return dtype.flatmap(
                lambda d: _arrays(xp, d, shape, elements=elements, fill=fill, unique=unique)
            )
        if isinstance(shape, st.SearchStrategy):
            return shape.flatmap(
                lambda s: _arrays(xp, dtype, s, elements=elements, fill=fill, unique=unique)
            )

        if isinstance(dtype, str):
            dtype = dtype_from_name(xp, dtype)

        if isinstance(shape, int):
            shape = (shape,)
        check_argument(
>           all(isinstance(x, int) and x >= 0 for x in shape),
            f"shape={shape!r}, but all dimensions must be non-negative integers.",
        )
E       TypeError: 'function' object is not iterable

../../anaconda3/envs/array-apis/lib/python3.9/site-packages/hypothesis/extra/array_api.py:482: TypeError