a
    Ų
žd1¹ ć                   @   s   d Z ddlZddlZddlZddlmZ ddlmZ ddlmZ ej	d dkoZej	d dkZ
ej	d dkovej	d d	kZG d
d dejZedkre ”  dS )z!Basic tests for yapf.reformatter.é    N)Śreformatter)Śstyle)Śyapf_test_helperé   é   é   é
   c                   @   sę  e Zd Zedd Zdd Zdd Zdd Zd	d
 Zdd Z	dd Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd  Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Zd7d8 Zd9d: Z d;d< Z!d=d> Z"d?d@ Z#dAdB Z$dCdD Z%dEdF Z&dGdH Z'dIdJ Z(dKdL Z)dMdN Z*dOdP Z+dQdR Z,dSdT Z-dUdV Z.dWdX Z/dYdZ Z0d[d\ Z1d]d^ Z2d_d` Z3dadb Z4dcdd Z5dedf Z6dgdh Z7didj Z8dkdl Z9dmdn Z:dodp Z;dqdr Z<dsdt Z=dudv Z>dwdx Z?dydz Z@d{d| ZAd}d~ ZBdd ZCdd ZDdd ZEdd ZFdd ZGdd ZHdd ZIdd ZJdd ZKdd ZLdd ZMdd ZNdd ZOdd ZPdd ZQdd ZRdd  ZSd”d¢ ZTd£d¤ ZUd„d¦ ZVd§dØ ZWd©dŖ ZXd«d¬ ZYd­d® ZZdÆd° Z[d±d² Z\d³d“ Z]dµd¶ Z^d·dø Z_d¹dŗ Z`d»d¼ Zad½d¾ ZbdædĄ ZcdĮdĀ ZddĆdÄ ZedÅdĘ ZfdĒdČ ZgdÉdŹ ZhdĖdĢ ZidĶdĪ ZjdĻdŠ ZkdŃdŅ ZldÓdŌ ZmdÕdÖ Znd×dŲ ZodŁdŚ ZpdŪdÜ ZqdŻdŽ Zrdßdą Zsdįdā Ztdćdä Zudådę Zvdēdč Zwdédź Zxdėdģ Zydķdī Zzdļdš Z{dńdņ Z|dódō Z}dõdö Z~d÷dų Zdłdś Zdūdü Zdżdž Zd’d  Zdd Zdd Zdd Zdd Zd	d
 Zdd Zdd Zdd Zdd Zdd Zdd Ze ed”dd Ze ed”dd Ze ed”dd ZdS (   ŚBasicReformatterTestc                 C   s   t  t  ” ” d S )N)r   ŚSetGlobalStyleŚCreateYapfStyle)Ścls© r   śi/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/yapftests/reformatter_basic_test.pyŚ
setUpClass   s    zBasicReformatterTest.setUpClassc                 C   s4  t  t  d”” t d”}t d”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” t d”}t d	”}t |”}|  |t 	|”” t d
”}t d
”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” d S )Nz:{split_all_comma_separated_values: true, column_limit: 40}śc          responseDict = {"timestamp": timestamp, "someValue":   value, "whatever": 120}
          ś          responseDict = {
              "timestamp": timestamp,
              "someValue": value,
              "whatever": 120
          }
          z8          yes = { 'yes': 'no', 'no': 'yes', }
          z^          yes = {
              'yes': 'no',
              'no': 'yes',
          }
          ś          def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args):
                pass
          ś±          def foo(long_arg,
                  really_long_arg,
                  really_really_long_arg,
                  cant_keep_all_these_args):
            pass
          śn          foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args]
          ś²          foo_tuple = [
              long_arg,
              really_long_arg,
              really_really_long_arg,
              cant_keep_all_these_args
          ]
          ś-          foo_tuple = [short, arg]
          św          someLongFunction(this_is_a_very_long_parameter,
              abc=(a, this_will_just_fit_xxxxxxx))
          z          someLongFunction(
              this_is_a_very_long_parameter,
              abc=(a,
                   this_will_just_fit_xxxxxxx))
          )
r   r
   ŚCreateStyleFromConfigŚtextwrapŚdedentr   ŚParseAndUnwrapŚassertCodeEqualr   ŚReformat©ŚselfŚunformatted_codeŚexpected_formatted_codeŚllinesr   r   r   ŚtestSplittingAllArgs#   s:    ’’

















z)BasicReformatterTest.testSplittingAllArgsc                 C   s°  t  t  d”” t d”}t d”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” t d	”}t d
”}t |”}t 	|”}|  
dt| ” d ” |  ||” t d”}t d”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” t d”}t d”}t |”}|  |t 	|”” d S )NzD{split_all_top_level_comma_separated_values: true, column_limit: 40}r   r   r   r   r   r   r   r   z          someLongFunction(
              this_is_a_very_long_parameter,
              abc=(a, this_will_just_fit_xxxxxxx))
          é(   é’’’’zx          someLongFunction(this_is_a_very_long_parameter,
              abc=(a, this_will_not_fit_xxxxxxxxx))
          z          someLongFunction(
              this_is_a_very_long_parameter,
              abc=(a,
                   this_will_not_fit_xxxxxxxxx))
          za          a, b = f(
              a_very_long_parameter, yet_another_one, and_another)
          z»          KO = {
              'ABC': Abc, # abc
              'DEF': Def, # def
              'LOL': Lol, # wtf
              'GHI': Ghi,
              'JKL': Jkl,
          }
          z¾          KO = {
              'ABC': Abc,  # abc
              'DEF': Def,  # def
              'LOL': Lol,  # wtf
              'GHI': Ghi,
              'JKL': Jkl,
          }
          )r   r
   r   r   r   r   r   r   r   r   ŚassertEqualŚlenŚ
splitlines)r   r    r!   r"   Zactual_formatted_coder   r   r   ŚtestSplittingTopLevelAllArgsp   sN    ’’






















	
	
z1BasicReformatterTest.testSplittingTopLevelAllArgsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Naŗ          def g():  # Trailing comment
          if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and
              xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'):
            pass

        def f(  # Intermediate comment
        ):
          if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and
              xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'):
            pass
        a»          def g():  # Trailing comment
          if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and
              xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'):
            pass


        def f(  # Intermediate comment
        ):
          if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and
              xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'):
            pass
        ©r   r   r   r   r   r   r   r   r   r   r   Ś'testSimpleFunctionsWithTrailingCommentsę   s    


z<BasicReformatterTest.testSimpleFunctionsWithTrailingCommentsc              
   C   sX  t  d”}t  d”}t |”}|  |t |”” t  d”}t  d”}z>t t 	d”” t |”}|  |t |”” W t t 
” ” nt t 
” ” 0 t  d”}t  d”}t |”}|  |t |”” t  d”}t  d”}t |”}|  |t |”” t  d”}t  d	”}t |”}|  |t |”” t  d
”}t  d
”}t |”}|  |t |”” d S )Nz6        import foo as bar
        VAR = 'baz'
        z7        import foo as bar

        VAR = 'baz'
        z8        import foo as bar


        VAR = 'baz'
        zN{based_on_style: yapf, blank_lines_between_top_level_imports_and_variables: 2}z9        import foo as bar
        # Some comment
        zF        import foo as bar
        class Baz():
          pass
        zH        import foo as bar


        class Baz():
          pass
        zG        import foo as bar
        def foobar():
          pass
        zI        import foo as bar


        def foobar():
          pass
        zP        def foobar():
          from foo import Bar
          Bar.baz()
        ©r   r   r   r   r   r   r   r   r
   r   r   r   r   r   r   Ś0testBlankLinesBetweenTopLevelImportsAndVariables  sB    




’’
’ 











zEBasicReformatterTest.testBlankLinesBetweenTopLevelImportsAndVariablesc                 C   sd   t  d”}t  d”}t |”}|  |t |”” t  d”}t  d”}t |”}|  |t |”” d S )Nz5        def foobar(): # foo
         pass



        z4        def foobar():  # foo
          pass
        z9        x = {  'a':37,'b':42,

        'c':927}

        z1        x = {'a': 37, 'b': 42, 'c': 927}
        r*   r   r   r   r   ŚtestBlankLinesAtEndOfFile\  s    





z.BasicReformatterTest.testBlankLinesAtEndOfFilec              
   C   s   t  d”}d}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 || }}t |”}|  |t 	|”” d S )NzŠ        class foo(object):

          def foobar(self):

            pass

          def barfoo(self, x, y):  # bar

            if x:

              return y


        def bar():

          return 0
        zclass foo(object):
  
  def foobar(self):
    
    pass
  
  def barfoo(self, x, y):  # bar
    
    if x:
      
      return y


def bar():
  
  return 0
z0{based_on_style: yapf, indent_blank_lines: true}©r   r   r   r
   r   r   r   r   r   r   r   r   r   r   r   ŚtestIndentBlankLinesw  s$    
’’
’ ’
z)BasicReformatterTest.testIndentBlankLinesc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nau          x = {  'a':37,'b':42,

        'c':927}

        y = 'hello ''world'
        z = 'hello '+'world'
        a = 'hello {}'.format('world')
        class foo  (     object  ):
          def f    (self   ):
            return       37*-+2
          def g(self, x,y=42):
              return y
        def f  (   a ) :
          return      37+-+a[42-x :  y**3]
        aW          x = {'a': 37, 'b': 42, 'c': 927}

        y = 'hello ' 'world'
        z = 'hello ' + 'world'
        a = 'hello {}'.format('world')


        class foo(object):

          def f(self):
            return 37 * -+2

          def g(self, x, y=42):
            return y


        def f(a):
          return 37 + -+a[42 - x:y**3]
        r*   r   r   r   r   ŚtestMultipleUgliness  s    


