Improve examples to use 88 chars line length (#677) (#714)

[etc/vim.git] / tests / test_black.py

diff --git a/tests/test_black.py b/tests/test_black.py
index 9c798caa1c3169b6792f8d663ff41a97df345e10..3404e058e1b069abc46830e41953bb99feeee169 100644 (file)
--- a/tests/test_black.py
+++ b/tests/test_black.py
@@ -1,15 +1,25 @@
 #!/usr/bin/env python3
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
 #!/usr/bin/env python3
 import asyncio
 from concurrent.futures import ThreadPoolExecutor

-from contextlib import contextmanager
-from functools import partial
+from contextlib import contextmanager, redirect_stderr
+from functools import partial, wraps

 from io import BytesIO, TextIOWrapper
 import os
 from pathlib import Path
 import re
 import sys
 from tempfile import TemporaryDirectory
 from io import BytesIO, TextIOWrapper
 import os
 from pathlib import Path
 import re
 import sys
 from tempfile import TemporaryDirectory

-from typing import Any, BinaryIO, Generator, List, Tuple, Iterator
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Coroutine,
+    Generator,
+    List,
+    Tuple,
+    Iterator,
+    TypeVar,
+)

 import unittest
 from unittest.mock import patch, MagicMock
 
 import unittest
 from unittest.mock import patch, MagicMock
 


@@ -17,14 +27,24 @@ from click import unstyle
 from click.testing import CliRunner
 
 import black
 from click.testing import CliRunner
 
 import black

+from black import Feature

 
 

+try:
+    import blackd
+    from aiohttp.test_utils import TestClient, TestServer
+except ImportError:
+    has_blackd_deps = False
+else:
+    has_blackd_deps = True

 
 

-ll = 88
-ff = partial(black.format_file_in_place, line_length=ll, fast=True)
-fs = partial(black.format_str, line_length=ll)
+
+ff = partial(black.format_file_in_place, mode=black.FileMode(), fast=True)
+fs = partial(black.format_str, mode=black.FileMode())

 THIS_FILE = Path(__file__)
 THIS_DIR = THIS_FILE.parent
 EMPTY_LINE = "# EMPTY LINE WITH WHITESPACE" + " (this comment will be removed)"
 THIS_FILE = Path(__file__)
 THIS_DIR = THIS_FILE.parent
 EMPTY_LINE = "# EMPTY LINE WITH WHITESPACE" + " (this comment will be removed)"

+T = TypeVar("T")
+R = TypeVar("R")

 
 
 def dump_to_stderr(*output: str) -> str:
 
 
 def dump_to_stderr(*output: str) -> str:


@@ -79,13 +99,25 @@ def event_loop(close: bool) -> Iterator[None]:
             loop.close()
 
 
             loop.close()
 
 

+def async_test(f: Callable[..., Coroutine[Any, None, R]]) -> Callable[..., None]:
+    @event_loop(close=True)
+    @wraps(f)
+    def wrapper(*args: Any, **kwargs: Any) -> None:
+        asyncio.get_event_loop().run_until_complete(f(*args, **kwargs))
+
+    return wrapper
+
+

 class BlackRunner(CliRunner):
     """Modify CliRunner so that stderr is not merged with stdout.
 
     This is a hack that can be removed once we depend on Click 7.x"""
 
 class BlackRunner(CliRunner):
     """Modify CliRunner so that stderr is not merged with stdout.
 
     This is a hack that can be removed once we depend on Click 7.x"""
 

-    def __init__(self, stderrbuf: BinaryIO) -> None:
-        self.stderrbuf = stderrbuf
+    def __init__(self) -> None:
+        self.stderrbuf = BytesIO()
+        self.stdoutbuf = BytesIO()
+        self.stdout_bytes = b""
+        self.stderr_bytes = b""

         super().__init__()
 
     @contextmanager
         super().__init__()
 
     @contextmanager


@@ -96,6 +128,8 @@ class BlackRunner(CliRunner):
                 sys.stderr = TextIOWrapper(self.stderrbuf, encoding=self.charset)
                 yield output
             finally:
                 sys.stderr = TextIOWrapper(self.stderrbuf, encoding=self.charset)
                 yield output
             finally:

+                self.stdout_bytes = sys.stdout.buffer.getvalue()  # type: ignore
+                self.stderr_bytes = sys.stderr.buffer.getvalue()  # type: ignore

                 sys.stderr = hold_stderr
 
 
                 sys.stderr = hold_stderr
 
 


@@ -121,13 +155,22 @@ class BlackTestCase(unittest.TestCase):
                 black.err(str(ve))
         self.assertEqual(expected, actual)
 
                 black.err(str(ve))
         self.assertEqual(expected, actual)
 

+    def invokeBlack(
+        self, args: List[str], exit_code: int = 0, ignore_config: bool = True
+    ) -> None:
+        runner = BlackRunner()
+        if ignore_config:
+            args = ["--config", str(THIS_DIR / "empty.toml"), *args]
+        result = runner.invoke(black.main, args)
+        self.assertEqual(result.exit_code, exit_code, msg=runner.stderr_bytes.decode())
+

     @patch("black.dump_to_file", dump_to_stderr)
     def test_empty(self) -> None:
         source = expected = ""
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
     @patch("black.dump_to_file", dump_to_stderr)
     def test_empty(self) -> None:
         source = expected = ""
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     def test_empty_ff(self) -> None:
         expected = ""
 
     def test_empty_ff(self) -> None:
         expected = ""


@@ -146,7 +189,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

         self.assertFalse(ff(THIS_FILE))
 
     @patch("black.dump_to_file", dump_to_stderr)
         self.assertFalse(ff(THIS_FILE))
 
     @patch("black.dump_to_file", dump_to_stderr)


