code: def make_sparse_to_dense_tests(options):
      """Make a set of tests to do sparse to dense."""
  
      test_parameters = [
          {
              "value_dtype": [tf.float32, tf.int32, tf.int64],
              "index_dtype": [tf.int32, tf.int64],
              "value_count": [1, 3, 6, 8],
              "dense_shape": [[15], [3, 10], [4, 4, 4, 4], [7, 10, 9]],
              "default_value": [0, -1],
              "value_is_scalar": [True, False],
          }
      ]
  
      # Return a single value for 1-D dense shape, but a tuple for other shapes.
      def generate_index(dense_shape):
          if len(dense_shape) == 1:
              return np.random.randint(dense_shape[0])
          else:
              index = []
              for shape in dense_shape:
                  index.append(np.random.randint(shape))
              return tuple(index)
  
      def build_graph(parameters):
          """Build the sparse_to_dense op testing graph."""
          dense_shape = parameters["dense_shape"]
  
          # Special handle for value_is_scalar case.
          # value_count must be 1.
          if (
              parameters["value_is_scalar"]
              and parameters["value_count"] == 1
          ):
              value = tf.compat.v1.placeholder(
                  name="value",
                  dtype=parameters["value_dtype"],
                  shape=(),
              )
          else:
              value = tf.compat.v1.placeholder(
                  name="value",
                  dtype=parameters["value_dtype"],
                  shape=[parameters["value_count"]],
              )
          indices = set()
          while len(indices) < parameters["value_count"]:
              indices.add(generate_index(dense_shape))
          indices = tf.constant(
              tuple(indices), dtype=parameters["index_dtype"]
          )
          # TODO(renjieliu): Add test for validate_indices case.
          out = tf.compat.v1.sparse_to_dense(
              indices,
              dense_shape,
              value,
              parameters["default_value"],
              validate_indices=False,
          )
  
          return [value], [out]
  
      def build_inputs(parameters, sess, inputs, outputs):
          if (
              parameters["value_is_scalar"]
              and parameters["value_count"] == 1
          ):
              input_value = create_scalar_data(
                  parameters["value_dtype"]
              )
          else:
              input_value = create_tensor_data(
                  parameters["value_dtype"], [parameters["value_count"]]
              )
          return [input_value], sess.run(
              outputs, feed_dict=dict(zip(inputs, [input_value]))
          )
  
      make_zip_of_tests(
          options, test_parameters, build_graph, build_inputs
      )
  
imports: import numpy
  import tensorflow
  from tensorflow.lite.testing.zip_test_utils import create_scalar_data
  from tensorflow.lite.testing.zip_test_utils import create_tensor_data
  from tensorflow.lite.testing.zip_test_utils import make_zip_of_tests
  from tensorflow.lite.testing.zip_test_utils import register_make_test_function
label_desc: Use image node_id 1 for calling a global function with example usage: make_sparse_to_dense_tests(options) and returns: list,  list, list,  sess, np, tuple