z)BasicReformatterTest.testMultipleUglinessc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na          class Foo(object):
          pass

        # Attached comment
        class Bar(object):
          pass

        global_assignment = 42

        # Comment attached to class with decorator.
        # Comment attached to class with decorator.
        @noop
        @noop
        class Baz(object):
          pass

        # Intermediate comment

        class Qux(object):
          pass
        a          class Foo(object):
          pass


        # Attached comment
        class Bar(object):
          pass


        global_assignment = 42


        # Comment attached to class with decorator.
        # Comment attached to class with decorator.
        @noop
        @noop
        class Baz(object):
          pass


        # Intermediate comment


        class Qux(object):
          pass
        r*   r   r   r   r   ŚtestCommentsĘ  s    


z!BasicReformatterTest.testCommentsc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz        # Thing 1
        r*   ©r   Ścoder"   r   r   r   ŚtestSingleCommentū  s    

z&BasicReformatterTest.testSingleCommentc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz$        # Thing 1    
# Thing 2    
z,        # Thing 1
        # Thing 2
        r*   r   r   r   r   ŚtestCommentsWithTrailingSpaces  s    


z3BasicReformatterTest.testCommentsWithTrailingSpacesc                 C   s*   t  d”}t |”}|  |t |”” d S )Na          def f():
          return collections.OrderedDict({
              # First comment.
              'fnord': 37,

              # Second comment.
              # Continuation of second comment.
              'bork': 42,

              # Ending comment.
          })
        r*   r3   r   r   r   ŚtestCommentsInDataLiteral  s    

z.BasicReformatterTest.testCommentsInDataLiteralc                 C   s*   t  d”}t |”}|  |t |”” d S )NzF        import foo as bar
        # Thing 1
        # Thing 2
        r*   r3   r   r   r   Ś(testEndingWhitespaceAfterSimpleStatement  s    

z=BasicReformatterTest.testEndingWhitespaceAfterSimpleStatementc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nah          u"""Module-level docstring."""
        import os
        class Foo(object):

          """Class-level docstring."""
          # A comment for qux.
          def qux(self):


            """Function-level docstring.

            A multiline function docstring.
            """
            print('hello {}'.format('world'))
            return 42
        ah          u"""Module-level docstring."""
        import os


        class Foo(object):
          """Class-level docstring."""

          # A comment for qux.
          def qux(self):
            """Function-level docstring.

            A multiline function docstring.
            """
            print('hello {}'.format('world'))
            return 42
        r*   r   r   r   r   ŚtestDocstrings&  s    


z#BasicReformatterTest.testDocstringsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na:          """Hello world"""
        # A multiline
        # comment
        class bar(object):
          """class docstring"""
          # class multiline
          # comment
          def foo(self):
            """Another docstring."""
            # Another multiline
            # comment
            pass
        a=          """Hello world"""


        # A multiline
        # comment
        class bar(object):
          """class docstring"""

          # class multiline
          # comment
          def foo(self):
            """Another docstring."""
            # Another multiline
            # comment
            pass
        r*   r   r   r   r   Ś testDocstringAndMultilineCommentL  s    


z5BasicReformatterTest.testDocstringAndMultilineCommentc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na¶          """Hello world

        RIP Dennis Richie.
        """
        # A multiline
        # comment
        class bar(object):
          """class docstring

          A classy class.
          """
          # class multiline
          # comment
          def foo(self):
            """Another docstring.

            A functional function.
            """
            # Another multiline
            # comment
            pass
        a¹          """Hello world

        RIP Dennis Richie.
        """


        # A multiline
        # comment
        class bar(object):
          """class docstring

          A classy class.
          """

          # class multiline
          # comment
          def foo(self):
            """Another docstring.

            A functional function.
            """
            # Another multiline
            # comment
            pass
        r*   r   r   r   r   Ś)testMultilineDocstringAndMultilineCommento  s    


z>BasicReformatterTest.testMultilineDocstringAndMultilineCommentc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        a = ( 1, )
        z        a = (1,)
        r*   r   r   r   r   ŚtestTupleCommaBeforeLastParen¤  s    


z2BasicReformatterTest.testTupleCommaBeforeLastParenc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nzw        def f():
          assert port >= minimum, 'Unexpected port %d when minimum was %d.' % (port, minimum)
        zĘ        def f():
          assert port >= minimum, 'Unexpected port %d when minimum was %d.' % (port,
                                                                               minimum)
        r*   r   r   r   r   ŚtestNoBreakOutsideOfBracket®  s    


z0BasicReformatterTest.testNoBreakOutsideOfBracketc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nzz        @foo()
        class A(object):
          @bar()
          @baz()
          def x(self):
            pass
        z{        @foo()
        class A(object):

          @bar()
          @baz()
          def x(self):
            pass
        r*   r   r   r   r   ŚtestBlankLinesBeforeDecorators¾  s    

	
z3BasicReformatterTest.testBlankLinesBeforeDecoratorsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz[        @foo()
        # frob
        @bar
        def x  (self):
            pass
        zW        @foo()
        # frob
        @bar
        def x(self):
          pass
        r*   r   r   r   r   ŚtestCommentBetweenDecoratorsÓ  s    


z1BasicReformatterTest.testCommentBetweenDecoratorsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzR        def given(y):
            [k for k in ()
              if k in y]
        zB        def given(y):
          [k for k in () if k in y]
        r*   r   r   r   r   ŚtestListComprehensionå  s    


z*BasicReformatterTest.testListComprehensionc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz²        def given(y):
            long_variable_name = [
                long_var_name + 1
                for long_var_name in ()
                if long_var_name == 2]
        z        def given(y):
          long_variable_name = [
              long_var_name + 1 for long_var_name in () if long_var_name == 2
          ]
        r*   r   r   r   r   Ś"testListComprehensionPreferOneLineņ  s    


z7BasicReformatterTest.testListComprehensionPreferOneLinec                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz¦        def given(used_identifiers):
          return (sum(len(identifier)
                      for identifier in used_identifiers) / len(used_identifiers))
        z¢        def given(used_identifiers):
          return (sum(len(identifier) for identifier in used_identifiers) /
                  len(used_identifiers))
        r*   r   r   r   r   Ś5testListComprehensionPreferOneLineOverArithmeticSplit  s    


zJBasicReformatterTest.testListComprehensionPreferOneLineOverArithmeticSplitc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzŅ        def given(y):
            long_variable_name = [
                long_var_name + 1
                for long_var_name, number_two in ()
                if long_var_name == 2 and number_two == 3]
        zÕ        def given(y):
          long_variable_name = [
              long_var_name + 1
              for long_var_name, number_two in ()
              if long_var_name == 2 and number_two == 3
          ]
        r*   r   r   r   r   Ś0testListComprehensionPreferThreeLinesForLineWrap  s    


zEBasicReformatterTest.testListComprehensionPreferThreeLinesForLineWrapc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzĪ        def given(y):
            long_variable_name = [
                long_var_name
                for long_var_name, number_two in ()
                if long_var_name == 2 and number_two == 3]
        zĆ        def given(y):
          long_variable_name = [
              long_var_name for long_var_name, number_two in ()
              if long_var_name == 2 and number_two == 3
          ]
        r*   r   r   r   r   Ś6testListComprehensionPreferNoBreakForTrivialExpression$  s    


zKBasicReformatterTest.testListComprehensionPreferNoBreakForTrivialExpressionc                 C   s(   d}d}t  |”}|  |t |”” d S )Nz5foo( (1, ) )
foo( ( 1, 2, 3  ) )
foo( ( 1, 2, 3, ) )
z7foo((1,))
foo((1, 2, 3))
foo((
    1,
    2,
    3,
))
©r   r   r   r   r   r   r   r   r   ŚtestOpeningAndClosingBrackets6  s    	
z2BasicReformatterTest.testOpeningAndClosingBracketsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz&        def foo():  return 42
        z/        def foo():
          return 42
        r*   r   r   r   r   ŚtestSingleLineFunctionsH  s    


z,BasicReformatterTest.testSingleLineFunctionsc                 C   s(   d}d}t  |”}|  |t |”” d S )NzUfind_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in node.child) + " >"
zZfind_symbol(node.type) + "< " + " ".join(
    find_pattern(n) for n in node.child) + " >"
rE   r   r   r   r   Ś!testNoQueueSeletionInMiddleOfLineS  s    
z6BasicReformatterTest.testNoQueueSeletionInMiddleOfLinec                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz>        aaaaaaaaaa = bbbbbbbb.ccccccccc() [42] (a, 2)
        z<        aaaaaaaaaa = bbbbbbbb.ccccccccc()[42](a, 2)
        r*   r   r   r   r   Ś%testNoSpacesBetweenSubscriptsAndCallsa  s    


z:BasicReformatterTest.testNoSpacesBetweenSubscriptsAndCallsc                 C   sd   t  d”}t  d”}t |”}|  |t |”” t  d”}t  d”}t |”}|  |t |”” d S )Nz=        aaaaaaaaaa = bbbbbbbb.ccccccccc[ -1 ]( -42 )
        z9        aaaaaaaaaa = bbbbbbbb.ccccccccc[-1](-42)
        zp        aaaaaaaaaa = bbbbbbbb.ccccccccc( *varargs )
        aaaaaaaaaa = bbbbbbbb.ccccccccc( **kwargs )
        zl        aaaaaaaaaa = bbbbbbbb.ccccccccc(*varargs)
        aaaaaaaaaa = bbbbbbbb.ccccccccc(**kwargs)
        r*   r   r   r   r   Ś4testNoSpacesBetweenOpeningBracketAndStartingOperatork  s    





zIBasicReformatterTest.testNoSpacesBetweenOpeningBracketAndStartingOperatorc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nzc        if True:
            # This is a multiline
            # comment.
            pass
        z]        if True:
          # This is a multiline
          # comment.
          pass
        r*   r   r   r   r   ŚtestMultilineCommentReformatted  s    