@@ -155,21 +198,20 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

         self.assertFalse(ff(THIS_DIR / ".." / "black.py"))
 
     def test_piping(self) -> None:
         source, expected = read_data("../black", data=False)
         self.assertFalse(ff(THIS_DIR / ".." / "black.py"))
 
     def test_piping(self) -> None:
         source, expected = read_data("../black", data=False)

-        stderrbuf = BytesIO()
-        result = BlackRunner(stderrbuf).invoke(
+        result = BlackRunner().invoke(

             black.main,
             black.main,

-            ["-", "--fast", f"--line-length={ll}"],
+            ["-", "--fast", f"--line-length={black.DEFAULT_LINE_LENGTH}"],

             input=BytesIO(source.encode("utf8")),
         )
         self.assertEqual(result.exit_code, 0)
         self.assertFormatEqual(expected, result.output)
         black.assert_equivalent(source, result.output)
             input=BytesIO(source.encode("utf8")),
         )
         self.assertEqual(result.exit_code, 0)
         self.assertFormatEqual(expected, result.output)
         black.assert_equivalent(source, result.output)

-        black.assert_stable(source, result.output, line_length=ll)
+        black.assert_stable(source, result.output, black.FileMode())

 
     def test_piping_diff(self) -> None:
         diff_header = re.compile(
 
     def test_piping_diff(self) -> None:
         diff_header = re.compile(


@@ -179,9 +221,14 @@ class BlackTestCase(unittest.TestCase):
         source, _ = read_data("expression.py")
         expected, _ = read_data("expression.diff")
         config = THIS_DIR / "data" / "empty_pyproject.toml"
         source, _ = read_data("expression.py")
         expected, _ = read_data("expression.diff")
         config = THIS_DIR / "data" / "empty_pyproject.toml"

-        stderrbuf = BytesIO()
-        args = ["-", "--fast", f"--line-length={ll}", "--diff", f"--config={config}"]
-        result = BlackRunner(stderrbuf).invoke(
+        args = [
+            "-",
+            "--fast",
+            f"--line-length={black.DEFAULT_LINE_LENGTH}",
+            "--diff",
+            f"--config={config}",
+        ]
+        result = BlackRunner().invoke(

             black.main, args, input=BytesIO(source.encode("utf8"))
         )
         self.assertEqual(result.exit_code, 0)
             black.main, args, input=BytesIO(source.encode("utf8"))
         )
         self.assertEqual(result.exit_code, 0)


@@ -195,7 +242,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

         self.assertFalse(ff(THIS_DIR / ".." / "setup.py"))
 
     @patch("black.dump_to_file", dump_to_stderr)
         self.assertFalse(ff(THIS_DIR / ".." / "setup.py"))
 
     @patch("black.dump_to_file", dump_to_stderr)


@@ -204,7 +251,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_function2(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_function2(self) -> None:


@@ -212,7 +259,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_expression(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_expression(self) -> None:


@@ -220,7 +267,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     def test_expression_ff(self) -> None:
         source, expected = read_data("expression")
 
     def test_expression_ff(self) -> None:
         source, expected = read_data("expression")


@@ -234,7 +281,7 @@ class BlackTestCase(unittest.TestCase):
         self.assertFormatEqual(expected, actual)
         with patch("black.dump_to_file", dump_to_stderr):
             black.assert_equivalent(source, actual)
         self.assertFormatEqual(expected, actual)
         with patch("black.dump_to_file", dump_to_stderr):
             black.assert_equivalent(source, actual)

-            black.assert_stable(source, actual, line_length=ll)
+            black.assert_stable(source, actual, black.FileMode())

 
     def test_expression_diff(self) -> None:
         source, _ = read_data("expression.py")
 
     def test_expression_diff(self) -> None:
         source, _ = read_data("expression.py")


@@ -244,11 +291,8 @@ class BlackTestCase(unittest.TestCase):
             rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d "
             rf"\d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
         )
             rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d "
             rf"\d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
         )

-        stderrbuf = BytesIO()

         try:
         try:

-            result = BlackRunner(stderrbuf).invoke(
-                black.main, ["--diff", str(tmp_file)]
-            )
+            result = BlackRunner().invoke(black.main, ["--diff", str(tmp_file)])

             self.assertEqual(result.exit_code, 0)
         finally:
             os.unlink(tmp_file)
             self.assertEqual(result.exit_code, 0)
         finally:
             os.unlink(tmp_file)


@@ -260,7 +304,7 @@ class BlackTestCase(unittest.TestCase):
             msg = (
                 f"Expected diff isn't equal to the actual. If you made changes "
                 f"to expression.py and this is an anticipated difference, "
             msg = (
                 f"Expected diff isn't equal to the actual. If you made changes "
                 f"to expression.py and this is an anticipated difference, "

-                f"overwrite tests/expression.diff with {dump}"
+                f"overwrite tests/data/expression.diff with {dump}"

             )
             self.assertEqual(expected, actual, msg)
 
             )
             self.assertEqual(expected, actual, msg)
 


@@ -270,7 +314,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_string_quotes(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_string_quotes(self) -> None:


@@ -278,12 +322,12 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
-        mode = black.FileMode.NO_STRING_NORMALIZATION
+        black.assert_stable(source, actual, black.FileMode())
+        mode = black.FileMode(string_normalization=False)

         not_normalized = fs(source, mode=mode)
         self.assertFormatEqual(source, not_normalized)
         black.assert_equivalent(source, not_normalized)
         not_normalized = fs(source, mode=mode)
         self.assertFormatEqual(source, not_normalized)
         black.assert_equivalent(source, not_normalized)

-        black.assert_stable(source, not_normalized, line_length=ll, mode=mode)
+        black.assert_stable(source, not_normalized, mode=mode)

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_slices(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_slices(self) -> None:


@@ -291,7 +335,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments(self) -> None:


@@ -299,7 +343,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments2(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments2(self) -> None:


@@ -307,7 +351,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments3(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments3(self) -> None:


@@ -315,7 +359,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments4(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments4(self) -> None:


@@ -323,7 +367,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments5(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments5(self) -> None:


@@ -331,7 +375,15 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())
+
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_comments6(self) -> None:
+        source, expected = read_data("comments6")
+        actual = fs(source)
+        self.assertFormatEqual(expected, actual)
+        black.assert_equivalent(source, actual)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_cantfit(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_cantfit(self) -> None:


@@ -339,7 +391,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_import_spacing(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_import_spacing(self) -> None:


@@ -347,7 +399,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_composition(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_composition(self) -> None:


@@ -355,7 +407,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_empty_lines(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_empty_lines(self) -> None:


@@ -363,7 +415,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_string_prefixes(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_string_prefixes(self) -> None:


@@ -371,22 +423,32 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_numeric_literals(self) -> None:
         source, expected = read_data("numeric_literals")
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_numeric_literals(self) -> None:
         source, expected = read_data("numeric_literals")

-        actual = fs(source, mode=black.FileMode.PYTHON36)
+        mode = black.FileMode(target_versions=black.PY36_VERSIONS)
+        actual = fs(source, mode=mode)

         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, mode)
+
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_numeric_literals_ignoring_underscores(self) -> None:
+        source, expected = read_data("numeric_literals_skip_underscores")
+        mode = black.FileMode(target_versions=black.PY36_VERSIONS)
+        actual = fs(source, mode=mode)
+        self.assertFormatEqual(expected, actual)
+        black.assert_equivalent(source, actual)
+        black.assert_stable(source, actual, mode)

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_numeric_literals_py2(self) -> None:
         source, expected = read_data("numeric_literals_py2")
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_numeric_literals_py2(self) -> None:
         source, expected = read_data("numeric_literals_py2")
         actual = fs(source)
         self.assertFormatEqual(expected, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_python2(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_python2(self) -> None:


@@ -394,22 +456,22 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         # black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         # black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_python2_unicode_literals(self) -> None:
         source, expected = read_data("python2_unicode_literals")
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_python2_unicode_literals(self) -> None:
         source, expected = read_data("python2_unicode_literals")
         actual = fs(source)
         self.assertFormatEqual(expected, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_stub(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_stub(self) -> None:

-        mode = black.FileMode.PYI
+        mode = black.FileMode(is_pyi=True)

         source, expected = read_data("stub.pyi")
         actual = fs(source, mode=mode)
         self.assertFormatEqual(expected, actual)
         source, expected = read_data("stub.pyi")
         actual = fs(source, mode=mode)
         self.assertFormatEqual(expected, actual)

-        black.assert_stable(source, actual, line_length=ll, mode=mode)
+        black.assert_stable(source, actual, mode)

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_python37(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_python37(self) -> None:


@@ -419,7 +481,7 @@ class BlackTestCase(unittest.TestCase):
         major, minor = sys.version_info[:2]
         if major > 3 or (major == 3 and minor >= 7):
             black.assert_equivalent(source, actual)
         major, minor = sys.version_info[:2]
         if major > 3 or (major == 3 and minor >= 7):
             black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_fmtonoff(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_fmtonoff(self) -> None:


@@ -427,7 +489,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_fmtonoff2(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_fmtonoff2(self) -> None:


@@ -435,7 +497,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_remove_empty_parentheses_after_class(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_remove_empty_parentheses_after_class(self) -> None:


@@ -443,7 +505,7 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())

 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_new_line_between_class_and_code(self) -> None:
 
     @patch("black.dump_to_file", dump_to_stderr)
     def test_new_line_between_class_and_code(self) -> None:


@@ -451,7 +513,28 @@ class BlackTestCase(unittest.TestCase):
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)

-        black.assert_stable(source, actual, line_length=ll)
+        black.assert_stable(source, actual, black.FileMode())
+
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_bracket_match(self) -> None:
+        source, expected = read_data("bracketmatch")
+        actual = fs(source)
+        self.assertFormatEqual(expected, actual)
+        black.assert_equivalent(source, actual)
+        black.assert_stable(source, actual, black.FileMode())
+
+    def test_comment_indentation(self) -> None:
+        contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t# comment\n\tpass\n"
+        contents_spc = "if 1:\n    if 2:\n        pass\n    # comment\n    pass\n"
+
+        self.assertFormatEqual(fs(contents_spc), contents_spc)
+        self.assertFormatEqual(fs(contents_tab), contents_spc)
+
+        contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t\t# comment\n\tpass\n"
+        contents_spc = "if 1:\n    if 2:\n        pass\n        # comment\n    pass\n"
+
+        self.assertFormatEqual(fs(contents_tab), contents_spc)
+        self.assertFormatEqual(fs(contents_spc), contents_spc)

 
     def test_report_verbose(self) -> None:
         report = black.Report(verbose=True)
 
     def test_report_verbose(self) -> None:
         report = black.Report(verbose=True)


@@ -725,27 +808,31 @@ class BlackTestCase(unittest.TestCase):
                 "2 files would fail to reformat.",
             )
 
                 "2 files would fail to reformat.",
             )
 

-    def test_is_python36(self) -> None:
+    def test_get_features_used(self) -> None:

         node = black.lib2to3_parse("def f(*, arg): ...\n")
         node = black.lib2to3_parse("def f(*, arg): ...\n")

-        self.assertFalse(black.is_python36(node))
+        self.assertEqual(black.get_features_used(node), set())

         node = black.lib2to3_parse("def f(*, arg,): ...\n")
         node = black.lib2to3_parse("def f(*, arg,): ...\n")

-        self.assertTrue(black.is_python36(node))
+        self.assertEqual(black.get_features_used(node), {Feature.TRAILING_COMMA})

         node = black.lib2to3_parse("def f(*, arg): f'string'\n")
         node = black.lib2to3_parse("def f(*, arg): f'string'\n")

-        self.assertTrue(black.is_python36(node))
+        self.assertEqual(black.get_features_used(node), {Feature.F_STRINGS})

         node = black.lib2to3_parse("123_456\n")
         node = black.lib2to3_parse("123_456\n")

-        self.assertTrue(black.is_python36(node))
+        self.assertEqual(black.get_features_used(node), {Feature.NUMERIC_UNDERSCORES})

         node = black.lib2to3_parse("123456\n")
         node = black.lib2to3_parse("123456\n")

-        self.assertFalse(black.is_python36(node))
+        self.assertEqual(black.get_features_used(node), set())

         source, expected = read_data("function")
         node = black.lib2to3_parse(source)
         source, expected = read_data("function")
         node = black.lib2to3_parse(source)

-        self.assertTrue(black.is_python36(node))
+        self.assertEqual(
+            black.get_features_used(node), {Feature.TRAILING_COMMA, Feature.F_STRINGS}
+        )

         node = black.lib2to3_parse(expected)
         node = black.lib2to3_parse(expected)

-        self.assertTrue(black.is_python36(node))
+        self.assertEqual(
+            black.get_features_used(node), {Feature.TRAILING_COMMA, Feature.F_STRINGS}
+        )

         source, expected = read_data("expression")
         node = black.lib2to3_parse(source)
         source, expected = read_data("expression")
         node = black.lib2to3_parse(source)

-        self.assertFalse(black.is_python36(node))
+        self.assertEqual(black.get_features_used(node), set())

         node = black.lib2to3_parse(expected)
         node = black.lib2to3_parse(expected)

-        self.assertFalse(black.is_python36(node))
+        self.assertEqual(black.get_features_used(node), set())

 
     def test_get_future_imports(self) -> None:
         node = black.lib2to3_parse("\n")
 
     def test_get_future_imports(self) -> None:
         node = black.lib2to3_parse("\n")


@@ -803,21 +890,22 @@ class BlackTestCase(unittest.TestCase):
 
     def test_format_file_contents(self) -> None:
         empty = ""
 
     def test_format_file_contents(self) -> None:
         empty = ""

+        mode = black.FileMode()

         with self.assertRaises(black.NothingChanged):
         with self.assertRaises(black.NothingChanged):

-            black.format_file_contents(empty, line_length=ll, fast=False)
+            black.format_file_contents(empty, mode=mode, fast=False)

         just_nl = "\n"
         with self.assertRaises(black.NothingChanged):
         just_nl = "\n"
         with self.assertRaises(black.NothingChanged):

-            black.format_file_contents(just_nl, line_length=ll, fast=False)
+            black.format_file_contents(just_nl, mode=mode, fast=False)

         same = "l = [1, 2, 3]\n"
         with self.assertRaises(black.NothingChanged):
         same = "l = [1, 2, 3]\n"
         with self.assertRaises(black.NothingChanged):

-            black.format_file_contents(same, line_length=ll, fast=False)
+            black.format_file_contents(same, mode=mode, fast=False)

         different = "l = [1,2,3]"
         expected = same
         different = "l = [1,2,3]"
         expected = same

-        actual = black.format_file_contents(different, line_length=ll, fast=False)
+        actual = black.format_file_contents(different, mode=mode, fast=False)

         self.assertEqual(expected, actual)
         invalid = "return if you can"
         self.assertEqual(expected, actual)
         invalid = "return if you can"

-        with self.assertRaises(ValueError) as e:
-            black.format_file_contents(invalid, line_length=ll, fast=False)
+        with self.assertRaises(black.InvalidInput) as e:
+            black.format_file_contents(invalid, mode=mode, fast=False)

         self.assertEqual(str(e.exception), "Cannot parse: 1:7: return if you can")
 
     def test_endmarker(self) -> None:
         self.assertEqual(str(e.exception), "Cannot parse: 1:7: return if you can")
 
     def test_endmarker(self) -> None:


@@ -847,35 +935,33 @@ class BlackTestCase(unittest.TestCase):
         self.assertEqual("".join(err_lines), "")
 
     def test_cache_broken_file(self) -> None:
         self.assertEqual("".join(err_lines), "")
 
     def test_cache_broken_file(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir() as workspace:
         with cache_dir() as workspace:

-            cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH, mode)
+            cache_file = black.get_cache_file(mode)

             with cache_file.open("w") as fobj:
                 fobj.write("this is not a pickle")
             with cache_file.open("w") as fobj:
                 fobj.write("this is not a pickle")

-            self.assertEqual(black.read_cache(black.DEFAULT_LINE_LENGTH, mode), {})
+            self.assertEqual(black.read_cache(mode), {})

             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")

-            result = CliRunner().invoke(black.main, [str(src)])
-            self.assertEqual(result.exit_code, 0)
-            cache = black.read_cache(black.DEFAULT_LINE_LENGTH, mode)
+            self.invokeBlack([str(src)])
+            cache = black.read_cache(mode)

             self.assertIn(src, cache)
 
     def test_cache_single_file_already_cached(self) -> None:
             self.assertIn(src, cache)
 
     def test_cache_single_file_already_cached(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")
         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")

-            black.write_cache({}, [src], black.DEFAULT_LINE_LENGTH, mode)
-            result = CliRunner().invoke(black.main, [str(src)])
-            self.assertEqual(result.exit_code, 0)
+            black.write_cache({}, [src], mode)
+            self.invokeBlack([str(src)])

             with src.open("r") as fobj:
                 self.assertEqual(fobj.read(), "print('hello')")
 
     @event_loop(close=False)
     def test_cache_multiple_files(self) -> None:
             with src.open("r") as fobj:
                 self.assertEqual(fobj.read(), "print('hello')")
 
     @event_loop(close=False)
     def test_cache_multiple_files(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir() as workspace, patch(
             "black.ProcessPoolExecutor", new=ThreadPoolExecutor
         ):
         with cache_dir() as workspace, patch(
             "black.ProcessPoolExecutor", new=ThreadPoolExecutor
         ):


@@ -885,50 +971,48 @@ class BlackTestCase(unittest.TestCase):
             two = (workspace / "two.py").resolve()
             with two.open("w") as fobj:
                 fobj.write("print('hello')")
             two = (workspace / "two.py").resolve()
             with two.open("w") as fobj:
                 fobj.write("print('hello')")

-            black.write_cache({}, [one], black.DEFAULT_LINE_LENGTH, mode)
-            result = CliRunner().invoke(black.main, [str(workspace)])
-            self.assertEqual(result.exit_code, 0)
+            black.write_cache({}, [one], mode)
+            self.invokeBlack([str(workspace)])

             with one.open("r") as fobj:
                 self.assertEqual(fobj.read(), "print('hello')")
             with two.open("r") as fobj:
                 self.assertEqual(fobj.read(), 'print("hello")\n')
             with one.open("r") as fobj:
                 self.assertEqual(fobj.read(), "print('hello')")
             with two.open("r") as fobj:
                 self.assertEqual(fobj.read(), 'print("hello")\n')

-            cache = black.read_cache(black.DEFAULT_LINE_LENGTH, mode)
+            cache = black.read_cache(mode)

             self.assertIn(one, cache)
             self.assertIn(two, cache)
 
     def test_no_cache_when_writeback_diff(self) -> None:
             self.assertIn(one, cache)
             self.assertIn(two, cache)
 
     def test_no_cache_when_writeback_diff(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")
         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")

-            result = CliRunner().invoke(black.main, [str(src), "--diff"])
-            self.assertEqual(result.exit_code, 0)
-            cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH, mode)
+            self.invokeBlack([str(src), "--diff"])
+            cache_file = black.get_cache_file(mode)

             self.assertFalse(cache_file.exists())
 
     def test_no_cache_when_stdin(self) -> None:
             self.assertFalse(cache_file.exists())
 
     def test_no_cache_when_stdin(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir():
             result = CliRunner().invoke(
                 black.main, ["-"], input=BytesIO(b"print('hello')")
             )
             self.assertEqual(result.exit_code, 0)
         with cache_dir():
             result = CliRunner().invoke(
                 black.main, ["-"], input=BytesIO(b"print('hello')")
             )
             self.assertEqual(result.exit_code, 0)

-            cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH, mode)
+            cache_file = black.get_cache_file(mode)

             self.assertFalse(cache_file.exists())
 
     def test_read_cache_no_cachefile(self) -> None:
             self.assertFalse(cache_file.exists())
 
     def test_read_cache_no_cachefile(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir():
         with cache_dir():

-            self.assertEqual(black.read_cache(black.DEFAULT_LINE_LENGTH, mode), {})
+            self.assertEqual(black.read_cache(mode), {})

 
     def test_write_cache_read_cache(self) -> None:
 
     def test_write_cache_read_cache(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             src.touch()
         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             src.touch()

-            black.write_cache({}, [src], black.DEFAULT_LINE_LENGTH, mode)
-            cache = black.read_cache(black.DEFAULT_LINE_LENGTH, mode)
+            black.write_cache({}, [src], mode)
+            cache = black.read_cache(mode)

             self.assertIn(src, cache)
             self.assertEqual(cache[src], black.get_cache_info(src))
 
             self.assertIn(src, cache)
             self.assertEqual(cache[src], black.get_cache_info(src))
 


@@ -949,15 +1033,15 @@ class BlackTestCase(unittest.TestCase):
             self.assertEqual(done, {cached})
 
     def test_write_cache_creates_directory_if_needed(self) -> None:
             self.assertEqual(done, {cached})
 
     def test_write_cache_creates_directory_if_needed(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir(exists=False) as workspace:
             self.assertFalse(workspace.exists())
         with cache_dir(exists=False) as workspace:
             self.assertFalse(workspace.exists())

-            black.write_cache({}, [], black.DEFAULT_LINE_LENGTH, mode)
+            black.write_cache({}, [], mode)

             self.assertTrue(workspace.exists())
 
     @event_loop(close=False)
     def test_failed_formatting_does_not_get_cached(self) -> None:
             self.assertTrue(workspace.exists())
 
     @event_loop(close=False)
     def test_failed_formatting_does_not_get_cached(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir() as workspace, patch(
             "black.ProcessPoolExecutor", new=ThreadPoolExecutor
         ):
         with cache_dir() as workspace, patch(
             "black.ProcessPoolExecutor", new=ThreadPoolExecutor
         ):


@@ -967,40 +1051,33 @@ class BlackTestCase(unittest.TestCase):
             clean = (workspace / "clean.py").resolve()
             with clean.open("w") as fobj:
                 fobj.write('print("hello")\n')
             clean = (workspace / "clean.py").resolve()
             with clean.open("w") as fobj:
                 fobj.write('print("hello")\n')

-            result = CliRunner().invoke(black.main, [str(workspace)])
-            self.assertEqual(result.exit_code, 123)
-            cache = black.read_cache(black.DEFAULT_LINE_LENGTH, mode)
+            self.invokeBlack([str(workspace)], exit_code=123)
+            cache = black.read_cache(mode)

             self.assertNotIn(failing, cache)
             self.assertIn(clean, cache)
 
     def test_write_cache_write_fail(self) -> None:
             self.assertNotIn(failing, cache)
             self.assertIn(clean, cache)
 
     def test_write_cache_write_fail(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()

         with cache_dir(), patch.object(Path, "open") as mock:
             mock.side_effect = OSError
         with cache_dir(), patch.object(Path, "open") as mock:
             mock.side_effect = OSError

-            black.write_cache({}, [], black.DEFAULT_LINE_LENGTH, mode)
+            black.write_cache({}, [], mode)

 
     @event_loop(close=False)
     def test_check_diff_use_together(self) -> None:
         with cache_dir():
             # Files which will be reformatted.
             src1 = (THIS_DIR / "data" / "string_quotes.py").resolve()
 
     @event_loop(close=False)
     def test_check_diff_use_together(self) -> None:
         with cache_dir():
             # Files which will be reformatted.
             src1 = (THIS_DIR / "data" / "string_quotes.py").resolve()

-            result = CliRunner().invoke(black.main, [str(src1), "--diff", "--check"])
-            self.assertEqual(result.exit_code, 1, result.output)
+            self.invokeBlack([str(src1), "--diff", "--check"], exit_code=1)

             # Files which will not be reformatted.
             src2 = (THIS_DIR / "data" / "composition.py").resolve()
             # Files which will not be reformatted.
             src2 = (THIS_DIR / "data" / "composition.py").resolve()

-            result = CliRunner().invoke(black.main, [str(src2), "--diff", "--check"])
-            self.assertEqual(result.exit_code, 0, result.output)
+            self.invokeBlack([str(src2), "--diff", "--check"])

             # Multi file command.
             # Multi file command.

-            result = CliRunner().invoke(
-                black.main, [str(src1), str(src2), "--diff", "--check"]
-            )
-            self.assertEqual(result.exit_code, 1, result.output)
+            self.invokeBlack([str(src1), str(src2), "--diff", "--check"], exit_code=1)

 
     def test_no_files(self) -> None:
         with cache_dir():
             # Without an argument, black exits with error code 0.
 
     def test_no_files(self) -> None:
         with cache_dir():
             # Without an argument, black exits with error code 0.

-            result = CliRunner().invoke(black.main, [])
-            self.assertEqual(result.exit_code, 0)
+            self.invokeBlack([])

 
     def test_broken_symlink(self) -> None:
         with cache_dir() as workspace:
 
     def test_broken_symlink(self) -> None:
         with cache_dir() as workspace:


@@ -1009,43 +1086,42 @@ class BlackTestCase(unittest.TestCase):
                 symlink.symlink_to("nonexistent.py")
             except OSError as e:
                 self.skipTest(f"Can't create symlinks: {e}")
                 symlink.symlink_to("nonexistent.py")
             except OSError as e:
                 self.skipTest(f"Can't create symlinks: {e}")

-            result = CliRunner().invoke(black.main, [str(workspace.resolve())])
-            self.assertEqual(result.exit_code, 0)
+            self.invokeBlack([str(workspace.resolve())])

 
     def test_read_cache_line_lengths(self) -> None:
 
     def test_read_cache_line_lengths(self) -> None:

-        mode = black.FileMode.AUTO_DETECT
+        mode = black.FileMode()
+        short_mode = black.FileMode(line_length=1)

         with cache_dir() as workspace:
             path = (workspace / "file.py").resolve()
             path.touch()
         with cache_dir() as workspace:
             path = (workspace / "file.py").resolve()
             path.touch()

-            black.write_cache({}, [path], 1, mode)
-            one = black.read_cache(1, mode)
+            black.write_cache({}, [path], mode)
+            one = black.read_cache(mode)

             self.assertIn(path, one)
             self.assertIn(path, one)

-            two = black.read_cache(2, mode)
+            two = black.read_cache(short_mode)

             self.assertNotIn(path, two)
 
     def test_single_file_force_pyi(self) -> None:
             self.assertNotIn(path, two)
 
     def test_single_file_force_pyi(self) -> None:

-        reg_mode = black.FileMode.AUTO_DETECT
-        pyi_mode = black.FileMode.PYI
+        reg_mode = black.FileMode()
+        pyi_mode = black.FileMode(is_pyi=True)

         contents, expected = read_data("force_pyi")
         with cache_dir() as workspace:
             path = (workspace / "file.py").resolve()
             with open(path, "w") as fh:
                 fh.write(contents)
         contents, expected = read_data("force_pyi")
         with cache_dir() as workspace:
             path = (workspace / "file.py").resolve()
             with open(path, "w") as fh:
                 fh.write(contents)

-            result = CliRunner().invoke(black.main, [str(path), "--pyi"])
-            self.assertEqual(result.exit_code, 0)
+            self.invokeBlack([str(path), "--pyi"])

             with open(path, "r") as fh:
                 actual = fh.read()
             # verify cache with --pyi is separate
             with open(path, "r") as fh:
                 actual = fh.read()
             # verify cache with --pyi is separate

-            pyi_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, pyi_mode)
+            pyi_cache = black.read_cache(pyi_mode)

             self.assertIn(path, pyi_cache)
             self.assertIn(path, pyi_cache)

-            normal_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, reg_mode)
+            normal_cache = black.read_cache(reg_mode)

             self.assertNotIn(path, normal_cache)
         self.assertEqual(actual, expected)
 
     @event_loop(close=False)
     def test_multi_file_force_pyi(self) -> None:
             self.assertNotIn(path, normal_cache)
         self.assertEqual(actual, expected)
 
     @event_loop(close=False)
     def test_multi_file_force_pyi(self) -> None:

-        reg_mode = black.FileMode.AUTO_DETECT
-        pyi_mode = black.FileMode.PYI
+        reg_mode = black.FileMode()
+        pyi_mode = black.FileMode(is_pyi=True)

         contents, expected = read_data("force_pyi")
         with cache_dir() as workspace:
             paths = [
         contents, expected = read_data("force_pyi")
         with cache_dir() as workspace:
             paths = [


@@ -1055,15 +1131,14 @@ class BlackTestCase(unittest.TestCase):
             for path in paths:
                 with open(path, "w") as fh:
                     fh.write(contents)
             for path in paths:
                 with open(path, "w") as fh:
                     fh.write(contents)

-            result = CliRunner().invoke(black.main, [str(p) for p in paths] + ["--pyi"])
-            self.assertEqual(result.exit_code, 0)
+            self.invokeBlack([str(p) for p in paths] + ["--pyi"])

             for path in paths:
                 with open(path, "r") as fh:
                     actual = fh.read()
                 self.assertEqual(actual, expected)
             # verify cache with --pyi is separate
             for path in paths:
                 with open(path, "r") as fh:
                     actual = fh.read()
                 self.assertEqual(actual, expected)
             # verify cache with --pyi is separate

-            pyi_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, pyi_mode)
-            normal_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, reg_mode)
+            pyi_cache = black.read_cache(pyi_mode)
+            normal_cache = black.read_cache(reg_mode)

             for path in paths:
                 self.assertIn(path, pyi_cache)
                 self.assertNotIn(path, normal_cache)
             for path in paths:
                 self.assertIn(path, pyi_cache)
                 self.assertNotIn(path, normal_cache)


@@ -1078,28 +1153,27 @@ class BlackTestCase(unittest.TestCase):
         self.assertFormatEqual(actual, expected)
 
     def test_single_file_force_py36(self) -> None:
         self.assertFormatEqual(actual, expected)
 
     def test_single_file_force_py36(self) -> None:

-        reg_mode = black.FileMode.AUTO_DETECT
-        py36_mode = black.FileMode.PYTHON36
+        reg_mode = black.FileMode()
+        py36_mode = black.FileMode(target_versions=black.PY36_VERSIONS)

         source, expected = read_data("force_py36")
         with cache_dir() as workspace:
             path = (workspace / "file.py").resolve()
             with open(path, "w") as fh:
                 fh.write(source)
         source, expected = read_data("force_py36")
         with cache_dir() as workspace:
             path = (workspace / "file.py").resolve()
             with open(path, "w") as fh:
                 fh.write(source)

-            result = CliRunner().invoke(black.main, [str(path), "--py36"])
-            self.assertEqual(result.exit_code, 0)
+            self.invokeBlack([str(path), "--py36"])

             with open(path, "r") as fh:
                 actual = fh.read()
             # verify cache with --py36 is separate
             with open(path, "r") as fh:
                 actual = fh.read()
             # verify cache with --py36 is separate

-            py36_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, py36_mode)
+            py36_cache = black.read_cache(py36_mode)

             self.assertIn(path, py36_cache)
             self.assertIn(path, py36_cache)

-            normal_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, reg_mode)
+            normal_cache = black.read_cache(reg_mode)

             self.assertNotIn(path, normal_cache)
         self.assertEqual(actual, expected)
 
     @event_loop(close=False)
     def test_multi_file_force_py36(self) -> None:
             self.assertNotIn(path, normal_cache)
         self.assertEqual(actual, expected)
 
     @event_loop(close=False)
     def test_multi_file_force_py36(self) -> None:

-        reg_mode = black.FileMode.AUTO_DETECT
-        py36_mode = black.FileMode.PYTHON36
+        reg_mode = black.FileMode()
+        py36_mode = black.FileMode(target_versions=black.PY36_VERSIONS)

         source, expected = read_data("force_py36")
         with cache_dir() as workspace:
             paths = [
         source, expected = read_data("force_py36")
         with cache_dir() as workspace:
             paths = [


@@ -1109,17 +1183,14 @@ class BlackTestCase(unittest.TestCase):
             for path in paths:
                 with open(path, "w") as fh:
                     fh.write(source)
             for path in paths:
                 with open(path, "w") as fh:
                     fh.write(source)

-            result = CliRunner().invoke(
-                black.main, [str(p) for p in paths] + ["--py36"]
-            )
-            self.assertEqual(result.exit_code, 0)
+            self.invokeBlack([str(p) for p in paths] + ["--py36"])

             for path in paths:
                 with open(path, "r") as fh:
                     actual = fh.read()
                 self.assertEqual(actual, expected)
             # verify cache with --py36 is separate
             for path in paths:
                 with open(path, "r") as fh:
                     actual = fh.read()
                 self.assertEqual(actual, expected)
             # verify cache with --py36 is separate

-            pyi_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, py36_mode)
-            normal_cache = black.read_cache(black.DEFAULT_LINE_LENGTH, reg_mode)
+            pyi_cache = black.read_cache(py36_mode)
+            normal_cache = black.read_cache(reg_mode)

             for path in paths:
                 self.assertIn(path, pyi_cache)
                 self.assertNotIn(path, normal_cache)
             for path in paths:
                 self.assertIn(path, pyi_cache)
                 self.assertNotIn(path, normal_cache)


@@ -1196,8 +1267,7 @@ class BlackTestCase(unittest.TestCase):
 
     def test_invalid_include_exclude(self) -> None:
         for option in ["--include", "--exclude"]:
 
     def test_invalid_include_exclude(self) -> None:
         for option in ["--include", "--exclude"]:

-            result = CliRunner().invoke(black.main, ["-", option, "**()(!!*)"])
-            self.assertEqual(result.exit_code, 2)
+            self.invokeBlack(["-", option, "**()(!!*)"], exit_code=2)

 
     def test_preserves_line_endings(self) -> None:
         with TemporaryDirectory() as workspace:
 
     def test_preserves_line_endings(self) -> None:
         with TemporaryDirectory() as workspace:


@@ -1211,6 +1281,19 @@ class BlackTestCase(unittest.TestCase):
                 if nl == "\n":
                     self.assertNotIn(b"\r\n", updated_contents)
 
                 if nl == "\n":
                     self.assertNotIn(b"\r\n", updated_contents)
 

+    def test_preserves_line_endings_via_stdin(self) -> None:
+        for nl in ["\n", "\r\n"]:
+            contents = nl.join(["def f(  ):", "    pass"])
+            runner = BlackRunner()
+            result = runner.invoke(
+                black.main, ["-", "--fast"], input=BytesIO(contents.encode("utf8"))
+            )
+            self.assertEqual(result.exit_code, 0)
+            output = runner.stdout_bytes
+            self.assertIn(nl.encode("utf8"), output)
+            if nl == "\n":
+                self.assertNotIn(b"\r\n", output)
+

     def test_assert_equivalent_different_asts(self) -> None:
         with self.assertRaises(AssertionError):
             black.assert_equivalent("{}", "None")
     def test_assert_equivalent_different_asts(self) -> None:
         with self.assertRaises(AssertionError):
             black.assert_equivalent("{}", "None")


@@ -1230,7 +1313,7 @@ class BlackTestCase(unittest.TestCase):
         try:
             list(black.gen_python_files_in_dir(path, root, include, exclude, report))
         except ValueError as ve:
         try:
             list(black.gen_python_files_in_dir(path, root, include, exclude, report))
         except ValueError as ve:

-            self.fail("`get_python_files_in_dir()` failed: {ve}")
+            self.fail(f"`get_python_files_in_dir()` failed: {ve}")

         path.iterdir.assert_called_once()
         child.resolve.assert_called_once()
         child.is_symlink.assert_called_once()
         path.iterdir.assert_called_once()
         child.resolve.assert_called_once()
         child.is_symlink.assert_called_once()


@@ -1268,6 +1351,172 @@ class BlackTestCase(unittest.TestCase):
             except RuntimeError as re:
                 self.fail(f"`patch_click()` failed, exception still raised: {re}")
 
             except RuntimeError as re:
                 self.fail(f"`patch_click()` failed, exception still raised: {re}")
 

+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_request_needs_formatting(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            response = await client.post("/", data=b"print('hello world')")
+            self.assertEqual(response.status, 200)
+            self.assertEqual(response.charset, "utf8")
+            self.assertEqual(await response.read(), b'print("hello world")\n')
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_request_no_change(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            response = await client.post("/", data=b'print("hello world")\n')
+            self.assertEqual(response.status, 204)
+            self.assertEqual(await response.read(), b"")
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_request_syntax_error(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            response = await client.post("/", data=b"what even ( is")
+            self.assertEqual(response.status, 400)
+            content = await response.text()
+            self.assertTrue(
+                content.startswith("Cannot parse"),
+                msg=f"Expected error to start with 'Cannot parse', got {repr(content)}",
+            )
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_unsupported_version(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            response = await client.post(
+                "/", data=b"what", headers={blackd.VERSION_HEADER: "2"}
+            )
+            self.assertEqual(response.status, 501)
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_supported_version(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            response = await client.post(
+                "/", data=b"what", headers={blackd.VERSION_HEADER: "1"}
+            )
+            self.assertEqual(response.status, 200)
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_invalid_python_variant(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+
+            async def check(header_value: str, expected_status: int = 400) -> None:
+                response = await client.post(
+                    "/",
+                    data=b"what",
+                    headers={blackd.PYTHON_VARIANT_HEADER: header_value},
+                )
+                self.assertEqual(response.status, expected_status)
+
+            await check("lol")
+            await check("ruby3.5")
+            await check("pyi3.6")
+            await check("cpy1.5")
+            await check("2.8")
+            await check("cpy2.8")
+            await check("3.0")
+            await check("pypy3.0")
+            await check("jython3.4")
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_pyi(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            source, expected = read_data("stub.pyi")
+            response = await client.post(
+                "/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"}
+            )
+            self.assertEqual(response.status, 200)
+            self.assertEqual(await response.text(), expected)
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_python_variant(self) -> None:
+        app = blackd.make_app()
+        code = (
+            "def f(\n"
+            "    and_has_a_bunch_of,\n"
+            "    very_long_arguments_too,\n"
+            "    and_lots_of_them_as_well_lol,\n"
+            "    **and_very_long_keyword_arguments\n"
+            "):\n"
+            "    pass\n"
+        )
+        async with TestClient(TestServer(app)) as client:
+
+            async def check(header_value: str, expected_status: int) -> None:
+                response = await client.post(
+                    "/", data=code, headers={blackd.PYTHON_VARIANT_HEADER: header_value}
+                )
+                self.assertEqual(response.status, expected_status)
+
+            await check("3.6", 200)
+            await check("cpy3.6", 200)
+            await check("3.5,3.7", 200)
+            await check("3.5,cpy3.7", 200)
+
+            await check("2", 204)
+            await check("2.7", 204)
+            await check("cpy2.7", 204)
+            await check("pypy2.7", 204)
+            await check("3.4", 204)
+            await check("cpy3.4", 204)
+            await check("pypy3.4", 204)
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_fast(self) -> None:
+        with open(os.devnull, "w") as dn, redirect_stderr(dn):
+            app = blackd.make_app()
+            async with TestClient(TestServer(app)) as client:
+                response = await client.post("/", data=b"ur'hello'")
+                self.assertEqual(response.status, 500)
+                self.assertIn("failed to parse source file", await response.text())
+                response = await client.post(
+                    "/", data=b"ur'hello'", headers={blackd.FAST_OR_SAFE_HEADER: "fast"}
+                )
+                self.assertEqual(response.status, 200)
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_line_length(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            response = await client.post(
+                "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "7"}
+            )
+            self.assertEqual(response.status, 200)
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @async_test
+    async def test_blackd_invalid_line_length(self) -> None:
+        app = blackd.make_app()
+        async with TestClient(TestServer(app)) as client:
+            response = await client.post(
+                "/",
+                data=b'print("hello")\n',
+                headers={blackd.LINE_LENGTH_HEADER: "NaN"},
+            )
+            self.assertEqual(response.status, 400)
+
+    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    def test_blackd_main(self) -> None:
+        with patch("blackd.web.run_app"):
+            result = CliRunner().invoke(blackd.main, [])
+            if result.exception is not None:
+                raise result.exception
+            self.assertEqual(result.exit_code, 0)
+

 
 if __name__ == "__main__":
     unittest.main(module="test_black")
 
 if __name__ == "__main__":
     unittest.main(module="test_black")