code: def testEventShape(self, num_or_size_splits, expected_split_sizes):
      num_or_size_splits = self.build_input(num_or_size_splits)
      total_size = np.sum(expected_split_sizes)
      shape_in_static = tf.TensorShape([total_size, 2])
      shape_out_static = [
          tf.TensorShape([d, 2]) for d in expected_split_sizes
      ]
      bijector = split.Split(
          num_or_size_splits=num_or_size_splits,
          axis=-2,
          validate_args=True,
      )
  
      # Test that forward_ and inverse_event_shape are correct when
      # event_shape_in/_out are statically known, even when the input shapes
      # are only partially specified.
      self.assertAllEqual(
          bijector.forward_event_shape(shape_in_static),
          shape_out_static,
      )
      self.assertEqual(
          bijector.inverse_event_shape(shape_out_static),
          shape_in_static,
      )
  
      # Shape is always known for splitting in eager mode, so we skip these tests.
      if tf.executing_eagerly():
          return
      self.assertAllEqual(
          [
              s.as_list()
              for s in bijector.forward_event_shape(
                  tf.TensorShape([total_size, None])
              )
          ],
          [[d, None] for d in expected_split_sizes],
      )
  
      if bijector.split_sizes is None:
          static_split_sizes = tensorshape_util.constant_value_as_shape(
              expected_split_sizes
          ).as_list()
      else:
          static_split_sizes = tensorshape_util.constant_value_as_shape(
              num_or_size_splits
          ).as_list()
  
      static_total_size = (
          None if None in static_split_sizes else total_size
      )
  
      # Test correctness with an inverse input dimension of None that coincides
      # with the `-1` element in not-fully specified `split_sizes`
      shape_with_maybe_unknown_dim = [[None, 3]] + [
          [d, 3] for d in expected_split_sizes[1:]
      ]
      self.assertAllEqual(
          bijector.inverse_event_shape(
              shape_with_maybe_unknown_dim
          ).as_list(),
          [static_total_size, 3],
      )
  
      # Test correctness with an input dimension of None that does not coincide
      # with a `-1` split_size.
      shape_with_deducable_dim = [[d, 3] for d in expected_split_sizes]
      shape_with_deducable_dim[2] = [None, 3]
      self.assertAllEqual(
          bijector.inverse_event_shape(
              shape_with_deducable_dim
          ).as_list(),
          [total_size, 3],
      )
  
      # Test correctness for an input shape of known rank only.
      if bijector.split_sizes is not None:
          shape_with_unknown_total = [
              [d, None] for d in static_split_sizes
          ]
      else:
          shape_with_unknown_total = [[None, None]] * len(
              expected_split_sizes
          )
      self.assertAllEqual(
          [
              s.as_list()
              for s in bijector.forward_event_shape(
                  tf.TensorShape([None, None])
              )
          ],
          shape_with_unknown_total,
      )
  
imports: from absl.testing import parameterized
  import numpy
  import tensorflow.compat.v1
  import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import split
  from tensorflow_probability.python.internal import tensorshape_util
  from tensorflow_probability.python.internal import test_util
label_desc: Use image node_id 4 for calling the SplitBijectorTestStatic obj's underlying member method code with example usage: obj.testEventShape(num_or_size_splits, expected_split_sizes) without return types