z4BasicReformatterTest.testMultilineCommentReformattedc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na          _PYTHON_STATEMENTS = frozenset({
            lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', 'del_stmt':
            'pass_stmt', lambda: 'break_stmt': 'continue_stmt', 'return_stmt': 'raise_stmt',
            'yield_stmt': 'import_stmt', lambda: 'global_stmt': 'exec_stmt', 'assert_stmt':
            'if_stmt', 'while_stmt': 'for_stmt',
        })
        aæ          _PYTHON_STATEMENTS = frozenset({
            lambda x, y: 'simple_stmt': 'small_stmt',
            'expr_stmt': 'print_stmt',
            'del_stmt': 'pass_stmt',
            lambda: 'break_stmt': 'continue_stmt',
            'return_stmt': 'raise_stmt',
            'yield_stmt': 'import_stmt',
            lambda: 'global_stmt': 'exec_stmt',
            'assert_stmt': 'if_stmt',
            'while_stmt': 'for_stmt',
        })
        r*   r   r   r   r   ŚtestDictionaryMakerFormatting  s    


z2BasicReformatterTest.testDictionaryMakerFormattingc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nzį        if True:
          aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv)
          aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv)
        aA          if True:
          aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy,
                                                vvvvvvvvv)
          aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy,
                                                vvvvvvvvv)
        r*   r   r   r   r   ŚtestSimpleMultilineCode«  s    


z,BasicReformatterTest.testSimpleMultilineCodec                 C   s*   t  d”}t |”}|  |t |”” d S )Nz        if Foo:
          # Hello world
          # Yo man.
          # Yo man.
          # Yo man.
          # Yo man.
          a = 42
        r*   r3   r   r   r   ŚtestMultilineComment½  s    
	
z)BasicReformatterTest.testMultilineCommentc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz"        b = '0' ('hello')
        r*   r3   r   r   r   Ś$testSpaceBetweenStringAndParenthesesŹ  s    

z9BasicReformatterTest.testSpaceBetweenStringAndParenthesesc                 C   sZ   t  d”}t |”}|  |t |”” t  d”}t  d”}t |”}|  |t |”” d S )Nzą        code = textwrap.dedent('''            if Foo:
              # Hello world
              # Yo man.
              # Yo man.
              # Yo man.
              # Yo man.
              a = 42
            ''')
        aW          def f():
            email_text += """<html>This is a really long docstring that goes over the column limit and is multi-line.<br><br>
        <b>Czar: </b>"""+despot["Nicholas"]+"""<br>
        <b>Minion: </b>"""+serf["Dmitri"]+"""<br>
        <b>Residence: </b>"""+palace["Winter"]+"""<br>
        </body>
        </html>"""
        aa          def f():
          email_text += """<html>This is a really long docstring that goes over the column limit and is multi-line.<br><br>
        <b>Czar: </b>""" + despot["Nicholas"] + """<br>
        <b>Minion: </b>""" + serf["Dmitri"] + """<br>
        <b>Residence: </b>""" + palace["Winter"] + """<br>
        </body>
        </html>"""
        r*   )r   r4   r"   r    r!   r   r   r   ŚtestMultilineStringŃ  s    


	
	
z(BasicReformatterTest.testMultilineStringc                 C   s*   t  d”}t |”}|  |t |”” d S )Na           if (  # This is the first comment
            a and  # This is the second comment
            # This is the third comment
            b):  # A trailing comment
          # Whoa! A normal comment!!
          pass  # Another trailing comment
        r*   r3   r   r   r   ŚtestSimpleMultilineWithCommentsõ  s    

z4BasicReformatterTest.testSimpleMultilineWithCommentsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        def f():
          raise RuntimeError('unable to find insertion point for target node',
                             (target,))
        r*   r   r   r   r   Ś"testMatchingParenSplittingMatching  s    


z7BasicReformatterTest.testMatchingParenSplittingMatchingc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na          class F:
          def _ProcessArgLists(self, node):
            """Common method for processing argument lists."""
            for child in node.children:
              if isinstance(child, pytree.Leaf):
                self._SetTokenSubtype(
                    child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get(
                        child.value, format_token.Subtype.NONE))
        a½          class F:

          def _ProcessArgLists(self, node):
            """Common method for processing argument lists."""
            for child in node.children:
              if isinstance(child, pytree.Leaf):
                self._SetTokenSubtype(
                    child,
                    subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get(child.value,
                                                          format_token.Subtype.NONE))
        r*   r   r   r   r   ŚtestContinuationIndent  s    



z+BasicReformatterTest.testContinuationIndentc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzD        a = { 42, }
        b = ( 42, )
        c = [ 42, ]
        zj        a = {
            42,
        }
        b = (42,)
        c = [
            42,
        ]
        r*   r   r   r   r   ŚtestTrailingCommaAndBracket)  s    

	
z0BasicReformatterTest.testTrailingCommaAndBracketc                 C   sP   t  d”}t |”}|  |t |”” t  d”}t |”}|  |t |”” d S )Na           N_('Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world.')  # A comment is here.
        a          foo('Fake function call')  #. Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world.
        r*   r3   r   r   r   ŚtestI18n;  s    



zBasicReformatterTest.testI18nc                 C   s*   t  d”}t |”}|  |t |”” d S )Nzß        def f():
          return collections.OrderedDict({
              #. First i18n comment.
              'bork': 'foo',

              #. Second i18n comment.
              'snork': 'bar#.*=\\0',
          })
        r*   r3   r   r   r   ŚtestI18nCommentsInDataLiteralH  s    


z2BasicReformatterTest.testI18nCommentsInDataLiteralc                 C   s*   t  d”}t |”}|  |t |”” d S )Na          def f():

          def g():
            while (xxxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and
                   xxxxxxxxxxxxxxxxxxxxx(
                       yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'):
              pass
        r*   r3   r   r   r   ŚtestClosingBracketIndentV  s    
	
z-BasicReformatterTest.testClosingBracketIndentc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na           class Foo(object):

          def bar(self):
            self.aaaaaaaa = xxxxxxxxxxxxxxxxxxx.yyyyyyyyyyyyy(
                self.cccccc.ddddddddd.eeeeeeee,
                options={
                    "forkforkfork": 1,
                    "borkborkbork": 2,
                    "corkcorkcork": 3,
                    "horkhorkhork": 4,
                    "porkporkpork": 5,
                    })
        a          class Foo(object):

          def bar(self):
            self.aaaaaaaa = xxxxxxxxxxxxxxxxxxx.yyyyyyyyyyyyy(
                self.cccccc.ddddddddd.eeeeeeee,
                options={
                    "forkforkfork": 1,
                    "borkborkbork": 2,
                    "corkcorkcork": 3,
                    "horkhorkhork": 4,
                    "porkporkpork": 5,
                })
        r*   r   r   r   r   Ś testClosingBracketsInlinedInCallc  s    


z5BasicReformatterTest.testClosingBracketsInlinedInCallc                 C   s*   t  d”}t |”}|  |t |”” d S )Na           class A:

          def x(self, node, name, n=1):
            for i, child in enumerate(
                itertools.ifilter(lambda c: pytree_utils.NodeName(c) == name,
                                  node.pre_order())):
              pass
        r*   r3   r   r   r   ŚtestLineWrapInForExpression  s    
	
z0BasicReformatterTest.testLineWrapInForExpressionc                 C   s$   d}t  |”}|  |t |”” d S )NzŻclass foo:

  def bar(self, node, name, n=1):
    if True:
      if True:
        return [(aaaaaaaaaa,
                 bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(
                     cccc, ddddddddddddddddddddddddddddddddddddd))]
rE   r3   r   r   r   Ś testFunctionCallContinuationLine  s    

z5BasicReformatterTest.testFunctionCallContinuationLinec                 C   s*   t  d”}t |”}|  |t |”” d S )Nzū        class F(object):

          def __init__(self, fieldname,
                       #. Error message indicating an invalid e-mail address.
                       message=N_('Please check your email address.'), **kwargs):
            pass
        r*   r3   r   r   r   ŚtestI18nNonFormatting  s    

z*BasicReformatterTest.testI18nNonFormattingc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz-        if ~(a or b):
          pass
        r*   r3   r   r   r   Ś(testNoSpaceBetweenUnaryOpAndOpeningParenŖ  s    

z=BasicReformatterTest.testNoSpaceBetweenUnaryOpAndOpeningParenc                 C   s*   t  d”}t |”}|  |t |”” d S )NaH          class Foo(object):

          a = 42

          # This is a comment.
          def __init__(self,
                       xxxxxxx,
                       yyyyy=0,
                       zzzzzzz=None,
                       aaaaaaaaaaaaaaaaaa=False,
                       bbbbbbbbbbbbbbb=False):
            pass
        r*   r3   r   r   r   ŚtestCommentBeforeFuncDef²  s    

z-BasicReformatterTest.testCommentBeforeFuncDefc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na8          class Fnord(object):
          def Moo(self):
            aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb(
                ccccccccccccc=ccccccccccccc, ddddddd=ddddddd, eeee=eeee,
                fffff=fffff, ggggggg=ggggggg, hhhhhhhhhhhhh=hhhhhhhhhhhhh,
                iiiiiii=iiiiiiiiiiiiii)
        ay          class Fnord(object):

          def Moo(self):
            aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb(
                ccccccccccccc=ccccccccccccc,
                ddddddd=ddddddd,
                eeee=eeee,
                fffff=fffff,
                ggggggg=ggggggg,
                hhhhhhhhhhhhh=hhhhhhhhhhhhh,
                iiiiiii=iiiiiiiiiiiiii)
        r*   r   r   r   r   Ś&testExcessLineCountWithDefaultKeywordsÄ  s    


z;BasicReformatterTest.testExcessLineCountWithDefaultKeywordsc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz7        if not (this and that):
          pass
        r*   r3   r   r   r   ŚtestSpaceAfterNotOperatorŻ  s    

z.BasicReformatterTest.testSpaceAfterNotOperatorc                 C   s*   t  d”}t |”}|  |t |”” d S )Nzž        def f():
          if True:
            if True:
              python_files.extend(
                  os.path.join(filename, f)
                  for f in os.listdir(filename)
                  if IsPythonFile(os.path.join(filename, f)))
        r*   r3   r   r   r   ŚtestNoPenaltySplittingå  s    
	
