code: def test_generate_slices_sql_assert_record_batches(self):
      input_record_batches = [
          pa.RecordBatch.from_arrays(
              [
                  pa.array([[1], [2, 1], [3], [2, 1, 1], [3]]),
                  pa.array(
                      [
                          ["dog"],
                          ["cat"],
                          ["wolf"],
                          ["dog", "wolf"],
                          ["wolf"],
                      ]
                  ),
              ],
              ["a", "b"],
          ),
      ]
      slice_sql = """
          SELECT
            STRUCT(a, b)
          FROM
            example.a, example.b
      """
      expected_result = [
          (
              "a_1_b_dog",
              pa.RecordBatch.from_arrays(
                  [
                      pa.array([[1], [2, 1, 1]]),
                      pa.array([["dog"], ["dog", "wolf"]]),
                  ],
                  ["a", "b"],
              ),
          ),
          (
              "a_1_b_cat",
              pa.RecordBatch.from_arrays(
                  [pa.array([[2, 1]]), pa.array([["cat"]])], ["a", "b"]
              ),
          ),
          (
              "a_2_b_cat",
              pa.RecordBatch.from_arrays(
                  [pa.array([[2, 1]]), pa.array([["cat"]])], ["a", "b"]
              ),
          ),
          (
              "a_2_b_dog",
              pa.RecordBatch.from_arrays(
                  [pa.array([[2, 1, 1]]), pa.array([["dog", "wolf"]])],
                  ["a", "b"],
              ),
          ),
          (
              "a_1_b_wolf",
              pa.RecordBatch.from_arrays(
                  [pa.array([[2, 1, 1]]), pa.array([["dog", "wolf"]])],
                  ["a", "b"],
              ),
          ),
          (
              "a_2_b_wolf",
              pa.RecordBatch.from_arrays(
                  [pa.array([[2, 1, 1]]), pa.array([["dog", "wolf"]])],
                  ["a", "b"],
              ),
          ),
          (
              "a_3_b_wolf",
              pa.RecordBatch.from_arrays(
                  [
                      pa.array([[3], [3]]),
                      pa.array([["wolf"], ["wolf"]]),
                  ],
                  ["a", "b"],
              ),
          ),
          (constants.DEFAULT_SLICE_KEY, input_record_batches[0]),
      ]
  
      with beam.Pipeline() as pipeline:
          # pylint: disable=no-value-for-parameter
          result = (
              pipeline
              | "Create"
              >> beam.Create(input_record_batches, reshuffle=False)
              | "GenerateSlicesSql"
              >> beam.ParDo(
                  slicing_util.GenerateSlicesSqlDoFn(
                      slice_sqls=[slice_sql]
                  )
              )
          )
  
          # pylint: enable=no-value-for-parameter
  
          def check_result(got):
              try:
                  self._check_results(got, expected_result)
  
              except AssertionError as err:
                  raise util.BeamAssertException(err)
  
          util.assert_that(result, check_result)
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import sys
  import unittest
  from absl.testing import absltest
  import apache_beam
  from apache_beam.testing import util
  import pyarrow
  from tensorflow_data_validation import constants
  from tensorflow_data_validation.utils import slicing_util
  from tfx_bsl.public.proto import slicing_spec_pb2
  from google.protobuf import text_format
label_desc: Use image node_id 14 for calling the SlicingUtilTest obj's underlying member method code with example usage: obj.test_generate_slices_sql_assert_record_batches() without return types