text: from django.contrib import admin
  from django.contrib.contenttypes.models import ContentType
  from django.utils.html import escape
  
  from polymorphic.admin import (
      PolymorphicChildModelAdmin,
      PolymorphicChildModelFilter,
      PolymorphicInlineSupportMixin,
      PolymorphicParentModelAdmin,
      StackedPolymorphicInline,
  )
  from polymorphic.tests.admintestcase import AdminTestCase
  from polymorphic.tests.models import (
      InlineModelA,
      InlineModelB,
      InlineParent,
      Model2A,
      Model2B,
      Model2C,
      Model2D,
  )
  
  
  class PolymorphicAdminTests(AdminTestCase):
      def test_admin_registration(self):
          """
          Test how the registration works
          """
  
          @self.register(Model2A)
          class Model2Admin(PolymorphicParentModelAdmin):
              base_model = Model2A
              list_filter = (PolymorphicChildModelFilter,)
              child_models = (Model2B, Model2C, Model2D)
  
          @self.register(Model2B)
          @self.register(Model2C)
          @self.register(Model2D)
          class Model2ChildAdmin(PolymorphicChildModelAdmin):
              base_model = Model2A
              base_fieldsets = (("Base fields", {"fields": ("field1",)}),)
  
          # -- add page
          ct_id = ContentType.objects.get_for_model(Model2D).pk
          self.admin_get_add(Model2A)  # shows type page
          self.admin_get_add(Model2A, qs="?ct_id={}".format(ct_id))  # shows type page
  
          self.admin_get_add(Model2A)  # shows type page
          self.admin_post_add(
              Model2A,
              {"field1": "A", "field2": "B", "field3": "C", "field4": "D"},
              qs="?ct_id={}".format(ct_id),
          )
  
          d_obj = Model2A.objects.all()[0]
          self.assertEqual(d_obj.__class__, Model2D)
          self.assertEqual(d_obj.field1, "A")
          self.assertEqual(d_obj.field2, "B")
  
          # -- list page
          self.admin_get_changelist(Model2A)  # asserts 200
  
          # -- edit
          response = self.admin_get_change(Model2A, d_obj.pk)
          self.assertContains(response, "field4")
          self.admin_post_change(
              Model2A,
              d_obj.pk,
              {"field1": "A2", "field2": "B2", "field3": "C2", "field4": "D2"},
          )
  
          d_obj.refresh_from_db()
          self.assertEqual(d_obj.field1, "A2")
          self.assertEqual(d_obj.field2, "B2")
          self.assertEqual(d_obj.field3, "C2")
          self.assertEqual(d_obj.field4, "D2")
  
          # -- history
          self.admin_get_history(Model2A, d_obj.pk)
  
          # -- delete
          self.admin_get_delete(Model2A, d_obj.pk)
          self.admin_post_delete(Model2A, d_obj.pk)
          self.assertRaises(Model2A.DoesNotExist, lambda: d_obj.refresh_from_db())
  
      def test_admin_inlines(self):
          """
          Test the registration of inline models.
          """
  
          class InlineModelAChild(StackedPolymorphicInline.Child):
              model = InlineModelA
  
          class InlineModelBChild(StackedPolymorphicInline.Child):
              model = InlineModelB
  
          class Inline(StackedPolymorphicInline):
              model = InlineModelA
              child_inlines = (InlineModelAChild, InlineModelBChild)
  
          @self.register(InlineParent)
          class InlineParentAdmin(PolymorphicInlineSupportMixin, admin.ModelAdmin):
              inlines = (Inline,)
  
          parent = InlineParent.objects.create(title="FOO")
          self.assertEqual(parent.inline_children.count(), 0)
  
          # -- get edit page
          response = self.admin_get_change(InlineParent, parent.pk)
  
          # Make sure the fieldset has the right data exposed in data-inline-formset
          self.assertContains(response, "childTypes")
          self.assertContains(response, escape('"type": "inlinemodela"'))
          self.assertContains(response, escape('"type": "inlinemodelb"'))
  
          # -- post edit page
          self.admin_post_change(
              InlineParent,
              parent.pk,
              {
                  "title": "FOO2",
                  "inline_children-INITIAL_FORMS": 0,
                  "inline_children-TOTAL_FORMS": 1,
                  "inline_children-MIN_NUM_FORMS": 0,
                  "inline_children-MAX_NUM_FORMS": 1000,
                  "inline_children-0-parent": parent.pk,
                  "inline_children-0-polymorphic_ctype": ContentType.objects.get_for_model(
                      InlineModelB
                  ).pk,
                  "inline_children-0-field1": "A2",
                  "inline_children-0-field2": "B2",
              },
          )
  
          parent.refresh_from_db()
          self.assertEqual(parent.title, "FOO2")
          self.assertEqual(parent.inline_children.count(), 1)
          child = parent.inline_children.all()[0]
          self.assertEqual(child.__class__, InlineModelB)
          self.assertEqual(child.field1, "A2")
          self.assertEqual(child.field2, "B2")
  