z+BasicReformatterTest.testNoPenaltySplittingc                 C   s*   t  d”}t |”}|  |t |”” d S )NzŪ      def f():
        if ((left.value == '(' and right.value == ')') or
            (left.value == '[' and right.value == ']') or
            (left.value == '{' and right.value == '}')):
          return False
        r*   r3   r   r   r   ŚtestExpressionPenaltiesņ  s    

z,BasicReformatterTest.testExpressionPenaltiesc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        while True: continue
        for x in range(3): continue
        try: a = 42
        except: b = 42
        with open(a) as fd: a = fd.read()
        zŠ        while True:
          continue
        for x in range(3):
          continue
        try:
          a = 42
        except:
          b = 42
        with open(a) as fd:
          a = fd.read()
        r*   r   r   r   r   Ś"testLineDepthOfSingleLineStatementż  s    


z7BasicReformatterTest.testLineDepthOfSingleLineStatementc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        FOO = ['bar', 'baz', 'mux', 'qux', 'quux', 'quuux', 'quuuux',
          'quuuuux', 'quuuuuux', 'quuuuuuux', lambda a, b: 37,]
        a          FOO = [
            'bar',
            'baz',
            'mux',
            'qux',
            'quux',
            'quuux',
            'quuuux',
            'quuuuux',
            'quuuuuux',
            'quuuuuuux',
            lambda a, b: 37,
        ]
        r*   r   r   r   r   Ś!testSplitListWithTerminatingComma  s    


z6BasicReformatterTest.testSplitListWithTerminatingCommac                 C   s*   t  d”}t |”}|  |t |”” d S )Nav          FOO = [
            'bar',  # bar
            'baz',  # baz
            'mux',  # mux
            'qux',  # qux
            'quux',  # quux
            'quuux',  # quuux
            'quuuux',  # quuuux
            'quuuuux',  # quuuuux
            'quuuuuux',  # quuuuuux
            'quuuuuuux',  # quuuuuuux
            lambda a, b: 37  # lambda
        ]
        r*   r3   r   r   r   Ś%testSplitListWithInterspersedComments+  s    

z:BasicReformatterTest.testSplitListWithInterspersedCommentsc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz%        from ... import bork
        r*   r3   r   r   r   ŚtestRelativeImportStatements>  s    

z1BasicReformatterTest.testRelativeImportStatementsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzŖ        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa(
            ("...", "."), "..",
            ".............................................."
        )
        z        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa(
            ("...", "."), "..", "..............................................")
        r*   r   r   r   r   ŚtestSingleLineListE  s    


z'BasicReformatterTest.testSingleLineListc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na5          import signal


        try:
          signal.SIGALRM
          # ..................................................................
          # ...............................................................


          def timeout(seconds=1):
            pass
        except:
          pass
        a5          import signal

        try:
          signal.SIGALRM

          # ..................................................................
          # ...............................................................


          def timeout(seconds=1):
            pass
        except:
          pass
        r*   r   r   r   r   Ś,testBlankLinesBeforeFunctionsNotInColumnZeroT  s    


zABasicReformatterTest.testBlankLinesBeforeFunctionsNotInColumnZeroc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz¹        class A(object):

          def b(self):
            if self.aaaaaaaaaaaaaaaaaaaa not in self.bbbbbbbbbb(
                cccccccccccccccccccc=True):
              pass
        r*   r3   r   r   r   ŚtestNoKeywordArgumentBreakagev  s    

z2BasicReformatterTest.testNoKeywordArgumentBreakagec                 C   s$   d}t  |”}|  |t |”” d S )Nzōurlpatterns = patterns('', url(r'^$', 'homepage_view'),
                       url(r'^/login/$', 'login_view'),
                       url(r'^/login/$', 'logout_view'),
                       url(r'^/user/(?P<username>\w+)/$', 'profile_view'))
rE   r3   r   r   r   ŚtestTrailerOnSingleLine  s    
z,BasicReformatterTest.testTrailerOnSingleLinec                 C   s*   t  d”}t |”}|  |t |”” d S )NzČ        class Foo:

          def bar():
            if True:
              if (child.type == grammar_token.NAME and
                  child.value in substatement_names):
                pass
        r*   r3   r   r   r   ŚtestIfConditionalParens  s    
	
z,BasicReformatterTest.testIfConditionalParensc                 C   sv   t  d”}t |”}|  |t |”” t  d”}t |”}|  |t |”” t  d”}t |”}|  |t |”” d S )Na          text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. "\
               "Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur "\
               "ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis "\
               "sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. "\
               "Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet"
        z        from __future__ import nested_scopes, generators, division, absolute_import, with_statement, \
            print_function, unicode_literals
        zl        if aaaaaaaaa == 42 and bbbbbbbbbbbbbb == 42 and \
           cccccccc == 42:
          pass
        r*   r3   r   r   r   ŚtestContinuationMarkers  s    





z,BasicReformatterTest.testContinuationMarkersc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz        def fn(arg):
          v = fn2(key1=True,
                  #c1
                  key2=arg)\
                        .fn3()
        r*   r3   r   r   r   Ś#testCommentsWithContinuationMarkers³  s    

z8BasicReformatterTest.testCommentsWithContinuationMarkersc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz?        xyz = \
            \
            some_thing()
        r*   r3   r   r   r   ŚtestMultipleContinuationMarkers¾  s    

z4BasicReformatterTest.testMultipleContinuationMarkersc                 C   s$   d}t  |”}|  |t |”” d S )Nz$s = 'foo \
    bar' \
    .format()
rE   r3   r   r   r   Ś1testContinuationMarkerAfterStringWithContinuationĒ  s    
zFBasicReformatterTest.testContinuationMarkerAfterStringWithContinuationc                 C   s*   t  d”}t |”}|  |t |”” d S )NzŁ        flags.DEFINE_list(
            'output_dirs', [],
            'Lorem ipsum dolor sit amet, consetetur adipiscing elit. Donec a diam lectus. '
            'Sed sit amet ipsum mauris. Maecenas congue.')
        r*   r3   r   r   r   ŚtestEmptyContainersŠ  s    

z(BasicReformatterTest.testEmptyContainersc                 C   sZ   t  d”}t  d”}t |”}|  |t |”” t  d”}t |”}|  |t |”” d S )Nzė        a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd')
        aP          a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx'
                     'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} +
                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
                    'bbbbbbbbbbbbbbbbbbbbbbbbbb'
                    'cccccccccccccccccccccccccccccccc'
                    'ddddddddddddddddddddddddddddd')
        z        a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd'
        r*   ©r   r    r!   r"   r4   r   r   r   Ś$testSplitStringsIfSurroundedByParensŚ  s    




z9BasicReformatterTest.testSplitStringsIfSurroundedByParensc                 C   s*   t  d”}t |”}|  |t |”” d S )Nzź        #!/bin/sh
        if "true" : ''''
        then

        export FOO=123
        exec /usr/bin/env python "$0" "$@"

        exit 127
        fi
        '''

        import os

        assert os.environ['FOO'] == '123'
        r*   r3   r   r   r   ŚtestMultilineShebangń  s    

z)BasicReformatterTest.testMultilineShebangc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz        a_very_long_function_call_yada_yada_etc_etc_etc(long_arg1,
                                                        long_arg2 / long_arg3)
        r*   r3   r   r   r   Ś"testNoSplittingAroundTermOperators  s    

z7BasicReformatterTest.testNoSplittingAroundTermOperatorsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Naģ          c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)

        c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        ai          c = (
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
            is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        c = (
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
            in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        c = (
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
            not in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)

        c = (
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
            is bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        c = (
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
            <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)
        r*   )r   r4   Śexpected_coder"   r   r   r   Ś"testNoSplittingAroundCompOperators  s    


z7BasicReformatterTest.testNoSplittingAroundCompOperatorsc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz        somequitelongvariablename.somemember[(a, b)] = {
            'somelongkey': 1,
            'someotherlongkey': 2
        }
        r*   r3   r   r   r   Ś"testNoSplittingWithinSubscriptList+  s    

z7BasicReformatterTest.testNoSplittingWithinSubscriptListc                 C   sZ   t  d”}t |”}|  |t |”” t  d”}t  d”}t |”}|  |t |”” d S )Nz“        class foo:

          def bar(self):
            self.write(s=[
                '%s%s %s' % ('many of really', 'long strings', '+ just makes up 81')
            ])
        z·        def _():
          if True:
            if True:
              if contract == allow_contract and attr_dict.get(if_attribute) == has_value:
                return True
        zŹ        def _():
          if True:
            if True:
              if contract == allow_contract and attr_dict.get(
                  if_attribute) == has_value:
                return True
        r*   ©r   r4   r"   r    rt   r   r   r   ŚtestExcessCharacters5  s    




z)BasicReformatterTest.testExcessCharactersc                 C   sZ   t  d”}t |”}|  |t |”” t  d”}t  d”}t |”}|  |t |”” d S )Nz        foo = {
            variable: 'hello world. How are you today?'
            for variable in fnord
            if variable != 37
        }
        zN        foo = {
            x: x
            for x in fnord
        }
        z,        foo = {x: x for x in fnord}
        r*   rw   r   r   r   ŚtestDictSetGeneratorS  s    




z)BasicReformatterTest.testDictSetGeneratorc                 C   s*   t  d”}t |”}|  |t |”” d S )NzZ        beta = "123"

        test = {'alpha': beta[-1]}

        print(beta[-1])
        r*   r3   r   r   r   ŚtestUnaryOpInDictionaryValuej  s    

z1BasicReformatterTest.testUnaryOpInDictionaryValuec                 C   s*   t  d”}t |”}|  |t |”” d S )Nzś        if True:
          if True:
            if True:
              if True:
                remote_checksum = self.get_checksum(conn, tmp, dest, inject,
                                                    not directory_prepended, source)
        r*   r3   r   r   r   ŚtestUnaryNotOperatoru  s    

z)BasicReformatterTest.testUnaryNotOperatorc                 C   s$   d}t  |”}|  |t |”” d S )Na  class A(object):

  def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row):
    if True:
      if True:
        if True:
          if True:
            if row[4] is None or row[5] is None:
              bbbbbbbbbbbbb[
                  '..............'] = row[5] if row[5] is not None else 5
