| # 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. |
| """PEP8 tests for yapf.reformatter.""" |
| |
| import textwrap |
| import unittest |
| |
| from yapf.yapflib import py3compat |
| from yapf.yapflib import reformatter |
| from yapf.yapflib import style |
| |
| from yapftests import yapf_test_helper |
| |
| |
| class TestsForPEP8Style(yapf_test_helper.YAPFTest): |
| |
| @classmethod |
| def setUpClass(cls): # pylint: disable=g-missing-super-call |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| |
| def testIndent4(self): |
| unformatted_code = textwrap.dedent("""\ |
| if a+b: |
| pass |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| if a + b: |
| pass |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testSingleLineIfStatements(self): |
| code = textwrap.dedent("""\ |
| if True: a = 42 |
| elif False: b = 42 |
| else: c = 42 |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(code) |
| self.assertCodeEqual(code, reformatter.Reformat(llines)) |
| |
| def testBlankBetweenClassAndDef(self): |
| unformatted_code = textwrap.dedent("""\ |
| class Foo: |
| def joe(): |
| pass |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| class Foo: |
| |
| def joe(): |
| pass |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testBlankBetweenDefsInClass(self): |
| unformatted_code = textwrap.dedent('''\ |
| class TestClass: |
| def __init__(self): |
| self.running = False |
| def run(self): |
| """Override in subclass""" |
| def is_running(self): |
| return self.running |
| ''') |
| expected_formatted_code = textwrap.dedent('''\ |
| class TestClass: |
| |
| def __init__(self): |
| self.running = False |
| |
| def run(self): |
| """Override in subclass""" |
| |
| def is_running(self): |
| return self.running |
| ''') |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testSingleWhiteBeforeTrailingComment(self): |
| unformatted_code = textwrap.dedent("""\ |
| if a+b: # comment |
| pass |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| if a + b: # comment |
| pass |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testSpaceBetweenEndingCommandAndClosingBracket(self): |
| unformatted_code = textwrap.dedent("""\ |
| a = ( |
| 1, |
| ) |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| a = (1, ) |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testContinuedNonOutdentedLine(self): |
| code = textwrap.dedent("""\ |
| class eld(d): |
| if str(geom.geom_type).upper( |
| ) != self.geom_type and not self.geom_type == 'GEOMETRY': |
| ror(code='om_type') |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(code) |
| self.assertCodeEqual(code, reformatter.Reformat(llines)) |
| |
| def testWrappingPercentExpressions(self): |
| unformatted_code = textwrap.dedent("""\ |
| def f(): |
| if True: |
| zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) |
| zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) |
| zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) |
| zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| def f(): |
| if True: |
| zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, |
| xxxxxxxxxxxxxxxxx.yyy + 1) |
| zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, |
| xxxxxxxxxxxxxxxxx.yyy + 1) |
| zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1, |
| xxxxxxxxxxxxxxxxxxxxx + 1) |
| zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1, |
| xxxxxxxxxxxxxxxxxxxxx + 1) |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testAlignClosingBracketWithVisualIndentation(self): |
| unformatted_code = textwrap.dedent("""\ |
| TEST_LIST = ('foo', 'bar', # first comment |
| 'baz' # second comment |
| ) |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| TEST_LIST = ( |
| 'foo', |
| 'bar', # first comment |
| 'baz' # second comment |
| ) |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| unformatted_code = textwrap.dedent("""\ |
| def f(): |
| |
| def g(): |
| while (xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and |
| xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb' |
| ): |
| pass |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| def f(): |
| |
| def g(): |
| while (xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' |
| and xxxxxxxxxxxxxxxxxxxx( |
| yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'): |
| pass |
| """) # noqa |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testIndentSizeChanging(self): |
| unformatted_code = textwrap.dedent("""\ |
| if True: |
| runtime_mins = (program_end_time - program_start_time).total_seconds() / 60.0 |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| if True: |
| runtime_mins = (program_end_time - |
| program_start_time).total_seconds() / 60.0 |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testHangingIndentCollision(self): |
| unformatted_code = textwrap.dedent("""\ |
| if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy): |
| pass |
| elif (xxxxxxxxxxxxxxx(aaaaaaaaaaa, bbbbbbbbbbbbbb, cccccccccccc, dddddddddd=None)): |
| pass |
| |
| |
| def h(): |
| if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): |
| pass |
| |
| for connection in itertools.chain(branch.contact, branch.address, morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore): |
| dosomething(connection) |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx |
| or yyyyyyyyyyyyyyyyy): |
| pass |
| elif (xxxxxxxxxxxxxxx(aaaaaaaaaaa, |
| bbbbbbbbbbbbbb, |
| cccccccccccc, |
| dddddddddd=None)): |
| pass |
| |
| |
| def h(): |
| if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and |
| xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): |
| pass |
| |
| for connection in itertools.chain( |
| branch.contact, branch.address, |
| morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore): |
| dosomething(connection) |
| """) # noqa |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testSplittingBeforeLogicalOperator(self): |
| try: |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig( |
| '{based_on_style: pep8, split_before_logical_operator: True}')) |
| unformatted_code = textwrap.dedent("""\ |
| def foo(): |
| return bool(update.message.new_chat_member or update.message.left_chat_member or |
| update.message.new_chat_title or update.message.new_chat_photo or |
| update.message.delete_chat_photo or update.message.group_chat_created or |
| update.message.supergroup_chat_created or update.message.channel_chat_created |
| or update.message.migrate_to_chat_id or update.message.migrate_from_chat_id or |
| update.message.pinned_message) |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| def foo(): |
| return bool( |
| update.message.new_chat_member or update.message.left_chat_member |
| or update.message.new_chat_title or update.message.new_chat_photo |
| or update.message.delete_chat_photo |
| or update.message.group_chat_created |
| or update.message.supergroup_chat_created |
| or update.message.channel_chat_created |
| or update.message.migrate_to_chat_id |
| or update.message.migrate_from_chat_id |
| or update.message.pinned_message) |
| """) # noqa |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| finally: |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| |
| def testContiguousListEndingWithComment(self): |
| unformatted_code = textwrap.dedent("""\ |
| if True: |
| if True: |
| keys.append(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned. |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| if True: |
| if True: |
| keys.append( |
| aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned. |
| """) # noqa |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testSplittingBeforeFirstArgument(self): |
| try: |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig( |
| '{based_on_style: pep8, split_before_first_argument: True}')) |
| unformatted_code = textwrap.dedent("""\ |
| a_very_long_function_name(long_argument_name_1=1, long_argument_name_2=2, |
| long_argument_name_3=3, long_argument_name_4=4) |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| a_very_long_function_name( |
| long_argument_name_1=1, |
| long_argument_name_2=2, |
| long_argument_name_3=3, |
| long_argument_name_4=4) |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| finally: |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| |
| def testSplittingExpressionsInsideSubscripts(self): |
| unformatted_code = textwrap.dedent("""\ |
| def foo(): |
| df = df[(df['campaign_status'] == 'LIVE') & (df['action_status'] == 'LIVE')] |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| def foo(): |
| df = df[(df['campaign_status'] == 'LIVE') |
| & (df['action_status'] == 'LIVE')] |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testSplitListsAndDictSetMakersIfCommaTerminated(self): |
| unformatted_code = textwrap.dedent("""\ |
| DJANGO_TEMPLATES_OPTIONS = {"context_processors": []} |
| DJANGO_TEMPLATES_OPTIONS = {"context_processors": [],} |
| x = ["context_processors"] |
| x = ["context_processors",] |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| DJANGO_TEMPLATES_OPTIONS = {"context_processors": []} |
| DJANGO_TEMPLATES_OPTIONS = { |
| "context_processors": [], |
| } |
| x = ["context_processors"] |
| x = [ |
| "context_processors", |
| ] |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testSplitAroundNamedAssigns(self): |
| unformatted_code = textwrap.dedent("""\ |
| class a(): |
| |
| def a(): return a( |
| aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| class a(): |
| |
| def a(): |
| return a( |
| aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa |
| ) |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testUnaryOperator(self): |
| unformatted_code = textwrap.dedent("""\ |
| if not -3 < x < 3: |
| pass |
| if -3 < x < 3: |
| pass |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| if not -3 < x < 3: |
| pass |
| if -3 < x < 3: |
| pass |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testNoSplitBeforeDictValue(self): |
| try: |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig('{based_on_style: pep8, ' |
| 'allow_split_before_dict_value: false, ' |
| 'coalesce_brackets: true, ' |
| 'dedent_closing_brackets: true, ' |
| 'each_dict_entry_on_separate_line: true, ' |
| 'split_before_logical_operator: true}')) |
| |
| unformatted_code = textwrap.dedent("""\ |
| some_dict = { |
| 'title': _("I am example data"), |
| 'description': _("Lorem ipsum dolor met sit amet elit, si vis pacem para bellum " |
| "elites nihi very long string."), |
| } |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| some_dict = { |
| 'title': _("I am example data"), |
| 'description': _( |
| "Lorem ipsum dolor met sit amet elit, si vis pacem para bellum " |
| "elites nihi very long string." |
| ), |
| } |
| """) # noqa |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| |
| unformatted_code = textwrap.dedent("""\ |
| X = {'a': 1, 'b': 2, 'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure()} |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| X = { |
| 'a': 1, |
| 'b': 2, |
| 'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure() |
| } |
| """) # noqa |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| |
| unformatted_code = textwrap.dedent("""\ |
| attrs = { |
| 'category': category, |
| 'role': forms.ModelChoiceField(label=_("Role"), required=False, queryset=category_roles, initial=selected_role, empty_label=_("No access"),), |
| } |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| attrs = { |
| 'category': category, |
| 'role': forms.ModelChoiceField( |
| label=_("Role"), |
| required=False, |
| queryset=category_roles, |
| initial=selected_role, |
| empty_label=_("No access"), |
| ), |
| } |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| |
| unformatted_code = textwrap.dedent("""\ |
| css_class = forms.CharField( |
| label=_("CSS class"), |
| required=False, |
| help_text=_("Optional CSS class used to customize this category appearance from templates."), |
| ) |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| css_class = forms.CharField( |
| label=_("CSS class"), |
| required=False, |
| help_text=_( |
| "Optional CSS class used to customize this category appearance from templates." |
| ), |
| ) |
| """) # noqa |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| finally: |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| |
| def testBitwiseOperandSplitting(self): |
| unformatted_code = """\ |
| def _(): |
| include_values = np.where( |
| (cdffile['Quality_Flag'][:] >= 5) & ( |
| cdffile['Day_Night_Flag'][:] == 1) & ( |
| cdffile['Longitude'][:] >= select_lon - radius) & ( |
| cdffile['Longitude'][:] <= select_lon + radius) & ( |
| cdffile['Latitude'][:] >= select_lat - radius) & ( |
| cdffile['Latitude'][:] <= select_lat + radius)) |
| """ |
| expected_code = """\ |
| def _(): |
| include_values = np.where( |
| (cdffile['Quality_Flag'][:] >= 5) & (cdffile['Day_Night_Flag'][:] == 1) |
| & (cdffile['Longitude'][:] >= select_lon - radius) |
| & (cdffile['Longitude'][:] <= select_lon + radius) |
| & (cdffile['Latitude'][:] >= select_lat - radius) |
| & (cdffile['Latitude'][:] <= select_lat + radius)) |
| """ |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertEqual(expected_code, reformatter.Reformat(llines)) |
| |
| def testNoBlankLinesOnlyForFirstNestedObject(self): |
| unformatted_code = '''\ |
| class Demo: |
| """ |
| Demo docs |
| """ |
| def foo(self): |
| """ |
| foo docs |
| """ |
| def bar(self): |
| """ |
| bar docs |
| """ |
| ''' |
| expected_code = '''\ |
| class Demo: |
| """ |
| Demo docs |
| """ |
| |
| def foo(self): |
| """ |
| foo docs |
| """ |
| |
| def bar(self): |
| """ |
| bar docs |
| """ |
| ''' |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertEqual(expected_code, reformatter.Reformat(llines)) |
| |
| def testSplitBeforeArithmeticOperators(self): |
| try: |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig( |
| '{based_on_style: pep8, split_before_arithmetic_operator: true}')) |
| |
| unformatted_code = """\ |
| def _(): |
| raise ValueError('This is a long message that ends with an argument: ' + str(42)) |
| """ # noqa |
| expected_formatted_code = """\ |
| def _(): |
| raise ValueError('This is a long message that ends with an argument: ' |
| + str(42)) |
| """ |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| finally: |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| |
| def testListSplitting(self): |
| unformatted_code = """\ |
| foo([(1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), |
| (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), |
| (1,10), (1,11), (1, 10), (1,11), (10,11)]) |
| """ |
| expected_code = """\ |
| foo([(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), |
| (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 10), (1, 11), (1, 10), |
| (1, 11), (10, 11)]) |
| """ |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) |
| |
| def testNoBlankLineBeforeNestedFuncOrClass(self): |
| try: |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig( |
| '{based_on_style: pep8, ' |
| 'blank_line_before_nested_class_or_def: false}')) |
| |
| unformatted_code = '''\ |
| def normal_function(): |
| """Return the nested function.""" |
| |
| def nested_function(): |
| """Do nothing just nest within.""" |
| |
| @nested(klass) |
| class nested_class(): |
| pass |
| |
| pass |
| |
| return nested_function |
| ''' |
| expected_formatted_code = '''\ |
| def normal_function(): |
| """Return the nested function.""" |
| def nested_function(): |
| """Do nothing just nest within.""" |
| @nested(klass) |
| class nested_class(): |
| pass |
| |
| pass |
| |
| return nested_function |
| ''' |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, |
| reformatter.Reformat(llines)) |
| finally: |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| |
| def testParamListIndentationCollision1(self): |
| unformatted_code = textwrap.dedent("""\ |
| class _(): |
| |
| def __init__(self, title: Optional[str], diffs: Collection[BinaryDiff] = (), charset: Union[Type[AsciiCharset], Type[LineCharset]] = AsciiCharset, preprocess: Callable[[str], str] = identity, |
| # TODO(somebody): Make this a Literal type. |
| justify: str = 'rjust'): |
| self._cs = charset |
| self._preprocess = preprocess |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| class _(): |
| |
| def __init__( |
| self, |
| title: Optional[str], |
| diffs: Collection[BinaryDiff] = (), |
| charset: Union[Type[AsciiCharset], |
| Type[LineCharset]] = AsciiCharset, |
| preprocess: Callable[[str], str] = identity, |
| # TODO(somebody): Make this a Literal type. |
| justify: str = 'rjust'): |
| self._cs = charset |
| self._preprocess = preprocess |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testParamListIndentationCollision2(self): |
| code = textwrap.dedent("""\ |
| def simple_pass_function_with_an_extremely_long_name_and_some_arguments( |
| argument0, argument1): |
| pass |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(code) |
| self.assertCodeEqual(code, reformatter.Reformat(llines)) |
| |
| def testParamListIndentationCollision3(self): |
| code = textwrap.dedent("""\ |
| def func1( |
| arg1, |
| arg2, |
| ) -> None: |
| pass |
| |
| |
| def func2( |
| arg1, |
| arg2, |
| ): |
| pass |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(code) |
| self.assertCodeEqual(code, reformatter.Reformat(llines)) |
| |
| def testTwoWordComparisonOperators(self): |
| unformatted_code = textwrap.dedent("""\ |
| _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl is not ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj) |
| _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl not in {ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj}) |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl |
| is not ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj) |
| _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl |
| not in {ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj}) |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| @unittest.skipUnless(not py3compat.PY3, 'Requires Python 2.7') |
| def testAsyncAsNonKeyword(self): |
| # In Python 2, async may be used as a non-keyword identifier. |
| code = textwrap.dedent("""\ |
| from util import async |
| |
| |
| class A(object): |
| |
| def foo(self): |
| async.run() |
| |
| def bar(self): |
| pass |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(code) |
| self.assertCodeEqual(code, reformatter.Reformat(llines, verify=False)) |
| |
| def testStableInlinedDictionaryFormatting(self): |
| unformatted_code = textwrap.dedent("""\ |
| def _(): |
| url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( |
| value, urllib.urlencode({'action': 'update', 'parameter': value})) |
| """) # noqa |
| expected_formatted_code = textwrap.dedent("""\ |
| def _(): |
| url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( |
| value, urllib.urlencode({ |
| 'action': 'update', |
| 'parameter': value |
| })) |
| """) |
| |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| reformatted_code = reformatter.Reformat(llines) |
| self.assertCodeEqual(expected_formatted_code, reformatted_code) |
| |
| llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) |
| reformatted_code = reformatter.Reformat(llines) |
| self.assertCodeEqual(expected_formatted_code, reformatted_code) |
| |
| @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') |
| def testSpaceBetweenColonAndElipses(self): |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| code = textwrap.dedent("""\ |
| class MyClass(ABC): |
| |
| place: ... |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(code) |
| self.assertCodeEqual(code, reformatter.Reformat(llines, verify=False)) |
| |
| @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') |
| def testSpaceBetweenDictColonAndElipses(self): |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| unformatted_code = textwrap.dedent("""\ |
| {0:"...", 1:...} |
| """) |
| expected_formatted_code = textwrap.dedent("""\ |
| {0: "...", 1: ...} |
| """) |
| |
| llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| |
| class TestsForSpacesInsideBrackets(yapf_test_helper.YAPFTest): |
| """Test the SPACE_INSIDE_BRACKETS style option.""" |
| unformatted_code = textwrap.dedent("""\ |
| foo() |
| foo(1) |
| foo(1,2) |
| foo((1,)) |
| foo((1, 2)) |
| foo((1, 2,)) |
| foo(bar['baz'][0]) |
| set1 = {1, 2, 3} |
| dict1 = {1: 1, foo: 2, 3: bar} |
| dict2 = { |
| 1: 1, |
| foo: 2, |
| 3: bar, |
| } |
| dict3[3][1][get_index(*args,**kwargs)] |
| dict4[3][1][get_index(**kwargs)] |
| x = dict5[4](foo(*args)) |
| a = list1[:] |
| b = list2[slice_start:] |
| c = list3[slice_start:slice_end] |
| d = list4[slice_start:slice_end:] |
| e = list5[slice_start:slice_end:slice_step] |
| # Print gets special handling |
| print(set2) |
| compound = ((10+3)/(5-2**(6+x))) |
| string_idx = "mystring"[3] |
| """) |
| |
| def testEnabled(self): |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig('{space_inside_brackets: True}')) |
| |
| expected_formatted_code = textwrap.dedent("""\ |
| foo() |
| foo( 1 ) |
| foo( 1, 2 ) |
| foo( ( 1, ) ) |
| foo( ( 1, 2 ) ) |
| foo( ( |
| 1, |
| 2, |
| ) ) |
| foo( bar[ 'baz' ][ 0 ] ) |
| set1 = { 1, 2, 3 } |
| dict1 = { 1: 1, foo: 2, 3: bar } |
| dict2 = { |
| 1: 1, |
| foo: 2, |
| 3: bar, |
| } |
| dict3[ 3 ][ 1 ][ get_index( *args, **kwargs ) ] |
| dict4[ 3 ][ 1 ][ get_index( **kwargs ) ] |
| x = dict5[ 4 ]( foo( *args ) ) |
| a = list1[ : ] |
| b = list2[ slice_start: ] |
| c = list3[ slice_start:slice_end ] |
| d = list4[ slice_start:slice_end: ] |
| e = list5[ slice_start:slice_end:slice_step ] |
| # Print gets special handling |
| print( set2 ) |
| compound = ( ( 10 + 3 ) / ( 5 - 2**( 6 + x ) ) ) |
| string_idx = "mystring"[ 3 ] |
| """) |
| |
| llines = yapf_test_helper.ParseAndUnwrap(self.unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testDefault(self): |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| |
| expected_formatted_code = textwrap.dedent("""\ |
| foo() |
| foo(1) |
| foo(1, 2) |
| foo((1, )) |
| foo((1, 2)) |
| foo(( |
| 1, |
| 2, |
| )) |
| foo(bar['baz'][0]) |
| set1 = {1, 2, 3} |
| dict1 = {1: 1, foo: 2, 3: bar} |
| dict2 = { |
| 1: 1, |
| foo: 2, |
| 3: bar, |
| } |
| dict3[3][1][get_index(*args, **kwargs)] |
| dict4[3][1][get_index(**kwargs)] |
| x = dict5[4](foo(*args)) |
| a = list1[:] |
| b = list2[slice_start:] |
| c = list3[slice_start:slice_end] |
| d = list4[slice_start:slice_end:] |
| e = list5[slice_start:slice_end:slice_step] |
| # Print gets special handling |
| print(set2) |
| compound = ((10 + 3) / (5 - 2**(6 + x))) |
| string_idx = "mystring"[3] |
| """) |
| |
| llines = yapf_test_helper.ParseAndUnwrap(self.unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') |
| def testAwait(self): |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig('{space_inside_brackets: True}')) |
| unformatted_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 |
| """) |
| expected_formatted_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(unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| |
| class TestsForSpacesAroundSubscriptColon(yapf_test_helper.YAPFTest): |
| """Test the SPACES_AROUND_SUBSCRIPT_COLON style option.""" |
| unformatted_code = textwrap.dedent("""\ |
| a = list1[ : ] |
| b = list2[ slice_start: ] |
| c = list3[ slice_start:slice_end ] |
| d = list4[ slice_start:slice_end: ] |
| e = list5[ slice_start:slice_end:slice_step ] |
| a1 = list1[ : ] |
| b1 = list2[ 1: ] |
| c1 = list3[ 1:20 ] |
| d1 = list4[ 1:20: ] |
| e1 = list5[ 1:20:3 ] |
| """) |
| |
| def testEnabled(self): |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig('{spaces_around_subscript_colon: True}')) |
| expected_formatted_code = textwrap.dedent("""\ |
| a = list1[:] |
| b = list2[slice_start :] |
| c = list3[slice_start : slice_end] |
| d = list4[slice_start : slice_end :] |
| e = list5[slice_start : slice_end : slice_step] |
| a1 = list1[:] |
| b1 = list2[1 :] |
| c1 = list3[1 : 20] |
| d1 = list4[1 : 20 :] |
| e1 = list5[1 : 20 : 3] |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(self.unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testWithSpaceInsideBrackets(self): |
| style.SetGlobalStyle( |
| style.CreateStyleFromConfig('{' |
| 'spaces_around_subscript_colon: true, ' |
| 'space_inside_brackets: true,' |
| '}')) |
| expected_formatted_code = textwrap.dedent("""\ |
| a = list1[ : ] |
| b = list2[ slice_start : ] |
| c = list3[ slice_start : slice_end ] |
| d = list4[ slice_start : slice_end : ] |
| e = list5[ slice_start : slice_end : slice_step ] |
| a1 = list1[ : ] |
| b1 = list2[ 1 : ] |
| c1 = list3[ 1 : 20 ] |
| d1 = list4[ 1 : 20 : ] |
| e1 = list5[ 1 : 20 : 3 ] |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(self.unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| def testDefault(self): |
| style.SetGlobalStyle(style.CreatePEP8Style()) |
| expected_formatted_code = textwrap.dedent("""\ |
| a = list1[:] |
| b = list2[slice_start:] |
| c = list3[slice_start:slice_end] |
| d = list4[slice_start:slice_end:] |
| e = list5[slice_start:slice_end:slice_step] |
| a1 = list1[:] |
| b1 = list2[1:] |
| c1 = list3[1:20] |
| d1 = list4[1:20:] |
| e1 = list5[1:20:3] |
| """) |
| llines = yapf_test_helper.ParseAndUnwrap(self.unformatted_code) |
| self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
