code: def test_check_array(setup):
      # accept_sparse == False
      # raise error on sparse inputs
      X = [[1, 2], [3, 4]]
      X_csr = sp.csr_matrix(X)
      with pytest.raises(TypeError):
          check_array(X_csr)
      X_csr = mt.tensor(sp.csr_matrix(X))
      with pytest.raises(TypeError):
          check_array(X_csr)
      # ensure_2d=False
      X_array = check_array([0, 1, 2], ensure_2d=False)
      assert X_array.ndim == 1
      # ensure_2d=True with 1d array
      assert_raise_message(
          ValueError,
          "Expected 2D array, got 1D array instead",
          check_array,
          [0, 1, 2],
          ensure_2d=True,
      )
      assert_raise_message(
          ValueError,
          "Expected 2D array, got 1D array instead",
          check_array,
          mt.tensor([0, 1, 2]),
          ensure_2d=True,
      )
      # ensure_2d=True with scalar array
      assert_raise_message(
          ValueError,
          "Expected 2D array, got scalar array instead",
          check_array,
          10,
          ensure_2d=True,
      )
      # don't allow ndim > 3
      X_ndim = mt.arange(8).reshape(2, 2, 2)
      with pytest.raises(ValueError):
          check_array(X_ndim)
      check_array(X_ndim, allow_nd=True)  # doesn't raise
  
      # dtype and order enforcement.
      X_C = mt.arange(4).reshape(2, 2).copy("C")
      X_F = X_C.copy("F")
      X_int = X_C.astype(mt.int)
      X_float = X_C.astype(mt.float)
      Xs = [X_C, X_F, X_int, X_float]
      dtypes = [
          mt.int32,
          mt.int,
          mt.float,
          mt.float32,
          None,
          mt.bool,
          object,
      ]
      orders = ["C", "F", None]
      copy_flags = [True, False]
  
      for X, dtype, order, copy in product(
          Xs, dtypes, orders, copy_flags
      ):
          X_checked = check_array(
              X,
              dtype=dtype,
              order=order,
              copy=copy,
              force_all_finite=False,
          )
          if dtype is not None:
              assert X_checked.dtype == dtype
          else:
              assert X_checked.dtype == X.dtype
          if order == "C":
              assert X_checked.flags["C_CONTIGUOUS"]
              assert not X_checked.flags["F_CONTIGUOUS"]
          elif order == "F":
              assert X_checked.flags["F_CONTIGUOUS"]
              assert not X_checked.flags["C_CONTIGUOUS"]
          if copy:
              assert X is not X_checked
          else:
              # doesn't copy if it was already good
              if (
                  X.dtype == X_checked.dtype
                  and X_checked.flags["C_CONTIGUOUS"]
                  == X.flags["C_CONTIGUOUS"]
                  and X_checked.flags["F_CONTIGUOUS"]
                  == X.flags["F_CONTIGUOUS"]
              ):
                  assert X is X_checked
  
      # other input formats
      # convert lists to arrays
      X_dense = check_array([[1, 2], [3, 4]])
      assert isinstance(X_dense, Tensor)
      # raise on too deep lists
      with pytest.raises(ValueError):
          check_array(X_ndim.to_numpy().tolist())
      check_array(
          X_ndim.to_numpy().tolist(), allow_nd=True
      )  # doesn't raise
      # convert weird stuff to arrays
      X_no_array = _NotAnArray(X_dense.to_numpy())
      result = check_array(X_no_array)
      assert isinstance(result, Tensor)
  
      # deprecation warning if string-like array with dtype="numeric"
      expected_warn_regex = (
          r"converted to decimal numbers if dtype='numeric'"
      )
      X_str = [["11", "12"], ["13", "xx"]]
      for X in [
          X_str,
          mt.array(X_str, dtype="U"),
          mt.array(X_str, dtype="S"),
      ]:
          with pytest.warns(FutureWarning, match=expected_warn_regex):
              check_array(X, dtype="numeric")
  
      # deprecation warning if byte-like array with dtype="numeric"
      X_bytes = [[b"a", b"b"], [b"c", b"d"]]
      for X in [X_bytes, mt.array(X_bytes, dtype="V1")]:
          with pytest.warns(FutureWarning, match=expected_warn_regex):
              check_array(X, dtype="numeric")
  
      # test finite
      X = [[1.0, np.nan], [2.0, 3.0]]
      with pytest.raises(ValueError):
          _ = check_array(X).execute()
  
imports: from itertools import product
  import numpy
  import pytest
  import scipy.sparse
  from sklearn.utils.estimator_checks import _NotAnArray
  from sklearn.utils._mocking import MockDataFrame
  from sklearn.utils._testing import assert_raise_message, assert_raises_regex
  from ....None import tensor
  from ....None import dataframe
  from ....tensor.core import Tensor
  from ..validation import check_array, check_consistent_length
label_desc: Use image node_id 2 for calling a global function with example usage: test_check_array(setup) without return types