rE   r3   r   r   r   ŚtestRelaxArraySubscriptAffinity  s    
z4BasicReformatterTest.testRelaxArraySubscriptAffinityc                 C   s$   d}t  |”}|  |t |”” d S )Nza = {'a': b(c=d, **e)}
rE   r3   r   r   r   ŚtestFunctionCallInDict  s    
z+BasicReformatterTest.testFunctionCallInDictc                 C   s$   d}t  |”}|  |t |”” d S )Nz%a = {'a': {'a': {'a': b(c=d, **e)}}}
rE   r3   r   r   r   ŚtestFunctionCallInNestedDict  s    
z1BasicReformatterTest.testFunctionCallInNestedDictc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz«        def test():
          if not "Foooooooooooooooooooooooooooooo" or "Foooooooooooooooooooooooooooooo" == "Foooooooooooooooooooooooooooooo":
            pass
        r*   r3   r   r   r   ŚtestUnbreakableNot  s    

z'BasicReformatterTest.testUnbreakableNotc                 C   s*   t  d”}t |”}|  |t |”” d S )NzU      a = [
          'a',
          'b',
          'c'  # hello world
      ]
      r*   r3   r   r   r   ŚtestSplitListWithComment¤  s    

z-BasicReformatterTest.testSplitListWithCommentc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nag        class Test:

        def testSomething(self):
          expected = {
              ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc',
              ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc',
              ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc',
          }
        a        class Test:

        def testSomething(self):
          expected = {
              ('aaaaaaaaaaaaa', 'bbbb'):
                  'ccccccccccccccccccccccccccccccccccccccccccc',
              ('aaaaaaaaaaaaa', 'bbbb'):
                  'ccccccccccccccccccccccccccccccccccccccccccc',
              ('aaaaaaaaaaaaa', 'bbbb'):
                  'ccccccccccccccccccccccccccccccccccccccccccc',
          }
        r*   r   r   r   r   ŚtestOverColumnLimitÆ  s    



z(BasicReformatterTest.testOverColumnLimitc                 C   s*   t  d”}t |”}|  |t |”” d S )NzŚ      a = f(
          a="something",
          b="something requiring comment which is quite long",  # comment about b (pushes line over 79)
          c="something else, about which comment doesn't make sense")
      r*   r3   r   r   r   ŚtestEndingCommentŹ  s    

z&BasicReformatterTest.testEndingCommentc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz      def fn():
        return module \
               .method(Object(data,
                   fn2(arg)
               ))
      r*   r3   r   r   r   ŚtestContinuationSpaceRetentionŌ  s    

z3BasicReformatterTest.testContinuationSpaceRetentionc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz©      if x or z.y(
          a,
          c,
          aaaaaaaaaaaaaaaaaaaaa=aaaaaaaaaaaaaaaaaa,
          bbbbbbbbbbbbbbbbbbbbb=bbbbbbbbbbbbbbbbbb):
        pass
      r*   r3   r   r   r   Ś testIfExpressionWithFunctionCallß  s    

z5BasicReformatterTest.testIfExpressionWithFunctionCallc                 C   s*   t  d”}t |”}|  |t |”” d S )Nzi      def foo():
        com_text = \
      '''
      TEST
      ''' % (input_fname, output_fname)
      r*   r3   r   r   r   Ś#testUnformattedAfterMultilineStringė  s    

z8BasicReformatterTest.testUnformattedAfterMultilineStringc                 C   s*   t  d”}t |”}|  |t |”” d S )Nzŗ      sources = {
          'json': request.get_json(silent=True) or {},
          'json2': request.get_json(silent=True),
      }
      json = request.get_json(silent=True) or {}
      r*   r3   r   r   r   Ś&testNoSpacesAroundKeywordDefaultValuesö  s    

z;BasicReformatterTest.testNoSpacesAroundKeywordDefaultValuesc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        if True:
          if True:
            status = cf.describe_stacks(StackName=stackname)[u'Stacks'][0][u'StackStatus']
        z        if True:
          if True:
            status = cf.describe_stacks(
                StackName=stackname)[u'Stacks'][0][u'StackStatus']
        r*   r   r   r   r   Ś+testNoSplittingBeforeEndingSubscriptBracket  s    


z@BasicReformatterTest.testNoSplittingBeforeEndingSubscriptBracketc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Naų          xxxxxxxxxxxxxx = (re.search(r'(\d+\.\d+\.\d+\.)\d+',
                                    aaaaaaa.bbbbbbbbbbbb).group(1) +
                          re.search(r'\d+\.\d+\.\d+\.(\d+)',
                                    ccccccc).group(1))
        xxxxxxxxxxxxxx = (re.search(r'(\d+\.\d+\.\d+\.)\d+',
                                    aaaaaaa.bbbbbbbbbbbb).group(a.b) +
                          re.search(r'\d+\.\d+\.\d+\.(\d+)',
                                    ccccccc).group(c.d))
        af          xxxxxxxxxxxxxx = (
            re.search(r'(\d+\.\d+\.\d+\.)\d+', aaaaaaa.bbbbbbbbbbbb).group(1) +
            re.search(r'\d+\.\d+\.\d+\.(\d+)', ccccccc).group(1))
        xxxxxxxxxxxxxx = (
            re.search(r'(\d+\.\d+\.\d+\.)\d+', aaaaaaa.bbbbbbbbbbbb).group(a.b) +
            re.search(r'\d+\.\d+\.\d+\.(\d+)', ccccccc).group(c.d))
        r*   r   r   r   r   ŚtestNoSplittingOnSingleArgument  s    



z4BasicReformatterTest.testNoSplittingOnSingleArgumentc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nzö        while True:
          while True:
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list['bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',')
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list('bbbbbbbbbbbbbbbbbbbbbbbbb').split(',')
        a          while True:
          while True:
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list[
                'bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',')
            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list(
                'bbbbbbbbbbbbbbbbbbbbbbbbb').split(',')
        r*   r   r   r   r   ŚtestSplittingArraysSensibly&  s    


z0BasicReformatterTest.testSplittingArraysSensiblyc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        class f:

          def __repr__(self):
            tokens_repr = ','.join(['{0}({1!r})'.format(tok.name, tok.value) for tok in self._tokens])
        z°        class f:

          def __repr__(self):
            tokens_repr = ','.join(
                ['{0}({1!r})'.format(tok.name, tok.value) for tok in self._tokens])
        r*   r   r   r   r   ŚtestComprehensionForAndIf8  s    


z.BasicReformatterTest.testComprehensionForAndIfc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na          def f():
          if True:
            pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix(
                comment_prefix, comment_lineno, comment_column,
                standalone=True), ancestor_at_indent)
            pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix(
                comment_prefix, comment_lineno, comment_column,
                standalone=True))
        aŖ          def f():
          if True:
            pytree_utils.InsertNodesBefore(
                _CreateCommentsFromPrefix(
                    comment_prefix, comment_lineno, comment_column, standalone=True),
                ancestor_at_indent)
            pytree_utils.InsertNodesBefore(
                _CreateCommentsFromPrefix(
                    comment_prefix, comment_lineno, comment_column, standalone=True))
        r*   r   r   r   r   ŚtestFunctionCallArgumentsI  s    



z.BasicReformatterTest.testFunctionCallArgumentsc                 C   sZ   t  d”}t  d”}t |”}|  |t |”” t  d”}t |”}|  |t |”” d S )NzX        a = b ** 37
        c = (20 ** -3) / (_GRID_ROWS ** (code_length - 10))
        zR        a = b**37
        c = (20**-3) / (_GRID_ROWS**(code_length - 10))
        a        def f():
        if True:
          if (self.stack[-1].split_before_closing_bracket and
              # FIXME(morbo): Use the 'matching_bracket' instead of this.
              # FIXME(morbo): Don't forget about tuples!
              current.value in ']}'):
            pass
      r*   rp   r   r   r   ŚtestBinaryOperatorsb  s    



	
z(BasicReformatterTest.testBinaryOperatorsc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz      [retval1, retval2] = a_very_long_function(argument_1, argument2, argument_3,
                                                argument_4)
      r*   r3   r   r   r   ŚtestContiguousListz  s    

z'BasicReformatterTest.testContiguousListc                 C   sP   t  d”}t |”}|  |t |”” t  d”}t |”}|  |t |”” d S )Nz      a(a=aaaaaaaaaaaaaaaaaaaaa,
        b=aaaaaaaaaaaaaaaaaaaaaaaa,
        c=aaaaaaaaaaaaaaaaaa,
        *d,
        **e)
      z«      def foo():
        return [
            Bar(xxx='some string',
                yyy='another long string',
                zzz='a third long string')
        ]
      r*   r3   r   r   r   ŚtestArgsAndKwargsFormatting  s    



z0BasicReformatterTest.testArgsAndKwargsFormattingc                 C   s*   t  d”}t |”}|  |t |”” d S )Nzõ      def f():
        if True:
          TaskManager.get_tags = MagicMock(
              name='get_tags_mock',
              return_value=[157031694470475],
              # side_effect=[(157031694470475), (157031694470475),],
          )
      r*   r3   r   r   r   ŚtestCommentColumnLimitOverflow  s    
	
z3BasicReformatterTest.testCommentColumnLimitOverflowc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )NaH          class SomeClass(object):
          do_something = True

          def succeeded(self, dddddddddddddd):
            d = defer.succeed(None)

            if self.do_something:
              d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccc(dddddddddddddd))
            return d
        ae          class SomeClass(object):
          do_something = True

          def succeeded(self, dddddddddddddd):
            d = defer.succeed(None)

            if self.do_something:
              d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb.
                            cccccccccccccccccccccccccccccccc(dddddddddddddd))
            return d
        z5{based_on_style: yapf, allow_multiline_lambdas: true}r/   r   r   r   r   ŚtestMultilineLambdas„  s    

