code: def test_basic(self):
      @mb.program(
          input_specs=[
              mb.TensorSpec(shape=(1, 1, 1, 1), dtype=types.bool),
              mb.TensorSpec(shape=(1, 1, 1, 1), dtype=types.int32),
              mb.TensorSpec(shape=(1, 1, 1, 1), dtype=types.fp32),
          ]
      )
      def prog(x, y, z):
          out = mb.logical_not(x=x)
          return (out, y, z)
  
      prog.functions["not_main"] = copy.deepcopy(prog.functions["main"])
  
      prev_prog, prev_block, block = apply_pass_and_basic_check(
          prog,
          "mil_backend::adjust_io_to_supported_types",
          skip_output_type_check=True,
          skip_input_type_check=True,
      )  # output dtype is modified
  
      """
          Input graph:
  
          func main(bool x, int32 y, fp32 z) {
              bool  out = logical_not(x)
          } -> (out, y, z)
  
          becomes
  
          func main(fp32 x, int32 y, fp32 z) {
             bool  x_casted = cast(x)
             bool  out__pre__output__fp32__cast = logical_not(x_casted)
             fp32  out = cast(out__pre__output__fp32__cast)
          } -> (out, y, z)
          """
      assert get_op_types_in_program(prev_prog) == ["logical_not"]
      assert get_op_types_in_program(prog) == [
          "cast",
          "logical_not",
          "cast",
      ]
  
      prev_inputs = list(prev_prog.functions["main"].inputs.items())
      inputs = list(prog.functions["main"].inputs.items())
      assert prev_inputs[0][1].name == inputs[0][1].name
      assert inputs[0][1].dtype == types.fp32
      for i in range(1, len(inputs)):
          assert prev_inputs[i][1].name == inputs[i][1].name
          assert prev_inputs[i][1].dtype == inputs[i][1].dtype
  
      prev_outputs = prev_prog.functions["main"].outputs
      outputs = prog.functions["main"].outputs
      assert prev_outputs[0].name == outputs[0].name
      assert outputs[0].dtype == types.fp32
      for i in range(1, len(outputs)):
          assert prev_outputs[i].name == outputs[i].name
          assert prev_outputs[i].dtype == outputs[i].dtype
  
      """
          Input graph:
  
          func not_main(bool x, int32 y, fp32 z) {
              bool  out = logical_not(x)
          } -> (out, y, z)
  
          is identical after the pass.
          """
      assert get_op_types_in_program(prev_prog, "not_main") == [
          "logical_not"
      ]
      assert get_op_types_in_program(prog, "not_main") == [
          "logical_not"
      ]
  
      prev_inputs = list(prev_prog.functions["not_main"].inputs.items())
      inputs = list(prog.functions["not_main"].inputs.items())
      for i in range(0, len(inputs)):
          assert prev_inputs[i][1].name == inputs[i][1].name
          assert prev_inputs[i][1].dtype == inputs[i][1].dtype
  
      prev_outputs = prev_prog.functions["not_main"].outputs
      outputs = prog.functions["not_main"].outputs
      for i in range(0, len(outputs)):
          assert prev_outputs[i].name == outputs[i].name
          assert prev_outputs[i].dtype == outputs[i].dtype
  
imports: import copy
  import itertools
  import numpy
  import pytest
  import coremltools
  from coremltools.converters.mil._deployment_compatibility import AvailableTarget
  from coremltools.converters.mil.mil import Builder
  from coremltools.converters.mil.mil import types
  from coremltools.converters.mil.mil.passes.pass_registry import PASS_REGISTRY
  from coremltools.converters.mil.testing_utils import apply_pass_and_basic_check, assert_model_is_valid, get_op_types_in_program
label_desc: Use image node_id 1 for calling the TestAdjustToSupportedTypes obj's underlying member method code with example usage: obj.test_basic() and returns: out,  y,  z