code: def test_combine_transforms(self, input_shape, funcs):
      for device in (
          ["cpu", "cuda"] if torch.cuda.is_available() else ["cpu"]
      ):
          for seed in [10, 100, 1000, 10000]:
              set_determinism(seed=seed)
              _funcs = []
              for _func, _params in funcs:
                  _funcs.append(_func(**_params))
              is_map = isinstance(_funcs[0], MapTransform)
              chns, sp_size = input_shape[0], input_shape[1:]
              imgs = []
              for _ in range(chns):
                  if len(sp_size) == 2:
                      imgs.append(
                          create_test_image_2d(sp_size[0], sp_size[1])[
                              0
                          ]
                      )
                  else:
                      imgs.append(
                          create_test_image_3d(
                              sp_size[0], sp_size[1], sp_size[2]
                          )[0]
                      )
              data = np.stack(imgs).astype(float)
              im = MetaTensor(
                  data,
                  meta={"a": "b", "affine": np.eye(len(input_shape))},
              ).to(device)
              input_data = {"img": im} if is_map else im
              # non lazy
              non_lazy_result = input_data
              for _func in _funcs:
                  if isinstance(_func, mt.Randomizable):
                      _func.set_random_state(seed=seed)
                  non_lazy_result = _func(non_lazy_result)
              expected = (
                  non_lazy_result["img"] if is_map else non_lazy_result
              )
  
              # lazy
              pending_result = input_data
              for _func in _funcs:
                  _func.lazy = True
                  if isinstance(_func, mt.Randomizable):
                      _func.set_random_state(seed=seed)
                  pending_result = _func(pending_result)
              pending_result = (
                  pending_result["img"] if is_map else pending_result
              )
  
              assert_allclose(
                  pending_result.peek_pending_affine(),
                  expected.affine,
                  atol=1e-7,
              )
              assert_allclose(
                  pending_result.peek_pending_shape(),
                  expected.shape[1:4],
              )
  
              # test final result
              init_param = funcs[-1][1]
              call_param = {}
              apply_param = get_apply_param(init_param, call_param)
              result = apply_pending(
                  pending_result, overrides=apply_param
              )[0]
  
              match_ratio = np.sum(
                  np.isclose(result.array, expected.array, atol=5e-1)
              ) / np.prod(result.shape)
              self.assertGreater(match_ratio, 0.5)
  
file_path: MONAI/tests/test_spatial_combine_transforms.py
imports: from __future__ import annotations
  import unittest
  import numpy
  import torch
  from parameterized import parameterized
  import monai.transforms
  from monai.data import create_test_image_2d, create_test_image_3d
  from monai.data.meta_tensor import MetaTensor
  from monai.transforms.lazy.functional import apply_pending
  from monai.transforms.transform import MapTransform
  from monai.utils import set_determinism
  from tests.lazy_transforms_utils import get_apply_param
  from tests.utils import assert_allclose
label_desc: Use image node_id 1 for calling the CombineLazyTest obj's underlying member method code with example usage: obj.test_combine_transforms(input_shape, funcs) without return types