| 270 | 270 |
commented_out_code = '#x = 1'
|
| 271 | 271 |
self.assertEqual(
|
| 272 | 272 |
commented_out_code,
|
| 273 | |
fix_e265_and_e266(commented_out_code))
|
|
273 |
fix_e266(commented_out_code))
|
| 274 | 274 |
|
| 275 | 275 |
def test_fix_file(self):
|
| 276 | 276 |
self.assertIn(
|
|
| 322 | 322 |
self.assertEqual(
|
| 323 | 323 |
'print( 123 )\n',
|
| 324 | 324 |
autopep8.fix_code('print( 123 )\n', options={'ignore': ['E']}))
|
| 325 | |
|
| 326 | |
self.assertEqual(
|
| 327 | |
'y in x\n',
|
| 328 | |
autopep8.fix_code('x.has_key(y)\n', options={'aggressive': True}))
|
| 329 | 325 |
|
| 330 | 326 |
def test_fix_code_with_bad_options(self):
|
| 331 | 327 |
with self.assertRaises(ValueError):
|
|
| 710 | 706 |
1,
|
| 711 | 707 |
autopep8.count_unbalanced_brackets(
|
| 712 | 708 |
"'','.join(['%s=%s' % (col, col)')"))
|
| 713 | |
|
| 714 | |
def test_refactor_with_2to3(self):
|
| 715 | |
self.assertEqual(
|
| 716 | |
'1 in {}\n',
|
| 717 | |
autopep8.refactor_with_2to3('{}.has_key(1)\n', ['has_key']))
|
| 718 | |
|
| 719 | |
def test_refactor_with_2to3_should_handle_syntax_error_gracefully(self):
|
| 720 | |
self.assertEqual(
|
| 721 | |
'{}.has_key(1\n',
|
| 722 | |
autopep8.refactor_with_2to3('{}.has_key(1\n', ['has_key']))
|
| 723 | 709 |
|
| 724 | 710 |
def test_commented_out_code_lines(self):
|
| 725 | 711 |
self.assertEqual(
|
|
| 991 | 977 |
|
| 992 | 978 |
def test_e101_should_ignore_multiline_strings_complex(self):
|
| 993 | 979 |
line = """\
|
| 994 | |
print(3 <> 4, '''
|
|
980 |
print(3 != 4, '''
|
| 995 | 981 |
while True:
|
| 996 | 982 |
if True:
|
| 997 | 983 |
\t1
|
| 998 | |
\t''', 4 <> 5)
|
|
984 |
\t''', 4 != 5)
|
| 999 | 985 |
"""
|
| 1000 | 986 |
fixed = """\
|
| 1001 | 987 |
print(3 != 4, '''
|
|
| 2251 | 2237 |
with autopep8_context(line, options=['--select=E265']) as result:
|
| 2252 | 2238 |
self.assertEqual(fixed, result)
|
| 2253 | 2239 |
|
|
2240 |
def test_e265_issue662(self):
|
|
2241 |
line = "#print(\" \")\n"
|
|
2242 |
fixed = "# print(\" \")\n"
|
|
2243 |
with autopep8_context(line, options=['--select=E265']) as result:
|
|
2244 |
self.assertEqual(fixed, result)
|
|
2245 |
|
| 2254 | 2246 |
def test_ignore_e265(self):
|
| 2255 | 2247 |
line = "## A comment\n#B comment\n123\n"
|
| 2256 | 2248 |
fixed = "# A comment\n#B comment\n123\n"
|
|
| 2267 | 2259 |
line = "## A comment\n#B comment\n123\n"
|
| 2268 | 2260 |
fixed = "# A comment\n#B comment\n123\n"
|
| 2269 | 2261 |
with autopep8_context(line, options=['--select=E266']) as result:
|
|
2262 |
self.assertEqual(fixed, result)
|
|
2263 |
|
|
2264 |
def test_e266_issue662(self):
|
|
2265 |
line = "## comment\n"
|
|
2266 |
fixed = "# comment\n"
|
|
2267 |
with autopep8_context(line) as result:
|
| 2270 | 2268 |
self.assertEqual(fixed, result)
|
| 2271 | 2269 |
|
| 2272 | 2270 |
def test_ignore_e266(self):
|
|
| 3180 | 3178 |
# http://foo.bar/abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-
|
| 3181 | 3179 |
|
| 3182 | 3180 |
# The following is ugly commented-out code and should not be touched.
|
| 3183 | |
#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = 1
|
|
3181 |
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = 1
|
| 3184 | 3182 |
"""
|
| 3185 | 3183 |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 3186 | 3184 |
self.assertEqual(fixed, result)
|
|
| 4443 | 4441 |
|
| 4444 | 4442 |
def test_w191_should_ignore_multiline_strings(self):
|
| 4445 | 4443 |
line = """\
|
| 4446 | |
print(3 <> 4, '''
|
|
4444 |
print(3 != 4, '''
|
| 4447 | 4445 |
while True:
|
| 4448 | 4446 |
if True:
|
| 4449 | 4447 |
\t1
|
| 4450 | |
\t''', 4 <> 5)
|
|
4448 |
\t''', 4 != 5)
|
| 4451 | 4449 |
if True:
|
| 4452 | 4450 |
\t123
|
| 4453 | 4451 |
"""
|
|
| 4845 | 4843 |
with autopep8_context(line, options=['-aa', '--select=E,W5']) as result:
|
| 4846 | 4844 |
self.assertEqual(fixed, result)
|
| 4847 | 4845 |
with autopep8_context(line, options=['-aa', '--select=E,W50']) as result:
|
| 4848 | |
self.assertEqual(fixed, result)
|
| 4849 | |
|
| 4850 | |
def test_w601(self):
|
| 4851 | |
line = 'a = {0: 1}\na.has_key(0)\n'
|
| 4852 | |
fixed = 'a = {0: 1}\n0 in a\n'
|
| 4853 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4854 | |
self.assertEqual(fixed, result)
|
| 4855 | |
|
| 4856 | |
def test_w601_word(self):
|
| 4857 | |
line = 'my_dict = {0: 1}\nmy_dict.has_key(0)\n'
|
| 4858 | |
fixed = 'my_dict = {0: 1}\n0 in my_dict\n'
|
| 4859 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4860 | |
self.assertEqual(fixed, result)
|
| 4861 | |
|
| 4862 | |
def test_w601_conditional(self):
|
| 4863 | |
line = 'a = {0: 1}\nif a.has_key(0):\n print 1\n'
|
| 4864 | |
fixed = 'a = {0: 1}\nif 0 in a:\n print 1\n'
|
| 4865 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4866 | |
self.assertEqual(fixed, result)
|
| 4867 | |
|
| 4868 | |
def test_w601_self(self):
|
| 4869 | |
line = 'self.a.has_key(0)\n'
|
| 4870 | |
fixed = '0 in self.a\n'
|
| 4871 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4872 | |
self.assertEqual(fixed, result)
|
| 4873 | |
|
| 4874 | |
def test_w601_self_with_conditional(self):
|
| 4875 | |
line = 'if self.a.has_key(0):\n print 1\n'
|
| 4876 | |
fixed = 'if 0 in self.a:\n print 1\n'
|
| 4877 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4878 | |
self.assertEqual(fixed, result)
|
| 4879 | |
|
| 4880 | |
def test_w601_with_multiple(self):
|
| 4881 | |
line = 'a.has_key(0) and b.has_key(0)\n'
|
| 4882 | |
fixed = '0 in a and 0 in b\n'
|
| 4883 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4884 | |
self.assertEqual(fixed, result)
|
| 4885 | |
|
| 4886 | |
def test_w601_with_multiple_nested(self):
|
| 4887 | |
line = 'alpha.has_key(nested.has_key(12)) and beta.has_key(1)\n'
|
| 4888 | |
fixed = '(12 in nested) in alpha and 1 in beta\n'
|
| 4889 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4890 | |
self.assertEqual(fixed, result)
|
| 4891 | |
|
| 4892 | |
def test_w601_with_more_complexity(self):
|
| 4893 | |
line = 'y.has_key(0) + x.has_key(x.has_key(0) + x.has_key(x.has_key(0) + x.has_key(1)))\n'
|
| 4894 | |
fixed = '(0 in y) + ((0 in x) + ((0 in x) + (1 in x) in x) in x)\n'
|
| 4895 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4896 | |
self.assertEqual(fixed, result)
|
| 4897 | |
|
| 4898 | |
def test_w601_precedence(self):
|
| 4899 | |
line = 'if self.a.has_key(1 + 2):\n print 1\n'
|
| 4900 | |
fixed = 'if 1 + 2 in self.a:\n print 1\n'
|
| 4901 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4902 | |
self.assertEqual(fixed, result)
|
| 4903 | |
|
| 4904 | |
def test_w601_with_parens(self):
|
| 4905 | |
line = 'foo(12) in alpha\n'
|
| 4906 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4907 | |
self.assertEqual(line, result)
|
| 4908 | |
|
| 4909 | |
def test_w601_with_multiline(self):
|
| 4910 | |
line = """\
|
| 4911 | |
a.has_key(
|
| 4912 | |
0
|
| 4913 | |
)
|
| 4914 | |
"""
|
| 4915 | |
fixed = '0 in a\n'
|
| 4916 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4917 | |
self.assertEqual(fixed, result)
|
| 4918 | |
|
| 4919 | |
def test_w601_with_non_ascii(self):
|
| 4920 | |
line = """\
|
| 4921 | |
# -*- coding: utf-8 -*-
|
| 4922 | |
## éはe
|
| 4923 | |
correct = dict().has_key('good syntax ?')
|
| 4924 | |
"""
|
| 4925 | |
|
| 4926 | |
fixed = """\
|
| 4927 | |
# -*- coding: utf-8 -*-
|
| 4928 | |
# éはe
|
| 4929 | |
correct = 'good syntax ?' in dict()
|
| 4930 | |
"""
|
| 4931 | |
|
| 4932 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4933 | |
self.assertEqual(fixed, result)
|
| 4934 | |
|
| 4935 | |
def test_w602_arg_is_string(self):
|
| 4936 | |
line = "raise ValueError, \"w602 test\"\n"
|
| 4937 | |
fixed = "raise ValueError(\"w602 test\")\n"
|
| 4938 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4939 | |
self.assertEqual(fixed, result)
|
| 4940 | |
|
| 4941 | |
def test_w602_arg_is_string_with_comment(self):
|
| 4942 | |
line = "raise ValueError, \"w602 test\" # comment\n"
|
| 4943 | |
fixed = "raise ValueError(\"w602 test\") # comment\n"
|
| 4944 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4945 | |
self.assertEqual(fixed, result)
|
| 4946 | |
|
| 4947 | |
def test_w602_skip_ambiguous_case(self):
|
| 4948 | |
line = "raise 'a', 'b', 'c'\n"
|
| 4949 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4950 | |
self.assertEqual(line, result)
|
| 4951 | |
|
| 4952 | |
def test_w602_with_logic(self):
|
| 4953 | |
line = "raise TypeError, e or 'hello'\n"
|
| 4954 | |
fixed = "raise TypeError(e or 'hello')\n"
|
| 4955 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4956 | |
self.assertEqual(fixed, result)
|
| 4957 | |
|
| 4958 | |
def test_w602_triple_quotes(self):
|
| 4959 | |
line = 'raise ValueError, """hello"""\n1\n'
|
| 4960 | |
fixed = 'raise ValueError("""hello""")\n1\n'
|
| 4961 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4962 | |
self.assertEqual(fixed, result)
|
| 4963 | |
|
| 4964 | |
def test_w602_multiline(self):
|
| 4965 | |
line = 'raise ValueError, """\nhello"""\n'
|
| 4966 | |
fixed = 'raise ValueError("""\nhello""")\n'
|
| 4967 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4968 | |
self.assertEqual(fixed, result)
|
| 4969 | |
|
| 4970 | |
def test_w602_with_complex_multiline(self):
|
| 4971 | |
line = 'raise ValueError, """\nhello %s %s""" % (\n 1, 2)\n'
|
| 4972 | |
fixed = 'raise ValueError("""\nhello %s %s""" % (\n 1, 2))\n'
|
| 4973 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4974 | |
self.assertEqual(fixed, result)
|
| 4975 | |
|
| 4976 | |
def test_w602_multiline_with_trailing_spaces(self):
|
| 4977 | |
line = 'raise ValueError, """\nhello""" \n'
|
| 4978 | |
fixed = 'raise ValueError("""\nhello""")\n'
|
| 4979 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4980 | |
self.assertEqual(fixed, result)
|
| 4981 | |
|
| 4982 | |
def test_w602_multiline_with_escaped_newline(self):
|
| 4983 | |
line = 'raise ValueError, \\\n"""\nhello"""\n'
|
| 4984 | |
fixed = 'raise ValueError("""\nhello""")\n'
|
| 4985 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4986 | |
self.assertEqual(fixed, result)
|
| 4987 | |
|
| 4988 | |
def test_w602_multiline_with_escaped_newline_and_comment(self):
|
| 4989 | |
line = 'raise ValueError, \\\n"""\nhello""" # comment\n'
|
| 4990 | |
fixed = 'raise ValueError("""\nhello""") # comment\n'
|
| 4991 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4992 | |
self.assertEqual(fixed, result)
|
| 4993 | |
|
| 4994 | |
def test_w602_multiline_with_multiple_escaped_newlines(self):
|
| 4995 | |
line = 'raise ValueError, \\\n\\\n\\\n"""\nhello"""\n'
|
| 4996 | |
fixed = 'raise ValueError("""\nhello""")\n'
|
| 4997 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 4998 | |
self.assertEqual(fixed, result)
|
| 4999 | |
|
| 5000 | |
def test_w602_multiline_with_nested_quotes(self):
|
| 5001 | |
line = 'raise ValueError, """hello\'\'\'blah"a"b"c"""\n'
|
| 5002 | |
fixed = 'raise ValueError("""hello\'\'\'blah"a"b"c""")\n'
|
| 5003 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5004 | |
self.assertEqual(fixed, result)
|
| 5005 | |
|
| 5006 | |
def test_w602_with_multiline_with_single_quotes(self):
|
| 5007 | |
line = "raise ValueError, '''\nhello'''\n"
|
| 5008 | |
fixed = "raise ValueError('''\nhello''')\n"
|
| 5009 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5010 | |
self.assertEqual(fixed, result)
|
| 5011 | |
|
| 5012 | |
def test_w602_multiline_string_stays_the_same(self):
|
| 5013 | |
line = 'raise """\nhello"""\n'
|
| 5014 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5015 | |
self.assertEqual(line, result)
|
| 5016 | |
|
| 5017 | |
def test_w602_escaped_lf(self):
|
| 5018 | |
line = 'raise ValueError, \\\n"hello"\n'
|
| 5019 | |
fixed = 'raise ValueError("hello")\n'
|
| 5020 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5021 | |
self.assertEqual(fixed, result)
|
| 5022 | |
|
| 5023 | |
def test_w602_escaped_crlf(self):
|
| 5024 | |
line = 'raise ValueError, \\\r\n"hello"\r\n'
|
| 5025 | |
fixed = 'raise ValueError("hello")\r\n'
|
| 5026 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5027 | |
self.assertEqual(fixed, result)
|
| 5028 | |
|
| 5029 | |
def test_w602_indentation(self):
|
| 5030 | |
line = 'def foo():\n raise ValueError, "hello"\n'
|
| 5031 | |
fixed = 'def foo():\n raise ValueError("hello")\n'
|
| 5032 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5033 | |
self.assertEqual(fixed, result)
|
| 5034 | |
|
| 5035 | |
def test_w602_escaped_cr(self):
|
| 5036 | |
line = 'raise ValueError, \\\r"hello"\n\n'
|
| 5037 | |
fixed = 'raise ValueError("hello")\n'
|
| 5038 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5039 | |
self.assertEqual(fixed, result)
|
| 5040 | |
|
| 5041 | |
def test_w602_multiple_statements(self):
|
| 5042 | |
line = 'raise ValueError, "hello";print 1\n'
|
| 5043 | |
fixed = 'raise ValueError("hello")\nprint 1\n'
|
| 5044 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5045 | |
self.assertEqual(fixed, result)
|
| 5046 | |
|
| 5047 | |
def test_w602_raise_argument_with_indentation(self):
|
| 5048 | |
line = 'if True:\n raise ValueError, "error"\n'
|
| 5049 | |
fixed = 'if True:\n raise ValueError("error")\n'
|
| 5050 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5051 | |
self.assertEqual(fixed, result)
|
| 5052 | |
|
| 5053 | |
def test_w602_skip_raise_argument_triple(self):
|
| 5054 | |
line = 'raise ValueError, "info", traceback\n'
|
| 5055 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5056 | |
self.assertEqual(line, result)
|
| 5057 | |
|
| 5058 | |
def test_w602_skip_raise_argument_triple_with_comment(self):
|
| 5059 | |
line = 'raise ValueError, "info", traceback # comment\n'
|
| 5060 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5061 | |
self.assertEqual(line, result)
|
| 5062 | |
|
| 5063 | |
def test_w602_raise_argument_triple_fake(self):
|
| 5064 | |
line = 'raise ValueError, "info, info2"\n'
|
| 5065 | |
fixed = 'raise ValueError("info, info2")\n'
|
| 5066 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5067 | |
self.assertEqual(fixed, result)
|
| 5068 | |
|
| 5069 | |
def test_w602_with_list_comprehension(self):
|
| 5070 | |
line = 'raise Error, [x[0] for x in probs]\n'
|
| 5071 | |
fixed = 'raise Error([x[0] for x in probs])\n'
|
| 5072 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5073 | |
self.assertEqual(fixed, result)
|
| 5074 | |
|
| 5075 | |
def test_w602_with_bad_syntax(self):
|
| 5076 | |
line = "raise Error, 'abc\n"
|
| 5077 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5078 | |
self.assertEqual(line, result)
|
| 5079 | |
|
| 5080 | |
def test_w602_invalid_2to3_fixed_case(self):
|
| 5081 | |
line = """\
|
| 5082 | |
raise (ValueError
|
| 5083 | |
if True else TypeError)
|
| 5084 | |
"""
|
| 5085 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5086 | |
self.assertEqual(line, result)
|
| 5087 | |
|
| 5088 | |
@unittest.skip('TODO')
|
| 5089 | |
def test_w602_invalid_2to3_fixed_case_with_valid_syntax(self):
|
| 5090 | |
line = """\
|
| 5091 | |
raise (ValueError
|
| 5092 | |
if True else TypeError)
|
| 5093 | |
raise ValueError, "error"
|
| 5094 | |
"""
|
| 5095 | |
fixed = """\
|
| 5096 | |
raise (ValueError
|
| 5097 | |
if True else TypeError)
|
| 5098 | |
raise ValueError("error")
|
| 5099 | |
"""
|
| 5100 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5101 | |
self.assertEqual(fixed, result)
|
| 5102 | |
|
| 5103 | |
def test_w603(self):
|
| 5104 | |
line = 'if 2 <> 2:\n print False'
|
| 5105 | |
fixed = 'if 2 != 2:\n print False\n'
|
| 5106 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5107 | |
self.assertEqual(fixed, result)
|
| 5108 | |
|
| 5109 | |
def test_w604(self):
|
| 5110 | |
line = '`1`\n'
|
| 5111 | |
fixed = 'repr(1)\n'
|
| 5112 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5113 | |
self.assertEqual(fixed, result)
|
| 5114 | |
|
| 5115 | |
def test_w604_with_multiple_instances(self):
|
| 5116 | |
line = '``1`` + ``b``\n'
|
| 5117 | |
fixed = 'repr(repr(1)) + repr(repr(b))\n'
|
| 5118 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5119 | |
self.assertEqual(fixed, result)
|
| 5120 | |
|
| 5121 | |
def test_w604_with_multiple_lines(self):
|
| 5122 | |
line = '`(1\n )`\n'
|
| 5123 | |
fixed = 'repr((1\n ))\n'
|
| 5124 | |
with autopep8_context(line, options=['--aggressive']) as result:
|
| 5125 | 4846 |
self.assertEqual(fixed, result)
|
| 5126 | 4847 |
|
| 5127 | 4848 |
def test_w605_simple(self):
|
|
| 6732 | 6453 |
# http://foo.bar/abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-abc-
|
| 6733 | 6454 |
|
| 6734 | 6455 |
# The following is ugly commented-out code and should not be touched.
|
| 6735 | |
#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = 1
|
|
6456 |
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = 1
|
| 6736 | 6457 |
"""
|
| 6737 | 6458 |
with autopep8_context(line, options=['--experimental',
|
| 6738 | 6459 |
'--aggressive']) as result:
|
|
| 7577 | 7298 |
self.assertEqual(fixed, result)
|
| 7578 | 7299 |
|
| 7579 | 7300 |
|
|
7301 |
def fix_e266(source):
|
|
7302 |
with autopep8_context(source, options=['--select=E266']) as result:
|
|
7303 |
return result
|
|
7304 |
|
|
7305 |
|
| 7580 | 7306 |
def fix_e265_and_e266(source):
|
| 7581 | 7307 |
with autopep8_context(source, options=['--select=E265,E266']) as result:
|
| 7582 | 7308 |
return result
|