’’
’z)BasicReformatterTest.testMultilineLambdasc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )NaR          MAP_WITH_LONG_KEYS = {
            ('lorem ipsum', 'dolor sit amet'):
                1,
            ('consectetur adipiscing elit.', 'Vestibulum mauris justo, ornare eget dolor eget'):
                2,
            ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',):
                3
        }
        a_          MAP_WITH_LONG_KEYS = {
            ('lorem ipsum', 'dolor sit amet'):
                1,
            ('consectetur adipiscing elit.',
             'Vestibulum mauris justo, ornare eget dolor eget'):
                2,
            ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',):
                3
        }
        z={based_on_style: yapf, allow_multiline_dictionary_keys: true}r/   r   r   r   r   ŚtestMultilineDictionaryKeysČ  s    


’
’z0BasicReformatterTest.testMultilineDictionaryKeysc              
   C   s   t  d”}zbt t d”” t |”}t |”}|  	||” t |”}t |”}|  	||” W t t 
” ” nt t 
” ” 0 d S )Na^          class A(object):

          def method(self):
            filters = {
                'expressions': [{
                    'field': {
                        'search_field': {
                            'user_field': 'latest_party__number_of_guests'
                        },
                    }
                }]
            }
        zd{based_on_style: pep8, indent_width: 2, continuation_indent_width: 4, indent_dictionary_value: True}©r   r   r   r
   r   r   r   r   r   r   r   ©r   r4   r"   Śreformatted_coder   r   r   ŚtestStableDictionaryFormattingé  s    
’



z3BasicReformatterTest.testStableDictionaryFormattingc              
   C   s   ztt  t  ” ” t d”}t d”}t |”}t |”}|  	||” t |”}t |”}|  	||” W t  t  
” ” nt  t  
” ” 0 d S )Nzø          def _():
              url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format(
                  value, urllib.urlencode({'action': 'update', 'parameter': value}))
          zų          def _():
              url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format(
                  value, urllib.urlencode({
                      'action': 'update',
                      'parameter': value
                  }))
          )r   r
   ZCreatePEP8Styler   r   r   r   r   r   r   r   ©r   r    r!   r"   r   r   r   r   Ś%testStableInlinedDictionaryFormatting	  s    

	



z:BasicReformatterTest.testStableInlinedDictionaryFormattingc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        def mark_game_scored(gid):
          _connect.execute(_games.update().where(_games.c.gid == gid).values(
              scored=True))
        z        def mark_game_scored(gid):
          _connect.execute(
              _games.update().where(_games.c.gid == gid).values(scored=True))
        r*   r   r   r   r   Ś"testDontSplitKeywordValueArguments$  s    


z7BasicReformatterTest.testDontSplitKeywordValueArgumentsc                 C   s*   t  d”}t |”}|  |t |”” d S )Nzg      query = '''SELECT id
      FROM table
      WHERE day in {}'''
      days = ",".join(days)
      r*   r3   r   r   r   Ś(testDontAddBlankLineAfterMultilineString2  s    

z=BasicReformatterTest.testDontAddBlankLineAfterMultilineStringc                 C   s*   t  d”}t |”}|  |t |”” d S )Na$        def a():
        if True:
          if True:
            if True:
              columns = [
                  x for x, y in self._heap_this_is_very_long if x.route[0] == choice
              ]
              self._heap = [x for x in self._heap if x.route and x.route[0] == choice]
      r*   r3   r   r   r   Ś testFormattingListComprehensions<  s    


z5BasicReformatterTest.testFormattingListComprehensionsc              
   C   s   t  d”}zbt t d”” t |”}t |”}|  	||” t |”}t |”}|  	||” W t t 
” ” nt t 
” ” 0 d S )Naj          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,
        )

        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
        )
        z¦{based_on_style: pep8, indent_width: 2, continuation_indent_width: 4, indent_dictionary_value: True, dedent_closing_brackets: True, split_before_named_assigns: False}r   r   r   r   r   ŚtestNoSplittingWhenBinPackingJ  s    
’’



z2BasicReformatterTest.testNoSplittingWhenBinPackingc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b(c == d[
                'eeeeee']).ffffff():
          pass
        z        if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b(
            c == d['eeeeee']).ffffff():
          pass
        r*   r   r   r   r   ŚtestNotSplittingAfterSubscriptk  s    


z3BasicReformatterTest.testNotSplittingAfterSubscriptc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nzę        def _():
          if True:
            if True:
              if True:
                if True:
                  if True:
                    boxes[id_] = np.concatenate((points.min(axis=0), qoints.max(axis=0)))
        z’        def _():
          if True:
            if True:
              if True:
                if True:
                  if True:
                    boxes[id_] = np.concatenate(
                        (points.min(axis=0), qoints.max(axis=0)))
        r*   r   r   r   r   ŚtestSplittingOneArgumentListy  s    
	


z1BasicReformatterTest.testSplittingOneArgumentListc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NaŅ          class _():
          @classmethod
          def _pack_results_for_constraint_or(cls, combination, constraints):
            if True:
              if True:
                if True:
                  return cls._create_investigation_result(
                          (
                                  clue for clue in combination if not clue == Verifier.UNMATCHED
                          ), constraints, InvestigationResult.OR
                  )
        a          class _():

          @classmethod
          def _pack_results_for_constraint_or(cls, combination, constraints):
            if True:
              if True:
                if True:
                  return cls._create_investigation_result(
                      (clue for clue in combination if not clue == Verifier.UNMATCHED),
                      constraints, InvestigationResult.OR)
        r*   r   r   r   r   Ś+testSplittingBeforeFirstElementListArgument  s    


z@BasicReformatterTest.testSplittingBeforeFirstElementListArgumentc              
   C   s   t  d”}t  d”}zbt t d”” t |”}t |”}|  	||” t |”}t |”}|  	||” W t t 
” ” nt t 
” ” 0 d S )NaĮ          function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3)

        function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3,)

        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)

        a_very_long_function_name(long_argument_name_1, long_argument_name_2, long_argument_name_3, long_argument_name_4,)

        r =f0 (1,  2,3,)
        a          function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3)

        function_name(
            argument_name_1=1,
            argument_name_2=2,
            argument_name_3=3,
        )

        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)

        a_very_long_function_name(
            long_argument_name_1,
            long_argument_name_2,
            long_argument_name_3,
            long_argument_name_4,
        )

        r = f0(
            1,
            2,
            3,
        )
        zC{based_on_style: yapf, split_arguments_when_comma_terminated: True}r   r   r   r   r   Ś'testSplittingArgumentsTerminatedByComma­  s    

’’



z<BasicReformatterTest.testSplittingArgumentsTerminatedByCommac                 C   s*   t  d”}t |”}|  |t |”” d S )Nz        from toto import titi, tata, tutu  # noqa
        from toto import titi, tata, tutu
        from toto import (titi, tata, tutu)
        r*   r3   r   r   r   ŚtestImportAsListę  s    

z%BasicReformatterTest.testImportAsListc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NaB          a = {
        'aaaaaaaaaaaaaaaaaaaaaaaa':
            Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True),
        'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb':
            Check('YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY', '=', True),
        'ccccccccccccccc':
            Check('XXXXXXXXXXXXXXXXXXX', '!=', 'SUSPENDED'),
        'dddddddddddddddddddddddddddddd':
            Check('WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW', '=', False),
        'eeeeeeeeeeeeeeeeeeeeeeeeeeeee':
            Check('VVVVVVVVVVVVVVVVVVVVVVVVVVVVVV', '=', False),
        'ffffffffffffffffffffffffff':
            Check('UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU', '=', True),
        'ggggggggggggggggg':
            Check('TTTTTTTTTTTTTTTTTTTTTTTTTTTTTT', '=', True),
        'hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh':
            Check('SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS', '=', True),
        'iiiiiiiiiiiiiiiiiiiiiiii':
            Check('RRRRRRRRRRRRRRRRRRRRRRRRRRR', '=', True),
        'jjjjjjjjjjjjjjjjjjjjjjjjjj':
            Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False),
        }
        a          a = {
            'aaaaaaaaaaaaaaaaaaaaaaaa':
                Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True),
            'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb':
                Check('YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY', '=', True),
            'ccccccccccccccc':
                Check('XXXXXXXXXXXXXXXXXXX', '!=', 'SUSPENDED'),
            'dddddddddddddddddddddddddddddd':
                Check('WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW', '=', False),
            'eeeeeeeeeeeeeeeeeeeeeeeeeeeee':
                Check('VVVVVVVVVVVVVVVVVVVVVVVVVVVVVV', '=', False),
            'ffffffffffffffffffffffffff':
                Check('UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU', '=', True),
            'ggggggggggggggggg':
                Check('TTTTTTTTTTTTTTTTTTTTTTTTTTTTTT', '=', True),
            'hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh':
                Check('SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS', '=', True),
            'iiiiiiiiiiiiiiiiiiiiiiii':
                Check('RRRRRRRRRRRRRRRRRRRRRRRRRRR', '=', True),
            'jjjjjjjjjjjjjjjjjjjjjjjjjj':
                Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False),
        }
        r*   r   r   r   r   ŚtestDictionaryValuesOnOwnLinesļ  s    


z3BasicReformatterTest.testDictionaryValuesOnOwnLinesc                 C   sd   t  d”}t  d”}t |”}|  |t |”” t  d”}t  d”}t |”}|  |t |”” d S )Nz²        doc = test_utils.CreateTestDocumentViaController(
            content={ 'a': 'b' },
            branch_key=branch.key,
            collection_key=collection.key)
        z        doc = test_utils.CreateTestDocumentViaController(
            content={'a': 'b'}, branch_key=branch.key, collection_key=collection.key)
        zß        doc = test_utils.CreateTestDocumentViaController(
            content={ 'a': 'b' },
            branch_key=branch.key,
            collection_key=collection.key,
            collection_key2=collection.key2)
        zŻ        doc = test_utils.CreateTestDocumentViaController(
            content={'a': 'b'},
            branch_key=branch.key,
            collection_key=collection.key,
            collection_key2=collection.key2)
        r*   r   r   r   r   ŚtestDictionaryOnOwnLine#	  s    





