code: def setUp(self):
      self.correspondence_dict = {
          "Double": {
              "python_type": float,
              "cpp_type": "double",
          },
          "Float": {
              "python_type": np.float32,
              "cpp_type": "float",
          },
          "Int": {
              "python_type": np.int32,
              "cpp_type": "std::int32_t",
          },
          "UInt": {
              "python_type": np.uint32,
              "cpp_type": "std::uint32_t",
          },
          "Short": {
              "python_type": np.int16,
              "cpp_type": "std::int16_t",
          },
          "UShort": {
              "python_type": np.uint16,
              "cpp_type": "std::uint16_t",
          },
          "Long": {
              "python_type": np.int64,
              "cpp_type": "std::int64_t",
          },
          "ULong": {
              "python_type": np.uint64,
              "cpp_type": "std::uint64_t",
          },
      }
  
      for array_type, info in self.correspondence_dict.items():
          # fixed number of the correct type
          info["number"] = 148  # info['python_type'](np.exp(5))
  
          # The dense array of the corresponding type
          python_array = np.array([1, 2, 5, 0, 4, 1]).astype(
              info["python_type"]
          )
  
          # The dense array 2D of the corresponding type
          python_array_2d = np.array([[1, 2, 5], [0, 4, 1]]).astype(
              info["python_type"]
          )
  
          # The list of dense array of the corresponding type
          python_array_list_1d = [
              np.array([1, 2, 5]).astype(info["python_type"]),
              np.array([1, 2, 9]).astype(info["python_type"]),
              np.array([0, 4]).astype(info["python_type"]),
          ]
  
          python_array2d_list_1d = [
              np.array([[1, 2, 5], [0, 4, 1]]).astype(
                  info["python_type"]
              ),
              np.array([[1, 2, 9], [1, 2, 5], [0, 4, 1]]).astype(
                  info["python_type"]
              ),
              np.array([[0]]).astype(info["python_type"]),
          ]
  
          python_array_list_2d = [
              [np.array([1, 2, 5]).astype(info["python_type"])],
              [
                  np.array([1, 2, 9, 5]).astype(info["python_type"]),
                  np.array([0, 4, 1]).astype(info["python_type"]),
              ],
              [],
          ]
  
          python_array2d_list_2d = [
              [
                  np.array([[1, 2, 5], [0, 4, 1]]).astype(
                      info["python_type"]
                  ),
              ],
              [
                  np.array([[1, 2, 9], [1, 2, 5], [0, 4, 1]]).astype(
                      info["python_type"]
                  ),
                  np.array([[0]]).astype(info["python_type"]),
              ],
              [],
          ]
  
          # The sparse array of the corresponding type
          python_sparse_array = csr_matrix(
              (
                  np.array([1.5, 2, 3, 1]),
                  np.array([3, 5, 7, 9]),
                  np.array([0, 4]),
              )
          ).astype(info["python_type"])
  
          # The sparse array 2D of the corresponding type
          python_sparse_array_2d = csr_matrix(
              (
                  np.array([1.5, 2, 3, 1]),
                  np.array([3, 5, 7, 4]),
                  np.array([0, 3, 4]),
              )
          ).astype(info["python_type"])
  
          python_sparse_array_list_1d = [
              csr_matrix(
                  (
                      np.array([1.5, 2, 3, 1]),
                      np.array([3, 5, 7, 9]),
                      np.array([0, 4]),
                  )
              ).astype(info["python_type"]),
              csr_matrix(
                  (
                      np.array([1.5, 2, 3]),
                      np.array([3, 5, 11]),
                      np.array([0, 3]),
                  )
              ).astype(info["python_type"]),
              csr_matrix(
                  (
                      np.array([1.5, 2, 3, 1, 2]),
                      np.array([3, 5, 7, 4, 1]),
                      np.array([0, 5]),
                  )
              ).astype(info["python_type"]),
          ]
  
          # TODO: add mixed list
  
          python_sparse_array2d_list_1d = [
              csr_matrix(
                  (
                      np.array([1.5, 2, 3, 1]),
                      np.array([3, 5, 7, 9]),
                      np.array([0, 3, 4]),
                  )
              ).astype(info["python_type"]),
              csr_matrix(
                  (
                      np.array([1.5, 2, 3]),
                      np.array([3, 5, 11]),
                      np.array([0, 1, 3]),
                  )
              ).astype(info["python_type"]),
              csr_matrix(
                  (
                      np.array([1.5, 2, 3, 1, 2]),
                      np.array([3, 5, 7, 4, 1]),
                      np.array([0, 2, 3, 5]),
                  )
              ).astype(info["python_type"]),
          ]
  
          python_sparse_array_list_2d = [
              [
                  csr_matrix(
                      (
                          np.array([1.5, 2, 3, 1]),
                          np.array([3, 5, 7, 9]),
                          np.array([0, 4]),
                      )
                  ).astype(info["python_type"])
              ],
              [
                  csr_matrix(
                      (
                          np.array([1.5, 2, 3]),
                          np.array([3, 5, 11]),
                          np.array([0, 3]),
                      )
                  ).astype(info["python_type"]),
                  csr_matrix(
                      (
                          np.array([1.5, 2, 3, 1, 2]),
                          np.array([3, 5, 7, 4, 1]),
                          np.array([0, 5]),
                      )
                  ).astype(info["python_type"]),
              ],
              [],
          ]
  
          python_sparse_array2d_list_2d = [
              [
                  csr_matrix(
                      (
                          np.array([1.5, 2, 3, 1]),
                          np.array([3, 5, 7, 9]),
                          np.array([0, 3, 4]),
                      )
                  ).astype(info["python_type"])
              ],
              [
                  csr_matrix(
                      (
                          np.array([1.5, 2, 3]),
                          np.array([3, 5, 11]),
                          np.array([0, 1, 3]),
                      )
                  ).astype(info["python_type"]),
                  csr_matrix(
                      (
                          np.array([1.5, 2, 3, 1, 2]),
                          np.array([3, 5, 7, 4, 1]),
                          np.array([0, 2, 3, 5]),
                      )
                  ).astype(info["python_type"]),
              ],
              [],
          ]
  
          info["python_array"] = python_array
          info["python_array_2d"] = python_array_2d
          info["python_array_list_1d"] = python_array_list_1d
          info["python_array2d_list_1d"] = python_array2d_list_1d
          info["python_array2d_list_2d"] = python_array2d_list_2d
          info["python_array_list_2d"] = python_array_list_2d
          info["python_sparse_array"] = python_sparse_array
          info["python_sparse_array_2d"] = python_sparse_array_2d
          info[
              "python_sparse_array_list_1d"
          ] = python_sparse_array_list_1d
          info[
              "python_sparse_array2d_list_1d"
          ] = python_sparse_array2d_list_1d
          info[
              "python_sparse_array_list_2d"
          ] = python_sparse_array_list_2d
          info[
              "python_sparse_array2d_list_2d"
          ] = python_sparse_array2d_list_2d
  
          # corresponding test functions
          # for typemap in
          info["typemap_in_array"] = getattr(
              test, "test_typemap_in_Array%s" % array_type
          )
          info["typemap_in_array_2d"] = getattr(
              test, "test_typemap_in_Array%s2d" % array_type
          )
          info["typemap_in_array_list_1d"] = getattr(
              test, "test_typemap_in_Array%sList1D" % array_type
          )
          info["typemap_in_array_list_2d"] = getattr(
              test, "test_typemap_in_Array%sList2D" % array_type
          )
  
          info["typemap_in_sparse_array"] = getattr(
              test, "test_typemap_in_SparseArray%s" % array_type
          )
          info["typemap_in_sparse_array_2d"] = getattr(
              test, "test_typemap_in_SparseArray%s2d" % array_type
          )
  
          info["typemap_in_sarray_ptr"] = getattr(
              test, "test_typemap_in_SArray%sPtr" % array_type
          )
          info["typemap_in_sarray_ptr_2d"] = getattr(
              test, "test_typemap_in_SArray%s2dPtr" % array_type
          )
          info["typemap_in_sarray_ptr_list_1d"] = getattr(
              test, "test_typemap_in_SArray%sPtrList1D" % array_type
          )
          info["typemap_in_sarray_ptr_list_2d"] = getattr(
              test, "test_typemap_in_SArray%sPtrList2D" % array_type
          )
          info["typemap_in_sarray2d_ptr_list_1d"] = getattr(
              test, "test_typemap_in_SArray%s2dPtrList1D" % array_type
          )
          info["typemap_in_sarray2d_ptr_list_2d"] = getattr(
              test, "test_typemap_in_SArray%s2dPtrList2D" % array_type
          )
  
          info["typemap_in_varray_ptr"] = getattr(
              test, "test_typemap_in_VArray%sPtr" % array_type
          )
          info["typemap_in_varray_ptr_list_1d"] = getattr(
              test, "test_typemap_in_VArray%sPtrList1D" % array_type
          )
          info["typemap_in_varray_ptr_list_2d"] = getattr(
              test, "test_typemap_in_VArray%sPtrList2D" % array_type
          )
  
          info["typemap_in_base_array"] = getattr(
              test, "test_typemap_in_BaseArray%s" % array_type
          )
          info["typemap_in_base_array_2d"] = getattr(
              test, "test_typemap_in_BaseArray%s2d" % array_type
          )
  
          info["typemap_in_sparse_array_ptr"] = getattr(
              test, "test_typemap_in_SSparseArray%sPtr" % array_type
          )
          info["typemap_in_sparse_array_2d_ptr"] = getattr(
              test, "test_typemap_in_SSparseArray%s2dPtr" % array_type
          )
  
          info["typemap_in_base_array_ptr"] = getattr(
              test, "test_typemap_in_SBaseArray%sPtr" % array_type
          )
          info["typemap_in_base_array_2d_ptr"] = getattr(
              test, "test_typemap_in_SBaseArray%s2dPtr" % array_type
          )
          info["typemap_in_base_array_list_1d"] = getattr(
              test, "test_typemap_in_BaseArray%sList1D" % array_type
          )
          info["typemap_in_base_array_list_2d"] = getattr(
              test, "test_typemap_in_BaseArray%sList2D" % array_type
          )
          info["typemap_in_base_array2d_list_1d"] = getattr(
              test, "test_typemap_in_BaseArray%s2dList1D" % array_type
          )
          info["typemap_in_base_array2d_list_2d"] = getattr(
              test, "test_typemap_in_BaseArray%s2dList2D" % array_type
          )
  
          info["typemap_in_base_array_ptr_list_1d"] = getattr(
              test, "test_typemap_in_SBaseArray%sPtrList1D" % array_type
          )
          info["typemap_in_base_array_ptr_list_2d"] = getattr(
              test, "test_typemap_in_SBaseArray%sPtrList2D" % array_type
          )
          info["typemap_in_base_array2d_ptr_list_1d"] = getattr(
              test,
              "test_typemap_in_SBaseArray%s2dPtrList1D" % array_type,
          )
          info["typemap_in_base_array2d_ptr_list_2d"] = getattr(
              test,
              "test_typemap_in_SBaseArray%s2dPtrList2D" % array_type,
          )
  
          # Functions that are not overloaded to test error messages
          info["typemap_in_array_not_ol"] = getattr(
              test, "test_typemap_in_not_ol_Array%s" % array_type
          )
          info["typemap_in_array_2d_not_ol"] = getattr(
              test, "test_typemap_in_not_ol_Array%s2d" % array_type
          )
          info["typemap_in_sparse_array_not_ol"] = getattr(
              test, "test_typemap_in_not_ol_SparseArray%s" % array_type
          )
          info["typemap_in_base_array_not_ol"] = getattr(
              test, "test_typemap_in_not_ol_BaseArray%s" % array_type
          )
  
          info["typemap_in_array_list_1d_not_ol"] = getattr(
              test, "test_typemap_in_not_ol_Array%sList1D" % array_type
          )
          info["typemap_in_array_list_2d_not_ol"] = getattr(
              test, "test_typemap_in_not_ol_Array%sList2D" % array_type
          )
  
          # for typemap out
          info["typemap_out_sarray_ptr"] = getattr(
              test, "test_typemap_out_SArray%sPtr" % array_type
          )
          info["typemap_out_sarray_ptr_list_1d"] = getattr(
              test, "test_typemap_out_SArray%sPtrList1D" % array_type
          )
          info["typemap_out_sarray_ptr_list_2d"] = getattr(
              test, "test_typemap_out_SArray%sPtrList2D" % array_type
          )
          info["typemap_out_sarray_2d_ptr"] = getattr(
              test, "test_typemap_out_SArray%s2dPtr" % array_type
          )
  
imports: import unittest
  import numpy
  from scipy.sparse import csr_matrix
  from tick.array_test.build import array_test
label_desc: Use image node_id 1 for calling the Test obj's underlying member method code with example usage: obj.setUp() without return types