You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
433 lines
15 KiB
433 lines
15 KiB
4 years ago
|
# 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.
|
||
|
"""Facebook tests for yapf.reformatter."""
|
||
|
|
||
|
import textwrap
|
||
|
import unittest
|
||
|
|
||
|
from yapf.yapflib import reformatter
|
||
|
from yapf.yapflib import style
|
||
|
|
||
|
from yapftests import yapf_test_helper
|
||
|
|
||
|
|
||
|
class TestsForFacebookStyle(yapf_test_helper.YAPFTest):
|
||
|
|
||
|
@classmethod
|
||
|
def setUpClass(cls):
|
||
|
style.SetGlobalStyle(style.CreateFacebookStyle())
|
||
|
|
||
|
def testNoNeedForLineBreaks(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(
|
||
|
just_one_arg, **kwargs):
|
||
|
pass
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(just_one_arg, **kwargs):
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentClosingBracket(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(
|
||
|
first_argument_on_the_same_line,
|
||
|
second_argument_makes_the_line_too_long):
|
||
|
pass
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(
|
||
|
first_argument_on_the_same_line, second_argument_makes_the_line_too_long
|
||
|
):
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testBreakAfterOpeningBracketIfContentsTooBig(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(a, b, c, d, e, f, g, h, i, j, k, l, m,
|
||
|
n, o, p, q, r, s, t, u, v, w, x, y, z):
|
||
|
pass
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(
|
||
|
a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, \
|
||
|
v, w, x, y, z
|
||
|
):
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentClosingBracketWithComments(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(
|
||
|
# comment about the first argument
|
||
|
first_argument_with_a_very_long_name_or_so,
|
||
|
# comment about the second argument
|
||
|
second_argument_makes_the_line_too_long):
|
||
|
pass
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
def overly_long_function_name(
|
||
|
# comment about the first argument
|
||
|
first_argument_with_a_very_long_name_or_so,
|
||
|
# comment about the second argument
|
||
|
second_argument_makes_the_line_too_long
|
||
|
):
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentImportAsNames(self):
|
||
|
code = textwrap.dedent("""\
|
||
|
from module import (
|
||
|
internal_function as function,
|
||
|
SOME_CONSTANT_NUMBER1,
|
||
|
SOME_CONSTANT_NUMBER2,
|
||
|
SOME_CONSTANT_NUMBER3,
|
||
|
)
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
||
|
self.assertCodeEqual(code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentTestListGexp(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
try:
|
||
|
pass
|
||
|
except (
|
||
|
IOError, OSError, LookupError, RuntimeError, OverflowError
|
||
|
) as exception:
|
||
|
pass
|
||
|
|
||
|
try:
|
||
|
pass
|
||
|
except (
|
||
|
IOError, OSError, LookupError, RuntimeError, OverflowError,
|
||
|
) as exception:
|
||
|
pass
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
try:
|
||
|
pass
|
||
|
except (
|
||
|
IOError, OSError, LookupError, RuntimeError, OverflowError
|
||
|
) as exception:
|
||
|
pass
|
||
|
|
||
|
try:
|
||
|
pass
|
||
|
except (
|
||
|
IOError,
|
||
|
OSError,
|
||
|
LookupError,
|
||
|
RuntimeError,
|
||
|
OverflowError,
|
||
|
) as exception:
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testBrokenIdempotency(self):
|
||
|
# TODO(ambv): The following behaviour should be fixed.
|
||
|
pass0_code = textwrap.dedent("""\
|
||
|
try:
|
||
|
pass
|
||
|
except (IOError, OSError, LookupError, RuntimeError, OverflowError) as exception:
|
||
|
pass
|
||
|
""")
|
||
|
pass1_code = textwrap.dedent("""\
|
||
|
try:
|
||
|
pass
|
||
|
except (
|
||
|
IOError, OSError, LookupError, RuntimeError, OverflowError
|
||
|
) as exception:
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(pass0_code)
|
||
|
self.assertCodeEqual(pass1_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
pass2_code = textwrap.dedent("""\
|
||
|
try:
|
||
|
pass
|
||
|
except (
|
||
|
IOError, OSError, LookupError, RuntimeError, OverflowError
|
||
|
) as exception:
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(pass1_code)
|
||
|
self.assertCodeEqual(pass2_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testIfExprHangingIndent(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
if True:
|
||
|
if True:
|
||
|
if True:
|
||
|
if not self.frobbies and (
|
||
|
self.foobars.counters['db.cheeses'] != 1 or
|
||
|
self.foobars.counters['db.marshmellow_skins'] != 1):
|
||
|
pass
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
if True:
|
||
|
if True:
|
||
|
if True:
|
||
|
if not self.frobbies and (
|
||
|
self.foobars.counters['db.cheeses'] != 1 or
|
||
|
self.foobars.counters['db.marshmellow_skins'] != 1
|
||
|
):
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testSimpleDedenting(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
if True:
|
||
|
self.assertEqual(result.reason_not_added, "current preflight is still running")
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
if True:
|
||
|
self.assertEqual(
|
||
|
result.reason_not_added, "current preflight is still running"
|
||
|
)
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentingWithSubscripts(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
class Foo:
|
||
|
class Bar:
|
||
|
@classmethod
|
||
|
def baz(cls, clues_list, effect, constraints, constraint_manager):
|
||
|
if clues_lists:
|
||
|
return cls.single_constraint_not(clues_lists, effect, constraints[0], constraint_manager)
|
||
|
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
class Foo:
|
||
|
class Bar:
|
||
|
@classmethod
|
||
|
def baz(cls, clues_list, effect, constraints, constraint_manager):
|
||
|
if clues_lists:
|
||
|
return cls.single_constraint_not(
|
||
|
clues_lists, effect, constraints[0], constraint_manager
|
||
|
)
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentingCallsWithInnerLists(self):
|
||
|
code = textwrap.dedent("""\
|
||
|
class _():
|
||
|
def _():
|
||
|
cls.effect_clues = {
|
||
|
'effect': Clue((cls.effect_time, 'apache_host'), effect_line, 40)
|
||
|
}
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
||
|
self.assertCodeEqual(code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentingListComprehension(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
class Foo():
|
||
|
def _pack_results_for_constraint_or():
|
||
|
self.param_groups = dict(
|
||
|
(
|
||
|
key + 1, ParamGroup(groups[key], default_converter)
|
||
|
) for key in six.moves.range(len(groups))
|
||
|
)
|
||
|
|
||
|
for combination in cls._clues_combinations(clues_lists):
|
||
|
if all(
|
||
|
cls._verify_constraint(combination, effect, constraint)
|
||
|
for constraint in constraints
|
||
|
):
|
||
|
pass
|
||
|
|
||
|
guessed_dict = dict(
|
||
|
(
|
||
|
key, guessed_pattern_matches[key]
|
||
|
) for key in six.moves.range(len(guessed_pattern_matches))
|
||
|
)
|
||
|
|
||
|
content = "".join(
|
||
|
itertools.chain(
|
||
|
(first_line_fragment, ), lines_between, (last_line_fragment, )
|
||
|
)
|
||
|
)
|
||
|
|
||
|
rule = Rule(
|
||
|
[self.cause1, self.cause2, self.cause1, self.cause2], self.effect, constraints1,
|
||
|
Rule.LINKAGE_AND
|
||
|
)
|
||
|
|
||
|
assert sorted(log_type.files_to_parse) == [
|
||
|
('localhost', os.path.join(path, 'node_1.log'), super_parser),
|
||
|
('localhost', os.path.join(path, 'node_2.log'), super_parser)
|
||
|
]
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
class Foo():
|
||
|
def _pack_results_for_constraint_or():
|
||
|
self.param_groups = dict(
|
||
|
(key + 1, ParamGroup(groups[key], default_converter))
|
||
|
for key in six.moves.range(len(groups))
|
||
|
)
|
||
|
|
||
|
for combination in cls._clues_combinations(clues_lists):
|
||
|
if all(
|
||
|
cls._verify_constraint(combination, effect, constraint)
|
||
|
for constraint in constraints
|
||
|
):
|
||
|
pass
|
||
|
|
||
|
guessed_dict = dict(
|
||
|
(key, guessed_pattern_matches[key])
|
||
|
for key in six.moves.range(len(guessed_pattern_matches))
|
||
|
)
|
||
|
|
||
|
content = "".join(
|
||
|
itertools.chain(
|
||
|
(first_line_fragment, ), lines_between, (last_line_fragment, )
|
||
|
)
|
||
|
)
|
||
|
|
||
|
rule = Rule(
|
||
|
[self.cause1, self.cause2, self.cause1, self.cause2], self.effect,
|
||
|
constraints1, Rule.LINKAGE_AND
|
||
|
)
|
||
|
|
||
|
assert sorted(log_type.files_to_parse) == [
|
||
|
('localhost', os.path.join(path, 'node_1.log'), super_parser),
|
||
|
('localhost', os.path.join(path, 'node_2.log'), super_parser)
|
||
|
]
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testMustSplitDedenting(self):
|
||
|
code = textwrap.dedent("""\
|
||
|
class _():
|
||
|
def _():
|
||
|
effect_line = FrontInput(
|
||
|
effect_line_offset, line_content,
|
||
|
LineSource('localhost', xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)
|
||
|
)
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
||
|
self.assertCodeEqual(code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentIfConditional(self):
|
||
|
code = textwrap.dedent("""\
|
||
|
class _():
|
||
|
def _():
|
||
|
if True:
|
||
|
if not self.frobbies and (
|
||
|
self.foobars.counters['db.cheeses'] != 1 or
|
||
|
self.foobars.counters['db.marshmellow_skins'] != 1
|
||
|
):
|
||
|
pass
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
||
|
self.assertCodeEqual(code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentSet(self):
|
||
|
code = textwrap.dedent("""\
|
||
|
class _():
|
||
|
def _():
|
||
|
assert set(self.constraint_links.get_links()) == set(
|
||
|
[
|
||
|
(2, 10, 100),
|
||
|
(2, 10, 200),
|
||
|
(2, 20, 100),
|
||
|
(2, 20, 200),
|
||
|
]
|
||
|
)
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
||
|
self.assertCodeEqual(code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testDedentingInnerScope(self):
|
||
|
code = textwrap.dedent("""\
|
||
|
class Foo():
|
||
|
@classmethod
|
||
|
def _pack_results_for_constraint_or(cls, combination, constraints):
|
||
|
return cls._create_investigation_result(
|
||
|
(clue for clue in combination if not clue == Verifier.UNMATCHED),
|
||
|
constraints, InvestigationResult.OR
|
||
|
)
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
||
|
reformatted_code = reformatter.Reformat(uwlines)
|
||
|
self.assertCodeEqual(code, reformatted_code)
|
||
|
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(reformatted_code)
|
||
|
reformatted_code = reformatter.Reformat(uwlines)
|
||
|
self.assertCodeEqual(code, reformatted_code)
|
||
|
|
||
|
def testCommentWithNewlinesInPrefix(self):
|
||
|
unformatted_code = textwrap.dedent("""\
|
||
|
def foo():
|
||
|
if 0:
|
||
|
return False
|
||
|
|
||
|
|
||
|
#a deadly comment
|
||
|
elif 1:
|
||
|
return True
|
||
|
|
||
|
|
||
|
print(foo())
|
||
|
""")
|
||
|
expected_formatted_code = textwrap.dedent("""\
|
||
|
def foo():
|
||
|
if 0:
|
||
|
return False
|
||
|
|
||
|
#a deadly comment
|
||
|
elif 1:
|
||
|
return True
|
||
|
|
||
|
|
||
|
print(foo())
|
||
|
""")
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
def testIfStmtClosingBracket(self):
|
||
|
unformatted_code = """\
|
||
|
if (isinstance(value , (StopIteration , StopAsyncIteration )) and exc.__cause__ is value_asdfasdfasdfasdfsafsafsafdasfasdfs):
|
||
|
return False
|
||
|
"""
|
||
|
expected_formatted_code = """\
|
||
|
if (
|
||
|
isinstance(value, (StopIteration, StopAsyncIteration)) and
|
||
|
exc.__cause__ is value_asdfasdfasdfasdfsafsafsafdasfasdfs
|
||
|
):
|
||
|
return False
|
||
|
"""
|
||
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
||
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
||
|
|
||
|
|
||
|
if __name__ == '__main__':
|
||
|
unittest.main()
|