code: def testCall_OutputTypeAndOutputDataTypeMatch(self):
      @resolver_function.resolver_function
      def resolve_artifact_list():
          return DummyNode(resolver_op.DataType.ARTIFACT_LIST)
  
      @resolver_function.resolver_function
      def resolve_artifact_multimap():
          return DummyNode(resolver_op.DataType.ARTIFACT_MULTIMAP)
  
      @resolver_function.resolver_function
      def resolve_artifact_multimap_list():
          return DummyNode(resolver_op.DataType.ARTIFACT_MULTIMAP_LIST)
  
      with self.subTest("ARTIFACT_LIST with dict output type"):
          with self.assertRaises(RuntimeError):
              with resolve_artifact_list.given_output_type({"x": X}):
                  resolve_artifact_list()
  
      with self.subTest("ARTIFACT_LIST with a single output type"):
          with resolve_artifact_list.given_output_type(X):
              result = resolve_artifact_list()
          self.assertIsInstance(
              result, resolved_channel.ResolvedChannel
          )
          self.assertEqual(
              result.invocation.function.__name__,
              "resolve_artifact_list",
          )
          self.assertEqual(result.type, X)
  
      with self.subTest("ARTIFACT_MULTIMAP with dict output type"):
          with resolve_artifact_multimap.given_output_type({"x": X}):
              result = resolve_artifact_multimap()
          self.assertIsInstance(result, dict)
          self.assertIsInstance(
              result["x"], resolved_channel.ResolvedChannel
          )
          self.assertEqual(
              result["x"].invocation.function.__name__,
              "resolve_artifact_multimap",
          )
          self.assertEqual(result["x"].type, X)
  
      with self.subTest("ARTIFACT_MULTIMAP with a single output type"):
          with self.assertRaises(RuntimeError):
              with resolve_artifact_multimap.given_output_type(X):
                  resolve_artifact_multimap()
  
      with self.subTest("ARTIFACT_MULTIMAP_LIST with dict output type"):
          with resolve_artifact_multimap_list.given_output_type(
              {"x": X}
          ):
              result = resolve_artifact_multimap_list()
          self.assertIsInstance(result, for_each_internal.Loopable)
  
      with self.subTest(
          "ARTIFACT_MULTIMAP_LIST with a single output type"
      ):
          with self.assertRaises(RuntimeError):
              with resolve_artifact_multimap_list.given_output_type(X):
                  resolve_artifact_multimap_list()
  
imports: from typing import Mapping, Set
  import tensorflow
  from tfx.dsl.control_flow import for_each
  from tfx.dsl.control_flow import for_each_internal
  from tfx.dsl.input_resolution import resolver_function
  from tfx.dsl.input_resolution import resolver_op
  import tfx.types
  from tfx.types import resolved_channel
  from tfx.utils import typing_utils
label_desc: Use image node_id 10 for calling the ResolverFunctionTest obj's underlying member method code with example usage: obj.testCall_OutputTypeAndOutputDataTypeMatch() and returns: DummyNode, DummyNode, DummyNode