code: def test_split_axes_with_zero():
      """
      See Also
      --------
      dask.array.tests.test_rechunk.test_intersect_chunks_with_zero
      """
      old = ((4, 4), (2,))
      new = ((4, 0, 0, 4), (1, 1))
      result = split_axes(old, new)
  
      expected = [
          [
              [Split(0, 0, slice(0, 4, None))],
              [
                  Split(1, 0, slice(0, 0, None)),
                  Split(2, 0, slice(0, 0, None)),
                  Split(3, 0, slice(0, 4, None)),
              ],
          ],
          [
              [
                  Split(0, 0, slice(0, 1, None)),
                  Split(1, 0, slice(1, 2, None)),
              ]
          ],
      ]
      assert result == expected
  
      old = ((4, 0, 0, 4), (1, 1))
      new = ((4, 4), (2,))
      result = split_axes(old, new)
  
      expected = [
          [
              [Split(0, 0, slice(0, 4, None))],
              [],
              [],
              [Split(1, 0, slice(0, 4, None))],
          ],
          [
              [Split(0, 0, slice(0, 1, None))],
              [Split(0, 1, slice(0, 1, None))],
          ],
      ]
      assert result == expected
  
      old = ((4, 4), (2,))
      new = ((2, 0, 0, 2, 4), (1, 1))
      result = split_axes(old, new)
      expected = [
          [
              [
                  Split(0, 0, slice(0, 2, None)),
                  Split(1, 0, slice(2, 2, None)),
                  Split(2, 0, slice(2, 2, None)),
                  Split(3, 0, slice(2, 4)),
              ],
              [Split(4, 0, slice(0, 4, None))],
          ],
          [
              [
                  Split(0, 0, slice(0, 1, None)),
                  Split(1, 0, slice(1, 2, None)),
              ]
          ],
      ]
      assert result == expected
  
      old = ((4, 4), (2,))
      new = ((0, 0, 4, 4), (1, 1))
      result = split_axes(old, new)
      expected = [
          [
              [
                  Split(0, 0, slice(0, 0, None)),
                  Split(1, 0, slice(0, 0, None)),
                  Split(2, 0, slice(0, 4, None)),
              ],
              [Split(3, 0, slice(0, 4, None))],
          ],
          [
              [
                  Split(0, 0, slice(0, 1, None)),
                  Split(1, 0, slice(1, 2, None)),
              ]
          ],
      ]
      assert result == expected
  
imports: from __future__ import annotations
  import asyncio
  import math
  import random
  import warnings
  import pytest
  from packaging.version import parse
  from concurrent.futures import ThreadPoolExecutor
  from tornado.ioloop import IOLoop
  import dask
  from dask.array.core import concatenate3
  from dask.array.rechunk import normalize_chunks, rechunk
  from dask.array.utils import assert_eq
  from dask.base import flatten
  from dask.utils import key_split
  from distributed import Event
  from distributed.protocol.utils_test import get_host_array
  from distributed.shuffle._core import ShuffleId
  from distributed.shuffle._limiter import ResourceLimiter
  from distributed.shuffle._rechunk import ArrayRechunkRun, ArrayRechunkSpec, Split, split_axes
  from distributed.shuffle.tests.utils import AbstractShuffleTestPool
  from distributed.utils_test import gen_cluster, gen_test
  from itertools import product
label_desc: Use image node_id 8 for calling a global function with example usage: test_split_axes_with_zero() without return types