code: def testConv2dOperations(self):
      conv_input = mtf.zeros(
          self.mesh,
          mtf.Shape(
              [
                  self.batch_dim,
                  self.grid_h_dim,
                  self.grid_w_dim,
                  self.in_dim,
              ]
          ),
      )
      conv_filter = mtf.zeros(
          self.mesh,
          mtf.Shape(
              [
                  self.filter_h_dim,
                  self.filter_w_dim,
                  self.in_dim,
                  self.out_dim,
              ]
          ),
      )
      strides = [1, 1, 1, 1]
      padding = "SAME"
  
      conv2d_operation = mtf.Conv2dOperation(
          conv_input, conv_filter, strides, padding
      )
      self.assertEqual(
          conv2d_operation.splittable_dims,
          frozenset(["batch", "in", "out"]),
      )
      self.assertEqual(
          conv2d_operation.unsplittable_dims,
          frozenset(["filter_h", "filter_w", "grid_h", "grid_w"]),
      )
  
      output = conv2d_operation.outputs[0]
      d_output = mtf.zeros(self.mesh, output.shape)
  
      conv2d_backprop_input_operation = (
          mtf.Conv2or3dBackpropInputOperation(
              2,
              False,
              conv_input.shape,
              conv_filter,
              d_output,
              strides,
              padding,
          )
      )
      self.assertEqual(
          conv2d_backprop_input_operation.splittable_dims,
          frozenset(
              [
                  "batch",
                  "filter_h",
                  "filter_w",
                  "grid_h",
                  "grid_w",
                  "in",
                  "out",
              ]
          ),
      )
      self.assertEqual(
          conv2d_backprop_input_operation.unsplittable_dims, frozenset()
      )
  
      conv2d_backprop_filter_operation = (
          mtf.Conv2or3dBackpropFilterOperation(
              2,
              False,
              conv_input,
              conv_filter.shape,
              d_output,
              strides,
              padding,
          )
      )
      self.assertEqual(
          conv2d_backprop_filter_operation.splittable_dims,
          frozenset(
              [
                  "batch",
                  "filter_h",
                  "filter_w",
                  "grid_h",
                  "grid_w",
                  "in",
                  "out",
              ]
          ),
      )
      self.assertEqual(
          conv2d_backprop_filter_operation.unsplittable_dims,
          frozenset(),
      )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from absl.testing import parameterized
  import mesh_tensorflow
  from mesh_tensorflow import test_utils
  import numpy
  import tensorflow.compat.v1
  from tensorflow.python.framework import test_util
label_desc: Use image node_id 14 for calling the OperationSplittabilityTest obj's underlying member method code with example usage: obj.testConv2dOperations() without return types