z,BasicReformatterTest.testDictionaryOnOwnLinec                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na>          _A = {
            'cccccccccc': ('^^1',),
            'rrrrrrrrrrrrrrrrrrrrrrrrr': ('^7913',  # AAAAAAAAAAAAAA.
                                         ),
            'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': ('^6242',  # BBBBBBBBBBBBBBB.
                                                  ),
            'vvvvvvvvvvvvvvvvvvv': ('^27959',  # CCCCCCCCCCCCCCCCCC.
                                    '^19746',  # DDDDDDDDDDDDDDDDDDDDDDD.
                                    '^22907',  # EEEEEEEEEEEEEEEEEEEEEEEE.
                                    '^21098',  # FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.
                                    '^22826',  # GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG.
                                    '^22769',  # HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH.
                                    '^22935',  # IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII.
                                    '^3982',  # JJJJJJJJJJJJJ.
                                   ),
            'uuuuuuuuuuuu': ('^19745',  # LLLLLLLLLLLLLLLLLLLLLLLLLL.
                             '^21324',  # MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM.
                             '^22831',  # NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN.
                             '^17081',  # OOOOOOOOOOOOOOOOOOOOO.
                            ),
            'eeeeeeeeeeeeee': (
                '^9416',  # Reporter email. Not necessarily the reporter.
                '^^3',  # This appears to be the raw email field.
            ),
            'cccccccccc': ('^21109',  # PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP.
                          ),
        }
        ah          _A = {
            'cccccccccc': ('^^1',),
            'rrrrrrrrrrrrrrrrrrrrrrrrr': (
                '^7913',  # AAAAAAAAAAAAAA.
            ),
            'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': (
                '^6242',  # BBBBBBBBBBBBBBB.
            ),
            'vvvvvvvvvvvvvvvvvvv': (
                '^27959',  # CCCCCCCCCCCCCCCCCC.
                '^19746',  # DDDDDDDDDDDDDDDDDDDDDDD.
                '^22907',  # EEEEEEEEEEEEEEEEEEEEEEEE.
                '^21098',  # FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.
                '^22826',  # GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG.
                '^22769',  # HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH.
                '^22935',  # IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII.
                '^3982',  # JJJJJJJJJJJJJ.
            ),
            'uuuuuuuuuuuu': (
                '^19745',  # LLLLLLLLLLLLLLLLLLLLLLLLLL.
                '^21324',  # MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM.
                '^22831',  # NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN.
                '^17081',  # OOOOOOOOOOOOOOOOOOOOO.
            ),
            'eeeeeeeeeeeeee': (
                '^9416',  # Reporter email. Not necessarily the reporter.
                '^^3',  # This appears to be the raw email field.
            ),
            'cccccccccc': (
                '^21109',  # PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP.
            ),
        }
        r*   r   r   r   r   ŚtestNestedListsInDictionaryB	  s    

"
z0BasicReformatterTest.testNestedListsInDictionaryc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NaO          class _():
          def _():
            breadcrumbs = [{'name': 'Admin',
                            'url': url_for(".home")},
                           {'title': title},]
            breadcrumbs = [{'name': 'Admin',
                            'url': url_for(".home")},
                           {'title': title}]
        ao          class _():
          def _():
            breadcrumbs = [
                {
                    'name': 'Admin',
                    'url': url_for(".home")
                },
                {
                    'title': title
                },
            ]
            breadcrumbs = [{'name': 'Admin', 'url': url_for(".home")}, {'title': title}]
        r*   r   r   r   r   ŚtestNestedDictionary	  s    



z)BasicReformatterTest.testNestedDictionaryc                 C   s*   t  d”}t |”}|  |t |”” d S )Naę          class _():

          @mock.patch.dict(
              os.environ,
              {'HTTP_' + xsrf._XSRF_TOKEN_HEADER.replace('-', '_'): 'atoken'})
          def _():
            pass


        AAAAAAAAAAAAAAAAAAAAAAAA = {
            Environment.XXXXXXXXXX: 'some text more text even more tex',
            Environment.YYYYYYY: 'some text more text even more text yet ag',
            Environment.ZZZZZZZZZZZ: 'some text more text even more text yet again tex',
        }
        r*   r3   r   r   r   ŚtestDictionaryElementsOnOneLine”	  s    

z4BasicReformatterTest.testDictionaryElementsOnOneLinec                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nzi        list("a long line to break the line. a long line to break the brk a long lin", not True)
        zv        list("a long line to break the line. a long line to break the brk a long lin",
             not True)
        r*   ©r   r    rt   r"   r   r   r   ŚtestNotInParamsµ	  s    


z$BasicReformatterTest.testNotInParamsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzÉ        def _():
          if True:
            with py3compat.open_with_encoding(filename, mode='w',
                                              encoding=encoding) as fd:
              pass
        z¬        def _():
          if True:
            with py3compat.open_with_encoding(
                filename, mode='w', encoding=encoding) as fd:
              pass
        r*   r¦   r   r   r   ŚtestNamedAssignNotAtEndOfLineĄ	  s    


z2BasicReformatterTest.testNamedAssignNotAtEndOfLinec              
   C   s   t  d”}t  d”}t |”}|  |t |”” t  d”}t  d”}z>t t 	d”” t |”}|  |t |”” W t t 
” ” nt t 
” ” 0 d S )Nz        class A:

          """Does something.

          Also, here are some details.
          """

          def __init__(self):
            pass
        z        class A:
          """Does something.

          Also, here are some details.
          """

          def __init__(self):
            pass
        z?{based_on_style: yapf, blank_line_before_class_docstring: True}r,   ©r   r    rt   r"   r!   r   r   r   Ś!testBlankLineBeforeClassDocstringŅ	  s"    





’’
’z6BasicReformatterTest.testBlankLineBeforeClassDocstringc              
   C   s   t  d”}t  d”}t |”}|  |t |”” t  d”}t  d”}z>t t 	d”” t |”}|  |t |”” W t t 
” ” nt t 
” ” 0 d S )Nz        #!/usr/bin/env python
        # -*- coding: utf-8 name> -*-

        """Some module docstring."""


        def foobar():
          pass
        z        #!/usr/bin/env python
        # -*- coding: utf-8 name> -*-
        """Some module docstring."""


        def foobar():
          pass
        z        #!/usr/bin/env python
        # -*- coding: utf-8 name> -*-
        """Some module docstring."""


        def foobar():
            pass
        z        #!/usr/bin/env python
        # -*- coding: utf-8 name> -*-

        """Some module docstring."""


        def foobar():
            pass
        z@{based_on_style: pep8, blank_line_before_module_docstring: True}r,   r©   r   r   r   Ś"testBlankLineBeforeModuleDocstring
  s"    


	

	
’’
’z7BasicReformatterTest.testBlankLineBeforeModuleDocstringc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz£        def f():
          this_is_a_very_long_function_name(an_extremely_long_variable_name, (
              'a string that may be too long %s' % 'M15'))
        z±        def f():
          this_is_a_very_long_function_name(
              an_extremely_long_variable_name,
              ('a string that may be too long %s' % 'M15'))
        r*   r¦   r   r   r   ŚtestTupleCohesionE
  s    


z&BasicReformatterTest.testTupleCohesionc                 C   s*   t  d”}t |”}|  |t |”” d S )Nz        foo = d[not a]
        r*   r3   r   r   r   ŚtestSubscriptExpressionT
  s    

z,BasicReformatterTest.testSubscriptExpressionc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz        A[B, C,]
        z7        A[
            B,
            C,
        ]
    r*   r¦   r   r   r   Ś(testSubscriptExpressionTerminatedByComma[
  s    


z=BasicReformatterTest.testSubscriptExpressionTerminatedByCommac                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na]          def foo():
          return [
              Bar(
                  xxx='some string',
                  yyy='another long string',
                  zzz='a third long string'), Bar(
                      xxx='some string',
                      yyy='another long string',
                      zzz='a third long string')
          ]
        a9          def foo():
          return [
              Bar(xxx='some string',
                  yyy='another long string',
                  zzz='a third long string'),
              Bar(xxx='some string',
                  yyy='another long string',
                  zzz='a third long string')
          ]
        r*   r¦   r   r   r   ŚtestListWithFunctionCallsh
  s    


z.BasicReformatterTest.testListWithFunctionCallsc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz2        X=...
        Y = X if ... else X
        z4        X = ...
        Y = X if ... else X
        r*   r¦   r   r   r   ŚtestEllipses
  s    


z!BasicReformatterTest.testEllipsesc                 C   s(   d}d}t  |”}|  |t |”” d S )NzTmy_dict = {
    'key':  # Some comment about the key
        {'nested_key': 1, },
}
zimy_dict = {
    'key':  # Some comment about the key
        {
            'nested_key': 1,
        },
}
rE   r¦   r   r   r   ŚtestPseudoParens
  s    
z%BasicReformatterTest.testPseudoParensc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 dS )z5Tests split_before_first_argument on a function call.zo        a_very_long_function_name("long string with formatting {0:s}".format(
            "mystring"))
        zo        a_very_long_function_name(
            "long string with formatting {0:s}".format("mystring"))
        ś9{based_on_style: yapf, split_before_first_argument: True}Nr/   r   r   r   r   Ś.testSplittingBeforeFirstArgumentOnFunctionCall”
  s    

’’
’zCBasicReformatterTest.testSplittingBeforeFirstArgumentOnFunctionCallc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 dS )z;Tests split_before_first_argument on a function definition.z«        def _GetNumberOfSecondsFromElements(year, month, day, hours,
                                            minutes, seconds, microseconds):
          return
        z        def _GetNumberOfSecondsFromElements(
            year, month, day, hours, minutes, seconds, microseconds):
          return
        r²   Nr/   r   r   r   r   Ś4testSplittingBeforeFirstArgumentOnFunctionDefinition·
  s    

