text: from typing import Collection, Dict, List, Mapping, Sequence, Tuple
  
  import pytest
  
  from apischema import serializer, settings
  from apischema.conversions.conversions import Conversion, LazyConversion
  from apischema.conversions.visitor import SerializationVisitor
  from apischema.json_schema.conversions_resolver import (
      WithConversionsResolver,
      merge_results,
  )
  from apischema.objects import set_object_fields
  from apischema.types import AnyType
  from apischema.utils import identity
  
  
  @pytest.mark.parametrize(
      "results, origin, expected",
      [
          ([[int]], Collection, [[int]]),
          ([[int, str], [str]], Mapping, [[int, str], [str, str]]),
          ([[int], []], Mapping, []),
      ],
  )
  def test_merge_results(results, origin, expected):
      assert list(merge_results(results, origin)) == [
          origin[tuple(exp)] for exp in expected
      ]
  
  
  class Visitor(SerializationVisitor, WithConversionsResolver):
      def visit(self, tp: AnyType) -> Sequence[AnyType]:
          return self.resolve_conversion(tp)
  
  
  class A:
      pass
  
  
  serializer(Conversion(id, source=A, target=int))
  
  tmp = None
  rec_conversion = Conversion(identity, A, Collection[A], LazyConversion(lambda: tmp))
  tmp = rec_conversion
  
  
  class B:
      pass
  
  
  set_object_fields(B, [])
  
  
  @pytest.mark.parametrize(
      "tp, conversions, expected",
      [
          (int, None, [int]),
          (int, Conversion(str, int), []),
          (List[int], None, [Collection[int]]),
          (List[int], Conversion(str, source=int), [Collection[str]]),
          (
              Tuple[Dict[int, str], ...],
              [Conversion(str, source=int), Conversion(bool, source=str)],
              [Collection[Mapping[str, bool]]],
          ),
          (
              List[int],
              Conversion(str, source=int, sub_conversion=Conversion(bool, source=str)),
              [Collection[bool]],
          ),
          (A, None, [A]),
          (Collection[A], None, [Collection[A], Collection[int]]),
          (A, rec_conversion, []),
          (B, None, [B]),
      ],
  )
  def test_resolve_conversion(tp, conversions, expected):
      result = Visitor(settings.serialization.default_conversion).visit_with_conv(
          tp, conversions
      )
      assert list(result) == list(expected)
  