code: def test_fake_as_funcnode_keep_structure(tmpdir):
      path = str(tmpdir)
  
      class Model(chainer.Chain):
          def __init__(self):
              super().__init__()
  
          def f(self, x):
              return {"a": (x, x + 1), "b": [x + 2, x + 3, x + 4]}
  
          def __call__(self, x):
              ret = self.f(x)
              return ret["a"][0] + ret["b"][1]
  
      model = Model()
      x = input_generator.increasing(2, 3)
  
      with warnings.catch_warnings(record=True):
          model.f = fake_as_funcnode(model.f, "xF")
  
      def f_converter(params):
          return (
              onnx_helper.make_node(
                  "xF", params.input_names, params.output_names
              ),
          )
  
      addon_converters = {"xF": f_converter}
  
      with testing.assert_warns(UserWarning):
          export_testcase(
              model, x, path, external_converters=addon_converters
          )
  
      model_filepath = os.path.join(path, "model.onnx")
      assert os.path.isfile(model_filepath)
  
      onnx_model = onnx.load(model_filepath)
      node_names = [n.name for n in onnx_model.graph.node]
      assert len(node_names) == 2
      assert node_names[0] == "xF_0"
      assert len(onnx_model.graph.node[0].output) == 5
      assert len(onnx_model.graph.output) == 1
  
imports: import os
  import warnings
  import chainer
  import chainer.functions
  import chainer.links
  from chainer import testing
  import numpy
  import onnx
  import pytest
  from onnx_chainer import export
  from onnx_chainer import export_testcase
  from onnx_chainer import onnx_helper
  from onnx_chainer.replace_func import as_funcnode
  from onnx_chainer.replace_func import fake_as_funcnode
  from onnx_chainer.testing import input_generator
  from onnx_chainer_tests.helper import ONNXModelChecker
  from onnx_chainer_tests.helper import ONNXModelTest
label_desc: Use image node_id 3 for calling a global function with example usage: test_fake_as_funcnode_keep_structure(tmpdir) and returns: onnx_helper, dict, unknown