’’
’zIBasicReformatterTest.testSplittingBeforeFirstArgumentOnFunctionDefinitionc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 dS )z:Tests split_before_first_argument on a compound statement.zŗ        if (long_argument_name_1 == 1 or
            long_argument_name_2 == 2 or
            long_argument_name_3 == 3 or
            long_argument_name_4 == 4):
          pass
        z¢        if (long_argument_name_1 == 1 or long_argument_name_2 == 2 or
            long_argument_name_3 == 3 or long_argument_name_4 == 4):
          pass
        r²   Nr/   r   r   r   r   Ś3testSplittingBeforeFirstArgumentOnCompoundStatementĻ
  s    

’’
’zHBasicReformatterTest.testSplittingBeforeFirstArgumentOnCompoundStatementc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 dS )z(Tests coalesce_brackets on a dictionary.a$          date_time_values = (
            {
                u'year': year,
                u'month': month,
                u'day_of_month': day_of_month,
                u'hours': hours,
                u'minutes': minutes,
                u'seconds': seconds
            }
        )
        zņ        date_time_values = ({
            u'year': year,
            u'month': month,
            u'day_of_month': day_of_month,
            u'hours': hours,
            u'minutes': minutes,
            u'seconds': seconds
        })
        z/{based_on_style: yapf, coalesce_brackets: True}Nr/   r   r   r   r   ŚtestCoalesceBracketsOnDicté
  s    

’’
’z/BasicReformatterTest.testCoalesceBracketsOnDictc              
   C   s^   t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )NzÜ        if __name__ == "__main__":
          with another_resource:
            account = {
                "validUntil":
                    int(time() + (6 * 7 * 24 * 60 * 60))  # in 6 weeks time
            }
        zN{based_on_style: yapf, coalesce_brackets: True, dedent_closing_brackets: true}r/   r3   r   r   r   ŚtestSplitAfterComment  s    
	’’
z*BasicReformatterTest.testSplitAfterCommentc              
   C   s^   t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )Nz+        x = [1, 2, 3, 4, 5, 6, 7,]
        z<{based_on_style: yapf, disable_ending_comma_heuristic: True}r/   r3   r   r   r   ŚtestDisableEndingCommaHeuristic!  s    
’
z4BasicReformatterTest.testDisableEndingCommaHeuristicc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )Nść        def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None:
          pass


        def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None:
          pass
        a          def function(
            first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None
        ) -> None:
          pass


        def function(
            first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None
        ) -> None:
          pass
        z5{based_on_style: yapf, dedent_closing_brackets: True}r/   r   r   r   r   Ś>testDedentClosingBracketsWithTypeAnnotationExceedingLineLength0  s    

’
’zSBasicReformatterTest.testDedentClosingBracketsWithTypeAnnotationExceedingLineLengthc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )Nr¹   a          def function(
            first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None
            ) -> None:
          pass


        def function(
            first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None
            ) -> None:
          pass
        ś5{based_on_style: yapf, indent_closing_brackets: True}r/   r   r   r   r   Ś>testIndentClosingBracketsWithTypeAnnotationExceedingLineLengthQ  s    

’
’zSBasicReformatterTest.testIndentClosingBracketsWithTypeAnnotationExceedingLineLengthc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )Nzū        def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, third_and_final_argument=True):
          pass


        def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None):
          pass
        aG          def function(
            first_argument_xxxxxxxxxxxxxxxx=(0,),
            second_argument=None,
            third_and_final_argument=True
            ):
          pass


        def function(
            first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None
            ):
          pass
        r»   r/   r   r   r   r   Ś'testIndentClosingBracketsInFunctionCallr  s    

’
’z<BasicReformatterTest.testIndentClosingBracketsInFunctionCallc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )Na          def function():
          some_var = ('a long element', 'another long element', 'short element', 'really really long element')
          return True

        def function():
          some_var = ('a couple', 'small', 'elemens')
          return False
        a8          def function():
          some_var = (
              'a long element', 'another long element', 'short element',
              'really really long element'
              )
          return True


        def function():
          some_var = ('a couple', 'small', 'elemens')
          return False
        r»   r/   r   r   r   r   Ś testIndentClosingBracketsInTuple  s    
	
’
’z5BasicReformatterTest.testIndentClosingBracketsInTuplec              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )Na          def function():
          some_var = ['a long element', 'another long element', 'short element', 'really really long element']
          return True

        def function():
          some_var = ['a couple', 'small', 'elemens']
          return False
        a8          def function():
          some_var = [
              'a long element', 'another long element', 'short element',
              'really really long element'
              ]
          return True


        def function():
          some_var = ['a couple', 'small', 'elemens']
          return False
        r»   r/   r   r   r   r   ŚtestIndentClosingBracketsInListø  s    
	
’
’z4BasicReformatterTest.testIndentClosingBracketsInListc              
   C   sh   t  d”}t  d”}z>t t d”” t |”}|  |t 	|”” W t t 
” ” nt t 
” ” 0 d S )Naq          def function():
          some_var = {1: ('a long element', 'and another really really long element that is really really amazingly long'), 2: 'another long element', 3: 'short element', 4: 'really really long element'}
          return True

        def function():
          some_var = {1: 'a couple', 2: 'small', 3: 'elemens'}
          return False
        a          def function():
          some_var = {
              1:
                  (
                      'a long element',
                      'and another really really long element that is really really amazingly long'
                      ),
              2: 'another long element',
              3: 'short element',
              4: 'really really long element'
              }
          return True


        def function():
          some_var = {1: 'a couple', 2: 'small', 3: 'elemens'}
          return False
        r»   r/   r   r   r   r   ŚtestIndentClosingBracketsInDictŪ  s    
	
’
’z4BasicReformatterTest.testIndentClosingBracketsInDictc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Na,          class A:
            def b():
                d = {
                    "123456": [
                        {
                            "12": "aa"
                        },
                        {
                            "12": "bb"
                        },
                        {
                            "12": "cc",
                            "1234567890": {
                                "1234567": [{
                                    "12": "dd",
                                    "12345": "text 1"
                                }, {
                                    "12": "ee",
                                    "12345": "text 2"
                                }]
                            }
                        }
                    ]
                }
        aI          class A:

          def b():
            d = {
                "123456": [{
                    "12": "aa"
                }, {
                    "12": "bb"
                }, {
                    "12": "cc",
                    "1234567890": {
                        "1234567": [{
                            "12": "dd",
                            "12345": "text 1"
                        }, {
                            "12": "ee",
                            "12345": "text 2"
                        }]
                    }
                }]
            }
        r*   r   r   r   r   ŚtestMultipleDictionariesInList  s    


z3BasicReformatterTest.testMultipleDictionariesInListc              
   C   sl   zVt  t  d”” t d”}t |”}t |”}t d”}|  	||” W t  t  
” ” nt  t  
” ” 0 d S )Nz{force_multiline_dict: true}śm        responseDict = {'childDict': {'spam': 'eggs'}}
        generatedDict = {x: x for x in 'value'}
      z·        responseDict = {
            'childDict': {
                'spam': 'eggs'
            }
        }
        generatedDict = {
            x: x for x in 'value'
        }
      )r   r
   r   r   r   r   r   r   r   r   r   )r   r    r"   ŚactualŚexpectedr   r   r   ŚtestForceMultilineDict_True9  s    ’




z0BasicReformatterTest.testForceMultilineDict_Truec              
   C   sb   zLt  t  d”” t d”}|}t |”}|  |t 	|”” W t  t  
” ” nt  t  
” ” 0 d S )Nz{force_multiline_dict: false}rĀ   )r   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   ŚtestForceMultilineDict_FalseQ  s    ’

’z1BasicReformatterTest.testForceMultilineDict_FalsezRequires Python 3.8c                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzN      if (x  :=  len([1]*1000)>100):
        print(f'{x} is pretty big' )
    zO      if (x := len([1] * 1000) > 100):
        print(f'{x} is pretty big')
    r*   ©r   r    rÄ   r"   r   r   r   Ś
testWalrus`  s    


zBasicReformatterTest.testWalruszRequires Python 3.10c                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )Nz»        match command.split():
          case[action   ]:
            ...  # interpret single-verb action
          case[action,    obj]:
            ...  # interpret action, obj
        z·        match command.split():
          case [action]:
            ...  # interpret single-verb action
          case [action, obj]:
            ...  # interpret action, obj
        r*   rĒ   r   r   r   ŚtestStructuredPatternMatchingm  s    


z2BasicReformatterTest.testStructuredPatternMatchingc                 C   s4   t  d”}t  d”}t |”}|  |t |”” d S )NzŻ        with (cert_authority.cert_pem.tempfile() as ca_temp_path, patch.object(os, 'environ', os.environ | {'REQUESTS_CA_BUNDLE': ca_temp_path}),):
            httpserver_url = httpserver.url_for('/resource.jar')
        a          with (
            cert_authority.cert_pem.tempfile() as ca_temp_path,
            patch.object(os, 'environ',
                         os.environ | {'REQUESTS_CA_BUNDLE': ca_temp_path}),
        ):
          httpserver_url = httpserver.url_for('/resource.jar')
        r*   rĒ   r   r   r   Ś testParenthesizedContextManagers  s    


z5BasicReformatterTest.testParenthesizedContextManagersN)Ś__name__Ś
__module__Ś__qualname__Śclassmethodr   r#   r)   r+   r-   r.   r0   r1   r2   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   rl   rm   rn   ro   rq   rr   rs   ru   rv   rx   ry   rz   r{   r|   r}   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r”   r¢   r£   r¤   r„   r§   rØ   rŖ   r«   r¬   r­   r®   rÆ   r°   r±   r³   r“   rµ   r¶   r·   rø   rŗ   r¼   r½   r¾   ræ   rĄ   rĮ   rÅ   rĘ   ŚunittestZ
skipUnlessŚPY38rČ   ŚPY310rÉ   rŹ   r   r   r   r   r	      s$  
MvY'(5
	&#5

$ "
		

	
#! 
!9	4C<7
$!!###)5r	   Ś__main__)Ś__doc__Śsysr   rĻ   Zyapf.yapflibr   r   Z	yapftestsr   Śversion_inforŠ   rŃ   ZYAPFTestr	   rĖ   Śmainr   r   r   r   Ś<module>   sH                            