code: def test_parameter_types(self):
      docstring = dedent(
          """\
              Parameters
              ----------
              param1 : DataFrame
                  the data to work on
              param2 : int or float or None, optional
                  a parameter with different types
              param3 : dict-like, optional
                  a optional mapping
              param4 : int or float or None, optional
                  a optional parameter with different types
              param5 : {"F", "C", "N"}, optional
                  a optional parameter with fixed values
              param6 : int, default None
                  different default format
              param7 : mapping of hashable to str, optional
                  a optional mapping
              param8 : ... or Ellipsis
                  ellipsis
              param9 : tuple of list of int
                  a parameter with tuple of list of int
          """
      )
      expected = dedent(
          """\
              :param param1: the data to work on
              :type param1: :class:`DataFrame`
              :param param2: a parameter with different types
              :type param2: :class:`int` or :class:`float` or :obj:`None`, *optional*
              :param param3: a optional mapping
              :type param3: :term:`dict-like <mapping>`, *optional*
              :param param4: a optional parameter with different types
              :type param4: :class:`int` or :class:`float` or :obj:`None`, *optional*
              :param param5: a optional parameter with fixed values
              :type param5: ``{"F", "C", "N"}``, *optional*
              :param param6: different default format
              :type param6: :class:`int`, *default* :obj:`None`
              :param param7: a optional mapping
              :type param7: :term:`mapping` of :term:`hashable` to :class:`str`, *optional*
              :param param8: ellipsis
              :type param8: :obj:`... <Ellipsis>` or :obj:`Ellipsis`
              :param param9: a parameter with tuple of list of int
              :type param9: :class:`tuple` of :class:`list` of :class:`int`
          """
      )
      translations = {
          "dict-like": ":term:`dict-like <mapping>`",
          "mapping": ":term:`mapping`",
          "hashable": ":term:`hashable`",
      }
      config = Config(
          napoleon_use_param=True,
          napoleon_use_rtype=True,
          napoleon_preprocess_types=True,
          napoleon_type_aliases=translations,
      )
      actual = str(NumpyDocstring(docstring, config))
      assert expected == actual
  
imports: import re
  from collections import namedtuple
  from inspect import cleandoc
  from textwrap import dedent
  from unittest import mock
  import pytest
  from sphinx.ext.napoleon import Config
  from sphinx.ext.napoleon.docstring import GoogleDocstring, NumpyDocstring, _convert_numpy_type_spec, _recombine_set_tokens, _token_type, _tokenize_type_spec
  from tests.test_extensions.ext_napoleon_pep526_data_google import PEP526GoogleClass
  from tests.test_extensions.ext_napoleon_pep526_data_numpy import PEP526NumpyClass
label_desc: Use image node_id 22 for calling the TestNumpyDocstring obj's underlying member method code with example usage: obj.test_parameter_types() without return types