content: # Copyright 2016 Google Inc. All Rights Reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  """Python 3 tests for yapf.reformatter."""
  
  import sys
  import textwrap
  import unittest
  
  from yapf.yapflib import reformatter
  from yapf.yapflib import style
  
  from yapftests import yapf_test_helper
  
  
  class TestsForPython3Code(yapf_test_helper.YAPFTest):
    """Test a few constructs that are new Python 3 syntax."""
  
    @classmethod
    def setUpClass(cls):  # pylint: disable=g-missing-super-call
      style.SetGlobalStyle(style.CreatePEP8Style())
  
    def testTypedNames(self):
      unformatted_code = textwrap.dedent("""\
          def x(aaaaaaaaaaaaaaa:int,bbbbbbbbbbbbbbbb:str,ccccccccccccccc:dict,eeeeeeeeeeeeee:set={1, 2, 3})->bool:
            pass
      """)  # noqa
      expected_formatted_code = textwrap.dedent("""\
          def x(aaaaaaaaaaaaaaa: int,
                bbbbbbbbbbbbbbbb: str,
                ccccccccccccccc: dict,
                eeeeeeeeeeeeee: set = {1, 2, 3}) -> bool:
              pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testTypedNameWithLongNamedArg(self):
      unformatted_code = textwrap.dedent("""\
          def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters()) -> ReturnType:
            pass
      """)  # noqa
      expected_formatted_code = textwrap.dedent("""\
          def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters()
                   ) -> ReturnType:
              pass
      """)  # noqa
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testKeywordOnlyArgSpecifier(self):
      unformatted_code = textwrap.dedent("""\
          def foo(a, *, kw):
            return a+kw
      """)
      expected_formatted_code = textwrap.dedent("""\
          def foo(a, *, kw):
              return a + kw
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testAnnotations(self):
      unformatted_code = textwrap.dedent("""\
          def foo(a: list, b: "bar") -> dict:
            return a+b
      """)
      expected_formatted_code = textwrap.dedent("""\
          def foo(a: list, b: "bar") -> dict:
              return a + b
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testExecAsNonKeyword(self):
      unformatted_code = 'methods.exec( sys.modules[name])\n'
      expected_formatted_code = 'methods.exec(sys.modules[name])\n'
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testAsyncFunctions(self):
      code = textwrap.dedent("""\
          import asyncio
          import time
  
  
          @print_args
          async def slow_operation():
              await asyncio.sleep(1)
              # print("Slow operation {} complete".format(n))
  
  
          async def main():
              start = time.time()
              if (await get_html()):
                  pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testNoSpacesAroundPowerOperator(self):
      unformatted_code = textwrap.dedent("""\
          a**b
      """)
      expected_formatted_code = textwrap.dedent("""\
          a ** b
      """)
  
      try:
        style.SetGlobalStyle(
            style.CreateStyleFromConfig(
                '{based_on_style: pep8, SPACES_AROUND_POWER_OPERATOR: True}'))
  
        llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
        self.assertCodeEqual(expected_formatted_code,
                             reformatter.Reformat(llines))
      finally:
        style.SetGlobalStyle(style.CreatePEP8Style())
  
    def testSpacesAroundDefaultOrNamedAssign(self):
      unformatted_code = textwrap.dedent("""\
          f(a=5)
      """)
      expected_formatted_code = textwrap.dedent("""\
          f(a = 5)
      """)
  
      try:
        style.SetGlobalStyle(
            style.CreateStyleFromConfig(
                '{based_on_style: pep8, '
                'SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN: True}'))
  
        llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
        self.assertCodeEqual(expected_formatted_code,
                             reformatter.Reformat(llines))
      finally:
        style.SetGlobalStyle(style.CreatePEP8Style())
  
    def testTypeHint(self):
      unformatted_code = textwrap.dedent("""\
          def foo(x: int=42):
              pass
  
  
          def foo2(x: 'int' =42):
              pass
      """)
      expected_formatted_code = textwrap.dedent("""\
          def foo(x: int = 42):
              pass
  
  
          def foo2(x: 'int' = 42):
              pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testMatrixMultiplication(self):
      unformatted_code = textwrap.dedent("""\
          a=b@c
      """)
      expected_formatted_code = textwrap.dedent("""\
          a = b @ c
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testNoneKeyword(self):
      code = textwrap.dedent("""\
          None.__ne__()
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testAsyncWithPrecedingComment(self):
      unformatted_code = textwrap.dedent("""\
          import asyncio
  
          # Comment
          async def bar():
              pass
  
          async def foo():
              pass
      """)
      expected_formatted_code = textwrap.dedent("""\
          import asyncio
  
  
          # Comment
          async def bar():
              pass
  
  
          async def foo():
              pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testAsyncFunctionsNested(self):
      code = textwrap.dedent("""\
          async def outer():
  
              async def inner():
                  pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testKeepTypesIntact(self):
      unformatted_code = textwrap.dedent("""\
          def _ReduceAbstractContainers(
              self, *args: Optional[automation_converter.PyiCollectionAbc]) -> List[
                  automation_converter.PyiCollectionAbc]:
              pass
      """)  # noqa
      expected_formatted_code = textwrap.dedent("""\
          def _ReduceAbstractContainers(
              self, *args: Optional[automation_converter.PyiCollectionAbc]
          ) -> List[automation_converter.PyiCollectionAbc]:
              pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testContinuationIndentWithAsync(self):
      unformatted_code = textwrap.dedent("""\
          async def start_websocket():
              async with session.ws_connect(
                  r"ws://a_really_long_long_long_long_long_long_url") as ws:
                  pass
      """)
      expected_formatted_code = textwrap.dedent("""\
          async def start_websocket():
              async with session.ws_connect(
                      r"ws://a_really_long_long_long_long_long_long_url") as ws:
                  pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testSplittingArguments(self):
      unformatted_code = textwrap.dedent("""\
          async def open_file(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
              pass
  
          async def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None):
              pass
  
          def open_file(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
              pass
  
          def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None):
              pass
      """)  # noqa
      expected_formatted_code = textwrap.dedent("""\
          async def open_file(
              file,
              mode='r',
              buffering=-1,
              encoding=None,
              errors=None,
              newline=None,
              closefd=True,
              opener=None
          ):
              pass
  
  
          async def run_sync_in_worker_thread(
              sync_fn, *args, cancellable=False, limiter=None
          ):
              pass
  
  
          def open_file(
              file,
              mode='r',
              buffering=-1,
              encoding=None,
              errors=None,
              newline=None,
              closefd=True,
              opener=None
          ):
              pass
  
  
          def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None):
              pass
      """)  # noqa
  
      try:
        style.SetGlobalStyle(
            style.CreateStyleFromConfig(
                '{based_on_style: pep8, '
                'dedent_closing_brackets: true, '
                'coalesce_brackets: false, '
                'space_between_ending_comma_and_closing_bracket: false, '
                'split_arguments_when_comma_terminated: true, '
                'split_before_first_argument: true}'))
  
        llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
        self.assertCodeEqual(expected_formatted_code,
                             reformatter.Reformat(llines))
      finally:
        style.SetGlobalStyle(style.CreatePEP8Style())
  
    def testDictUnpacking(self):
      unformatted_code = textwrap.dedent("""\
          class Foo:
              def foo(self):
                  foofoofoofoofoofoofoofoo('foofoofoofoofoo', {
  
                      'foo': 'foo',
  
                      **foofoofoo
                  })
      """)
      expected_formatted_code = textwrap.dedent("""\
          class Foo:
  
              def foo(self):
                  foofoofoofoofoofoofoofoo('foofoofoofoofoo', {
                      'foo': 'foo',
                      **foofoofoo
                  })
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testMultilineFormatString(self):
      # https://github.com/google/yapf/issues/513
      code = textwrap.dedent("""\
          # yapf: disable
          (f'''
            ''')
          # yapf: enable
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testEllipses(self):
      # https://github.com/google/yapf/issues/533
      code = textwrap.dedent("""\
          def dirichlet(x12345678901234567890123456789012345678901234567890=...) -> None:
              return
      """)  # noqa
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testFunctionTypedReturnNextLine(self):
      code = textwrap.dedent("""\
          def _GenerateStatsEntries(
              process_id: Text,
              timestamp: Optional[ffffffff.FFFFFFFFFFF] = None
          ) -> Sequence[ssssssssssss.SSSSSSSSSSSSSSS]:
              pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testFunctionTypedReturnSameLine(self):
      code = textwrap.dedent("""\
          def rrrrrrrrrrrrrrrrrrrrrr(
                  ccccccccccccccccccccccc: Tuple[Text, Text]) -> List[Tuple[Text, Text]]:
              pass
      """)  # noqa
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testAsyncForElseNotIndentedInsideBody(self):
      code = textwrap.dedent("""\
          async def fn():
              async for message in websocket:
                  for i in range(10):
                      pass
                  else:
                      pass
              else:
                  pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testForElseInAsyncNotMixedWithAsyncFor(self):
      code = textwrap.dedent("""\
          async def fn():
              for i in range(10):
                  pass
              else:
                  pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testParameterListIndentationConflicts(self):
      unformatted_code = textwrap.dedent("""\
          def raw_message(  # pylint: disable=too-many-arguments
                      self, text, user_id=1000, chat_type='private', forward_date=None, forward_from=None):
                  pass
      """)  # noqa
      expected_formatted_code = textwrap.dedent("""\
          def raw_message(  # pylint: disable=too-many-arguments
                  self,
                  text,
                  user_id=1000,
                  chat_type='private',
                  forward_date=None,
                  forward_from=None):
              pass
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testTypeHintedYieldExpression(self):
      # https://github.com/google/yapf/issues/1092
      code = textwrap.dedent("""\
         def my_coroutine():
             x: int = yield
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testSyntaxMatch(self):
      # https://github.com/google/yapf/issues/1045
      # https://github.com/google/yapf/issues/1085
      unformatted_code = textwrap.dedent("""\
          a=3
          b=0
          match a :
              case 0 :
                  b=1
              case _	:
                  b=2
      """)
      expected_formatted_code = textwrap.dedent("""\
          a = 3
          b = 0
          match a:
              case 0:
                  b = 1
              case _:
                  b = 2
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testParenthsizedContextManager(self):
      # https://github.com/google/yapf/issues/1064
      unformatted_code = textwrap.dedent("""\
          def test_copy_dimension(self):
              with (Dataset() as target_ds,
                    Dataset() as source_ds):
                  do_something
      """)
      expected_formatted_code = textwrap.dedent("""\
          def test_copy_dimension(self):
              with (Dataset() as target_ds, Dataset() as source_ds):
                  do_something
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testUnpackedTuple(self):
      # https://github.com/google/yapf/issues/830
      # https://github.com/google/yapf/issues/1060
      unformatted_code = textwrap.dedent("""\
          def a():
            t = (2,3)
            for i in range(5):
              yield i,*t
      """)
      expected_formatted_code = textwrap.dedent("""\
          def a():
              t = (2, 3)
              for i in range(5):
                  yield i, *t
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testTypedTuple(self):
      # https://github.com/google/yapf/issues/412
      # https://github.com/google/yapf/issues/1058
      code = textwrap.dedent("""\
          t: tuple = 1, 2
          args = tuple(x for x in [2], )
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
    def testWalrusOperator(self):
      # https://github.com/google/yapf/issues/894
      unformatted_code = textwrap.dedent("""\
          import os
          a=[1,2,3,4]
          if (n:=len(a))>2:
              print()
      """)
      expected_formatted_code = textwrap.dedent("""\
          import os
  
          a = [1, 2, 3, 4]
          if (n := len(a)) > 2:
              print()
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testCondAssign(self):
      # https://github.com/google/yapf/issues/856
      unformatted_code = textwrap.dedent("""\
          def json(self) -> JSONTask:
                  result: JSONTask = {
                      "id": self.id,
                      "text": self.text,
                      "status": self.status,
                      "last_mod": self.last_mod_time
                  }
                  for i in "parent_id", "deadline", "reminder":
                      if x := getattr(self , i):
                          result[i] = x  # type: ignore
                  return result
      """)
      expected_formatted_code = textwrap.dedent("""\
          def json(self) -> JSONTask:
              result: JSONTask = {
                  "id": self.id,
                  "text": self.text,
                  "status": self.status,
                  "last_mod": self.last_mod_time
              }
              for i in "parent_id", "deadline", "reminder":
                  if x := getattr(self, i):
                      result[i] = x  # type: ignore
              return result
      """)
      llines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
      self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines))
  
    def testCopyDictionary(self):
      # https://github.com/google/yapf/issues/233
      # https://github.com/google/yapf/issues/402
      code = textwrap.dedent("""\
          a_dict = {'key': 'value'}
          a_dict_copy = {**a_dict}
          print('a_dict:', a_dict)
          print('a_dict_copy:', a_dict_copy)
      """)
      llines = yapf_test_helper.ParseAndUnwrap(code)
      self.assertCodeEqual(code, reformatter.Reformat(llines))
  
  
  if __name__ == '__main__':
    unittest.main()
  