diff --git a/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_dynamic_line_width.options.json b/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_dynamic_line_width.options.json
new file mode 100644
index 0000000000000..3367effa0051c
--- /dev/null
+++ b/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_dynamic_line_width.options.json
@@ -0,0 +1,26 @@
+[
+  {
+    "docstring_code": "enabled",
+    "docstring_code_line_width": "dynamic",
+    "indent_style": "space",
+    "indent_width": 4
+  },
+  {
+    "docstring_code": "enabled",
+    "docstring_code_line_width": "dynamic",
+    "indent_style": "space",
+    "indent_width": 2
+  },
+  {
+    "docstring_code": "enabled",
+    "docstring_code_line_width": "dynamic",
+    "indent_style": "tab",
+    "indent_width": 4
+  },
+  {
+    "docstring_code": "enabled",
+    "docstring_code_line_width": "dynamic",
+    "indent_style": "tab",
+    "indent_width": 8
+  }
+]
diff --git a/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_dynamic_line_width.py b/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_dynamic_line_width.py
new file mode 100644
index 0000000000000..04027909eda6e
--- /dev/null
+++ b/crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_dynamic_line_width.py
@@ -0,0 +1,172 @@
+def simple():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+    ```
+
+    Done.
+    """
+    pass
+
+
+# Like simple, but we double everything up to ensure the indent level is
+# tracked correctly.
+def repeated():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+    ```
+
+    Done.
+    """
+    pass
+
+
+# Like simple, but we make one line exactly one character longer than the limit
+# (for 4-space indents) and make sure it gets wrapped.
+def barely_exceeds_limit():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is 89 columns, which is one
+                # more than the limit. Therefore, it should get wrapped for
+                # indent_width >= 4.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678)
+                return 5
+            self.x = doit( 5 )
+    ```
+
+    Done.
+    """
+    pass
+
+
+# This tests that if the code block is unindented, that it gets indented and
+# the dynamic line width setting is applied correctly.
+def unindented():
+    """
+    First line.
+
+```py
+class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+    def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+        def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            # For 4 space indents, this is just one character shy of
+            # tripping the default line width of 88. So it should not be
+            # wrapped.
+            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+            return 5
+        self.x = doit( 5 )
+```
+
+    Done.
+    """
+    pass
+
+
+# Like unindented, but contains a `print` line where it just barely exceeds the
+# globally configured line width *after* its indentation has been corrected.
+def unindented_barely_exceeds_limit():
+    """
+    First line.
+
+```py
+class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+    def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+        def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            # For 4 space indents, this is 89 columns, which is one
+            # more than the limit. Therefore, it should get wrapped for
+            # indent_width >= 4.
+            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678)
+            return 5
+        self.x = doit( 5 )
+```
+
+    Done.
+    """
+    pass
diff --git a/crates/ruff_python_formatter/tests/snapshots/format@docstring_code_examples_dynamic_line_width.py.snap b/crates/ruff_python_formatter/tests/snapshots/format@docstring_code_examples_dynamic_line_width.py.snap
new file mode 100644
index 0000000000000..91c1984124c9d
--- /dev/null
+++ b/crates/ruff_python_formatter/tests/snapshots/format@docstring_code_examples_dynamic_line_width.py.snap
@@ -0,0 +1,1630 @@
+---
+source: crates/ruff_python_formatter/tests/fixtures.rs
+input_file: crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_dynamic_line_width.py
+---
+## Input
+```python
+def simple():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+    ```
+
+    Done.
+    """
+    pass
+
+
+# Like simple, but we double everything up to ensure the indent level is
+# tracked correctly.
+def repeated():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+            self.x = doit( 5 )
+    ```
+
+    Done.
+    """
+    pass
+
+
+# Like simple, but we make one line exactly one character longer than the limit
+# (for 4-space indents) and make sure it gets wrapped.
+def barely_exceeds_limit():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+        def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+                # For 4 space indents, this is 89 columns, which is one
+                # more than the limit. Therefore, it should get wrapped for
+                # indent_width >= 4.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678)
+                return 5
+            self.x = doit( 5 )
+    ```
+
+    Done.
+    """
+    pass
+
+
+# This tests that if the code block is unindented, that it gets indented and
+# the dynamic line width setting is applied correctly.
+def unindented():
+    """
+    First line.
+
+```py
+class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+    def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+        def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            # For 4 space indents, this is just one character shy of
+            # tripping the default line width of 88. So it should not be
+            # wrapped.
+            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+            return 5
+        self.x = doit( 5 )
+```
+
+    Done.
+    """
+    pass
+
+
+# Like unindented, but contains a `print` line where it just barely exceeds the
+# globally configured line width *after* its indentation has been corrected.
+def unindented_barely_exceeds_limit():
+    """
+    First line.
+
+```py
+class Abcdefghijklmopqrstuvwxyz(Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5):
+    def abcdefghijklmnopqrstuvwxyz(self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+        def abcdefghijklmnopqrstuvwxyz(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4):
+            # For 4 space indents, this is 89 columns, which is one
+            # more than the limit. Therefore, it should get wrapped for
+            # indent_width >= 4.
+            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678)
+            return 5
+        self.x = doit( 5 )
+```
+
+    Done.
+    """
+    pass
+```
+
+## Outputs
+### Output 1
+```
+indent-style               = space
+line-width                 = 88
+indent-width               = 4
+quote-style                = Double
+line-ending                = LineFeed
+magic-trailing-comma       = Respect
+docstring-code             = Enabled
+docstring-code-line-width  = "dynamic"
+preview                    = Disabled
+```
+
+```python
+def simple():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(
+        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+    ):
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+    ```
+
+    Done.
+    """
+    pass
+
+
+# Like simple, but we double everything up to ensure the indent level is
+# tracked correctly.
+def repeated():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(
+        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+    ):
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+
+
+    class Abcdefghijklmopqrstuvwxyz(
+        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+    ):
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+    ```
+
+    Done.
+    """
+    pass
+
+
+# Like simple, but we make one line exactly one character longer than the limit
+# (for 4-space indents) and make sure it gets wrapped.
+def barely_exceeds_limit():
+    """
+    First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(
+        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+    ):
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is 89 columns, which is one
+                # more than the limit. Therefore, it should get wrapped for
+                # indent_width >= 4.
+                print(
+                    abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678
+                )
+                return 5
+
+            self.x = doit(5)
+    ```
+
+    Done.
+    """
+    pass
+
+
+# This tests that if the code block is unindented, that it gets indented and
+# the dynamic line width setting is applied correctly.
+def unindented():
+    """
+        First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(
+        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+    ):
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is just one character shy of
+                # tripping the default line width of 88. So it should not be
+                # wrapped.
+                print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+                return 5
+
+            self.x = doit(5)
+    ```
+
+        Done.
+    """
+    pass
+
+
+# Like unindented, but contains a `print` line where it just barely exceeds the
+# globally configured line width *after* its indentation has been corrected.
+def unindented_barely_exceeds_limit():
+    """
+        First line.
+
+    ```py
+    class Abcdefghijklmopqrstuvwxyz(
+        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+    ):
+        def abcdefghijklmnopqrstuvwxyz(
+            self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+        ):
+            def abcdefghijklmnopqrstuvwxyz(
+                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+            ):
+                # For 4 space indents, this is 89 columns, which is one
+                # more than the limit. Therefore, it should get wrapped for
+                # indent_width >= 4.
+                print(
+                    abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678
+                )
+                return 5
+
+            self.x = doit(5)
+    ```
+
+        Done.
+    """
+    pass
+```
+
+
+### Output 2
+```
+indent-style               = space
+line-width                 = 88
+indent-width               = 2
+quote-style                = Double
+line-ending                = LineFeed
+magic-trailing-comma       = Respect
+docstring-code             = Enabled
+docstring-code-line-width  = "dynamic"
+preview                    = Disabled
+```
+
+```python
+def simple():
+  """
+  First line.
+
+  ```py
+  class Abcdefghijklmopqrstuvwxyz(
+    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+  ):
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+  ```
+
+  Done.
+  """
+  pass
+
+
+# Like simple, but we double everything up to ensure the indent level is
+# tracked correctly.
+def repeated():
+  """
+  First line.
+
+  ```py
+  class Abcdefghijklmopqrstuvwxyz(
+    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+  ):
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+
+
+  class Abcdefghijklmopqrstuvwxyz(
+    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+  ):
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+  ```
+
+  Done.
+  """
+  pass
+
+
+# Like simple, but we make one line exactly one character longer than the limit
+# (for 4-space indents) and make sure it gets wrapped.
+def barely_exceeds_limit():
+  """
+  First line.
+
+  ```py
+  class Abcdefghijklmopqrstuvwxyz(
+    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+  ):
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is 89 columns, which is one
+        # more than the limit. Therefore, it should get wrapped for
+        # indent_width >= 4.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678)
+        return 5
+
+      self.x = doit(5)
+  ```
+
+  Done.
+  """
+  pass
+
+
+# This tests that if the code block is unindented, that it gets indented and
+# the dynamic line width setting is applied correctly.
+def unindented():
+  """
+      First line.
+
+  ```py
+  class Abcdefghijklmopqrstuvwxyz(
+    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+  ):
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is just one character shy of
+        # tripping the default line width of 88. So it should not be
+        # wrapped.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+        return 5
+
+      self.x = doit(5)
+  ```
+
+      Done.
+  """
+  pass
+
+
+# Like unindented, but contains a `print` line where it just barely exceeds the
+# globally configured line width *after* its indentation has been corrected.
+def unindented_barely_exceeds_limit():
+  """
+      First line.
+
+  ```py
+  class Abcdefghijklmopqrstuvwxyz(
+    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+  ):
+    def abcdefghijklmnopqrstuvwxyz(
+      self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+    ):
+      def abcdefghijklmnopqrstuvwxyz(
+        abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+      ):
+        # For 4 space indents, this is 89 columns, which is one
+        # more than the limit. Therefore, it should get wrapped for
+        # indent_width >= 4.
+        print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678)
+        return 5
+
+      self.x = doit(5)
+  ```
+
+      Done.
+  """
+  pass
+```
+
+
+### Output 3
+```
+indent-style               = tab
+line-width                 = 88
+indent-width               = 4
+quote-style                = Double
+line-ending                = LineFeed
+magic-trailing-comma       = Respect
+docstring-code             = Enabled
+docstring-code-line-width  = "dynamic"
+preview                    = Disabled
+```
+
+```python
+def simple():
+	"""
+	First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+	```
+
+	Done.
+	"""
+	pass
+
+
+# Like simple, but we double everything up to ensure the indent level is
+# tracked correctly.
+def repeated():
+	"""
+	First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+
+
+	class Abcdefghijklmopqrstuvwxyz(
+	    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+	```
+
+	Done.
+	"""
+	pass
+
+
+# Like simple, but we make one line exactly one character longer than the limit
+# (for 4-space indents) and make sure it gets wrapped.
+def barely_exceeds_limit():
+	"""
+	First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is 89 columns, which is one
+	            # more than the limit. Therefore, it should get wrapped for
+	            # indent_width >= 4.
+	            print(
+	                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678
+	            )
+	            return 5
+
+	        self.x = doit(5)
+	```
+
+	Done.
+	"""
+	pass
+
+
+# This tests that if the code block is unindented, that it gets indented and
+# the dynamic line width setting is applied correctly.
+def unindented():
+	"""
+	    First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is just one character shy of
+	            # tripping the default line width of 88. So it should not be
+	            # wrapped.
+	            print(abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a567)
+	            return 5
+
+	        self.x = doit(5)
+	```
+
+	    Done.
+	"""
+	pass
+
+
+# Like unindented, but contains a `print` line where it just barely exceeds the
+# globally configured line width *after* its indentation has been corrected.
+def unindented_barely_exceeds_limit():
+	"""
+	    First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	    Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	    def abcdefghijklmnopqrstuvwxyz(
+	        self, abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	    ):
+	        def abcdefghijklmnopqrstuvwxyz(
+	            abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4
+	        ):
+	            # For 4 space indents, this is 89 columns, which is one
+	            # more than the limit. Therefore, it should get wrapped for
+	            # indent_width >= 4.
+	            print(
+	                abc, ddef, ghi, jkl, mno, pqr, stu, vwx, yz, a1, a2, a3, a4, a5678
+	            )
+	            return 5
+
+	        self.x = doit(5)
+	```
+
+	    Done.
+	"""
+	pass
+```
+
+
+### Output 4
+```
+indent-style               = tab
+line-width                 = 88
+indent-width               = 8
+quote-style                = Double
+line-ending                = LineFeed
+magic-trailing-comma       = Respect
+docstring-code             = Enabled
+docstring-code-line-width  = "dynamic"
+preview                    = Disabled
+```
+
+```python
+def simple():
+	"""
+	First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+	```
+
+	Done.
+	"""
+	pass
+
+
+# Like simple, but we double everything up to ensure the indent level is
+# tracked correctly.
+def repeated():
+	"""
+	First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+
+
+	class Abcdefghijklmopqrstuvwxyz(
+	        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+	```
+
+	Done.
+	"""
+	pass
+
+
+# Like simple, but we make one line exactly one character longer than the limit
+# (for 4-space indents) and make sure it gets wrapped.
+def barely_exceeds_limit():
+	"""
+	First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is 89 columns, which is one
+	                        # more than the limit. Therefore, it should get wrapped for
+	                        # indent_width >= 4.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a5678,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+	```
+
+	Done.
+	"""
+	pass
+
+
+# This tests that if the code block is unindented, that it gets indented and
+# the dynamic line width setting is applied correctly.
+def unindented():
+	"""
+	    First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is just one character shy of
+	                        # tripping the default line width of 88. So it should not be
+	                        # wrapped.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a567,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+	```
+
+	    Done.
+	"""
+	pass
+
+
+# Like unindented, but contains a `print` line where it just barely exceeds the
+# globally configured line width *after* its indentation has been corrected.
+def unindented_barely_exceeds_limit():
+	"""
+	    First line.
+
+	```py
+	class Abcdefghijklmopqrstuvwxyz(
+	        Abc, Def, Ghi, Jkl, Mno, Pqr, Stu, Vwx, Yz, A1, A2, A3, A4, A5
+	):
+	        def abcdefghijklmnopqrstuvwxyz(
+	                self,
+	                abc,
+	                ddef,
+	                ghi,
+	                jkl,
+	                mno,
+	                pqr,
+	                stu,
+	                vwx,
+	                yz,
+	                a1,
+	                a2,
+	                a3,
+	                a4,
+	        ):
+	                def abcdefghijklmnopqrstuvwxyz(
+	                        abc,
+	                        ddef,
+	                        ghi,
+	                        jkl,
+	                        mno,
+	                        pqr,
+	                        stu,
+	                        vwx,
+	                        yz,
+	                        a1,
+	                        a2,
+	                        a3,
+	                        a4,
+	                ):
+	                        # For 4 space indents, this is 89 columns, which is one
+	                        # more than the limit. Therefore, it should get wrapped for
+	                        # indent_width >= 4.
+	                        print(
+	                                abc,
+	                                ddef,
+	                                ghi,
+	                                jkl,
+	                                mno,
+	                                pqr,
+	                                stu,
+	                                vwx,
+	                                yz,
+	                                a1,
+	                                a2,
+	                                a3,
+	                                a4,
+	                                a5678,
+	                        )
+	                        return 5
+
+	                self.x = doit(5)
+	```
+
+	    Done.
+	"""
+	pass
+```
+
+
+