code: def _test_flat_structure_combinations():
      cases = [
          (
              "Tensor",
              lambda: constant_op.constant(37.0),
              lambda: tensor.TensorSpec,
              lambda: [dtypes.float32],
              lambda: [[]],
          ),
          (
              "TensorArray",
              lambda: tensor_array_ops.TensorArray(
                  dtype=dtypes.float32, element_shape=(3,), size=0
              ),
              lambda: tensor_array_ops.TensorArraySpec,
              lambda: [dtypes.variant],
              lambda: [[]],
          ),
          (
              "SparseTensor",
              lambda: sparse_tensor.SparseTensor(
                  indices=[[3, 4]], values=[-1], dense_shape=[4, 5]
              ),
              lambda: sparse_tensor.SparseTensorSpec,
              lambda: [dtypes.variant],
              lambda: [None],
          ),
          (
              "RaggedTensor",
              lambda: ragged_factory_ops.constant([[1, 2], [], [4]]),
              lambda: ragged_tensor.RaggedTensorSpec,
              lambda: [dtypes.variant],
              lambda: [None],
          ),
          (
              "Nested_0",
              lambda: (
                  constant_op.constant(37.0),
                  constant_op.constant([1, 2, 3]),
              ),
              lambda: tuple,
              lambda: [dtypes.float32, dtypes.int32],
              lambda: [[], [3]],
          ),
          (
              "Nested_1",
              lambda: {
                  "a": constant_op.constant(37.0),
                  "b": constant_op.constant([1, 2, 3]),
              },
              lambda: dict,
              lambda: [dtypes.float32, dtypes.int32],
              lambda: [[], [3]],
          ),
          (
              "Nested_2",
              lambda: {
                  "a": constant_op.constant(37.0),
                  "b": (
                      sparse_tensor.SparseTensor(
                          indices=[[0, 0]],
                          values=[1],
                          dense_shape=[1, 1],
                      ),
                      sparse_tensor.SparseTensor(
                          indices=[[3, 4]],
                          values=[-1],
                          dense_shape=[4, 5],
                      ),
                  ),
              },
              lambda: dict,
              lambda: [dtypes.float32, dtypes.variant, dtypes.variant],
              lambda: [[], None, None],
          ),
      ]
  
      def reduce_fn(x, y):
          # workaround for long line
          name, value_fn = y[:2]
          (
              expected_structure_fn,
              expected_types_fn,
              expected_shapes_fn,
          ) = y[2:]
          return x + combinations.combine(
              value_fn=combinations.NamedObject(
                  "value_fn.{}".format(name), value_fn
              ),
              expected_structure_fn=combinations.NamedObject(
                  "expected_structure_fn.{}".format(name),
                  expected_structure_fn,
              ),
              expected_types_fn=combinations.NamedObject(
                  "expected_types_fn.{}".format(name), expected_types_fn
              ),
              expected_shapes_fn=combinations.NamedObject(
                  "expected_shapes_fn.{}".format(name),
                  expected_shapes_fn,
              ),
          )
  
      return functools.reduce(reduce_fn, cases, [])
  
imports: import collections
  import dataclasses
  import functools
  from absl.testing import parameterized
  import numpy
  import wrapt
  from tensorflow.python.data.kernel_tests import test_base
  from tensorflow.python.data.ops import dataset_ops
  from tensorflow.python.data.util import nest
  from tensorflow.python.data.util import structure
  from tensorflow.python.framework import combinations
  from tensorflow.python.framework import constant_op
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import sparse_tensor
  from tensorflow.python.framework import tensor
  from tensorflow.python.framework import tensor_shape
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import tensor_array_ops
  from tensorflow.python.ops import variables
  from tensorflow.python.ops.ragged import ragged_factory_ops
  from tensorflow.python.ops.ragged import ragged_tensor
  from tensorflow.python.ops.ragged import ragged_tensor_value
  from tensorflow.python.platform import test
  from tensorflow.python.util.compat import collections_abc
label_desc: Use image node_id 1 for calling a global function with example usage: _test_flat_structure_combinations() and returns: functools, unknown