Attachment 1978864 Details for Bug 2226154 – build.log

build.log

build.log (text/plain), 32.00 KB, created by Fedora Release Engineering on 2023-07-25 19:10:06 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Fedora Release Engineering

Created: 2023-07-25 19:10:06 UTC

Size: 32.00 KB

patch

obsolete

>__________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_multiple_statements>
>    def test_w602_multiple_statements(self):
>        line = 'raise ValueError, "hello";print 1\n'
>        fixed = 'raise ValueError("hello")\nprint 1\n'
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: 'raise ValueError("hello")\nprint 1\n' != 'raise ValueError, "hello"\nprint 1\n'
>E           - raise ValueError("hello")
>E           ?                 ^       -
>E           + raise ValueError, "hello"
>E           ?                 ^^
>E             print 1
>test/test_autopep8.py:4982: AssertionError
>_______________ SystemTests.test_w602_raise_argument_triple_fake _______________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_raise_argument_triple_fake>
>    def test_w602_raise_argument_triple_fake(self):
>        line = 'raise ValueError, "info, info2"\n'
>        fixed = 'raise ValueError("info, info2")\n'
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: 'raise ValueError("info, info2")\n' != 'raise ValueError, "info, info2"\n'
>E           - raise ValueError("info, info2")
>E           ?                 ^             -
>E           + raise ValueError, "info, info2"
>E           ?                 ^^
>test/test_autopep8.py:5004: AssertionError
>____________ SystemTests.test_w602_raise_argument_with_indentation _____________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_raise_argument_with_indentation>
>    def test_w602_raise_argument_with_indentation(self):
>        line = 'if True:\n    raise ValueError, "error"\n'
>        fixed = 'if True:\n    raise ValueError("error")\n'
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: 'if True:\n    raise ValueError("error")\n' != 'if True:\n    raise ValueError, "error"\n'
>E             if True:
>E           -     raise ValueError("error")
>E           ?                     ^       -
>E           +     raise ValueError, "error"
>E           ?                     ^^
>test/test_autopep8.py:4988: AssertionError
>_____________________ SystemTests.test_w602_triple_quotes ______________________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_triple_quotes>
>    def test_w602_triple_quotes(self):
>        line = 'raise ValueError, """hello"""\n1\n'
>        fixed = 'raise ValueError("""hello""")\n1\n'
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: 'raise ValueError("""hello""")\n1\n' != 'raise ValueError, """hello"""\n1\n'
>E           - raise ValueError("""hello""")
>E           ?                 ^           -
>E           + raise ValueError, """hello"""
>E           ?                 ^^
>E             1
>test/test_autopep8.py:4899: AssertionError
>_________________ SystemTests.test_w602_with_complex_multiline _________________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_with_complex_multiline>
>    def test_w602_with_complex_multiline(self):
>        line = 'raise ValueError, """\nhello %s %s""" % (\n    1, 2)\n'
>        fixed = 'raise ValueError("""\nhello %s %s""" % (\n    1, 2))\n'
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: 'raise ValueError("""\nhello %s %s""" % (\n    1, 2))\n' != 'raise ValueError, """\nhello %s %s""" % (\n    1, 2)\n'
>E           - raise ValueError("""
>E           ?                 ^
>E           + raise ValueError, """
>E           ?                 ^^
>E             hello %s %s""" % (
>E           -     1, 2))
>E           ?          -
>E           +     1, 2)
>test/test_autopep8.py:4911: AssertionError
>________________ SystemTests.test_w602_with_list_comprehension _________________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_with_list_comprehension>
>    def test_w602_with_list_comprehension(self):
>        line = 'raise Error, [x[0] for x in probs]\n'
>        fixed = 'raise Error([x[0] for x in probs])\n'
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: 'raise Error([x[0] for x in probs])\n' != 'raise Error, [x[0] for x in probs]\n'
>E           - raise Error([x[0] for x in probs])
>E           ?            ^                     -
>E           + raise Error, [x[0] for x in probs]
>E           ?            ^^
>test/test_autopep8.py:5010: AssertionError
>_______________________ SystemTests.test_w602_with_logic _______________________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_with_logic>
>    def test_w602_with_logic(self):
>        line = "raise TypeError, e or 'hello'\n"
>        fixed = "raise TypeError(e or 'hello')\n"
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: "raise TypeError(e or 'hello')\n" != "raise TypeError, e or 'hello'\n"
>E           - raise TypeError(e or 'hello')
>E           ?                ^            -
>E           + raise TypeError, e or 'hello'
>E           ?                ^^
>test/test_autopep8.py:4893: AssertionError
>___________ SystemTests.test_w602_with_multiline_with_single_quotes ____________
>self = <test.test_autopep8.SystemTests testMethod=test_w602_with_multiline_with_single_quotes>
>    def test_w602_with_multiline_with_single_quotes(self):
>        line = "raise ValueError, '''\nhello'''\n"
>        fixed = "raise ValueError('''\nhello''')\n"
>        with autopep8_context(line, options=['--aggressive']) as result:
>>           self.assertEqual(fixed, result)
>E           AssertionError: "raise ValueError('''\nhello''')\n" != "raise ValueError, '''\nhello'''\n"
>E           - raise ValueError('''
>E           ?                 ^
>E           + raise ValueError, '''
>E           ?                 ^^
>E           - hello''')
>E           ?         -
>E           + hello'''
>test/test_autopep8.py:4947: AssertionError
>________________________ CommandLineTests.test_verbose _________________________
>self = <test.test_autopep8.CommandLineTests testMethod=test_verbose>
>    def test_verbose(self):
>        line = 'bad_syntax)'
>        with temporary_file_context(line) as filename:
>            p = Popen(list(AUTOPEP8_CMD_TUPLE) + [filename, '-vvv'],
>                      stdout=PIPE, stderr=PIPE)
>            verbose_error = p.communicate()[1].decode('utf-8')
>>       self.assertIn("'fix_e901' is not defined", verbose_error)
>E       AssertionError: "'fix_e901' is not defined" not found in "[file:/tmp/ic2px5vq]\n/builddir/build/BUILD/autopep8-1.6.0/autopep8.py:198: DeprecationWarning: lib2to3 package is deprecated and may not be able to parse Python 3.10+\n  from lib2to3.pgen2 import tokenize as lib2to3_tokenize\n--->  Applying global fix for E265\n--->  2 issue(s) to fix {'W292': {1}}\n--->  0 issue(s) to fix {}\n"
>test/test_autopep8.py:5688: AssertionError
>_____________ ExperimentalSystemTests.test_e501_experimental_dict ______________
>self = <test.test_autopep8.ExperimentalSystemTests testMethod=test_e501_experimental_dict>
>        def test_e501_experimental_dict(self):
>            line = """\
>    def f():
>        zzzzzzzzzzzzz = {
>            'aaaaaa/bbbbbb/ccccc/dddddddd/eeeeeeeee/fffffffffff/ggggggggg/hhhhhhhh.py':
>                yyyyyyyyyyy.xxxxxxxxxxx(
>                    'aa/bbbbbbb/cc/ddddddd/eeeeeeeeeee/fffffffffff/ggggggggg/hhhhhhh/ggggg.py',
>                    '00000000',
>                    yyyyyyyyyyy.xxxxxxxxx.zzzz),
>        }
>    """
>            fixed = """\
>    def f():
>        zzzzzzzzzzzzz = {
>            'aaaaaa/bbbbbb/ccccc/dddddddd/eeeeeeeee/fffffffffff/ggggggggg/hhhhhhhh.py':
>            yyyyyyyyyyy.xxxxxxxxxxx(
>                'aa/bbbbbbb/cc/ddddddd/eeeeeeeeeee/fffffffffff/ggggggggg/hhhhhhh/ggggg.py',
>                '00000000', yyyyyyyyyyy.xxxxxxxxx.zzzz), }
>    """
>    
>            with autopep8_context(line, options=['--experimental']) as result:
>>               self.assertEqual(fixed, result)
>E               AssertionError: "def [231 chars]py',\n            '00000000', yyyyyyyyyyy.xxxxxxxxx.zzzz), }\n" != "def [231 chars]py',\n            '00000000', yyyyyyyyyyy.xxxxxxxxx.zzzz),}\n"
>E                 def f():
>E                     zzzzzzzzzzzzz = {
>E                         'aaaaaa/bbbbbb/ccccc/dddddddd/eeeeeeeee/fffffffffff/ggggggggg/hhhhhhhh.py':
>E                         yyyyyyyyyyy.xxxxxxxxxxx(
>E                             'aa/bbbbbbb/cc/ddddddd/eeeeeeeeeee/fffffffffff/ggggggggg/hhhhhhh/ggggg.py',
>E               -             '00000000', yyyyyyyyyyy.xxxxxxxxx.zzzz), }
>E               ?                                                     -
>E               +             '00000000', yyyyyyyyyyy.xxxxxxxxx.zzzz),}
>test/test_autopep8.py:7290: AssertionError
>_ ExperimentalSystemTests.test_e501_experimental_oversized_default_initializer _
>self = <test.test_autopep8.ExperimentalSystemTests testMethod=test_e501_experimental_oversized_default_initializer>
>        def test_e501_experimental_oversized_default_initializer(self):
>            line = """\
>    aaaaaaaaaaaaaaaaaaaaa(lllll,mmmmmmmm,nnn,fffffffffff,ggggggggggg,hhh,ddddddddddddd=eeeeeeeee,bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=ccccccccccccccccccccccccccccccccccccccccccccccccc,bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=cccccccccccccccccccccccccccccccccccccccccccccccc)
>    """
>            fixed = """\
>    aaaaaaaaaaaaaaaaaaaaa(
>        lllll, mmmmmmmm, nnn, fffffffffff, ggggggggggg, hhh,
>        ddddddddddddd=eeeeeeeee,
>        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=ccccccccccccccccccccccccccccccccccccccccccccccccc,
>        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=cccccccccccccccccccccccccccccccccccccccccccccccc)
>    """
>            with autopep8_context(line, options=['--experimental']) as result:
>>               self.assertEqual(fixed, result)
>E               AssertionError: 'aaaa[13 chars]aaaa(\n    lllll, mmmmmmmm, nnn, fffffffffff, [253 chars]c)\n' != 'aaaa[13 chars]aaaa(lllll,m mmmmmmm,n nn,f ffffffffff,g ggggg[232 chars]c)\n'
>E               + aaaaaaaaaaaaaaaaaaaaa(lllll,m mmmmmmm,n nn,f ffffffffff,g gggggggggg,h hh,d dddddddddddd=eeeeeeeee,b bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=ccccccccccccccccccccccccccccccccccccccccccccccccc,b bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=cccccccccccccccccccccccccccccccccccccccccccccccc)
>E               - aaaaaaaaaaaaaaaaaaaaa(
>E               -     lllll, mmmmmmmm, nnn, fffffffffff, ggggggggggg, hhh,
>E               -     ddddddddddddd=eeeeeeeee,
>E               -     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=ccccccccccccccccccccccccccccccccccccccccccccccccc,
>E               -     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=cccccccccccccccccccccccccccccccccccccccccccccccc)
>test/test_autopep8.py:7119: AssertionError
>__ ExperimentalSystemTests.test_e501_experimental_parsing_dict_with_comments ___
>self = <autopep8.FixPEP8 object at 0xffffac470650>
>result = {'column': 80, 'id': 'E501', 'info': 'E501 line too long (82 > 79 characters)', 'line': 6}
>logical = ((0, 0), (5, 82), ["self.display['xxxxxxxxxxxx'] = [{'title': _('Library'),  # . This is the first comment.\n", "     ...This is the third comment.\n", "                                         'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]\n"])
>    def fix_long_line_logically(self, result, logical):
>        """Try to make lines fit within --max-line-length characters."""
>        if (
>            not logical or
>            len(logical[2]) == 1 or
>            self.source[result['line'] - 1].lstrip().startswith('#')
>        ):
>            return self.fix_long_line_physically(result)
>    
>        start_line_index = logical[0][0]
>        end_line_index = logical[1][0]
>        logical_lines = logical[2]
>    
>        previous_line = get_item(self.source, start_line_index - 1, default='')
>        next_line = get_item(self.source, end_line_index + 1, default='')
>    
>        single_line = join_logical_line(''.join(logical_lines))
>    
>        try:
>>           fixed = self.fix_long_line(
>                target=single_line,
>                previous_line=previous_line,
>                next_line=next_line,
>                original=''.join(logical_lines))
>autopep8.py:973: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = <autopep8.FixPEP8 object at 0xffffac470650>
>target = "self.display['xxxxxxxxxxxx'] = [{'title': _('Library'), # . This is the first comment. 'flag': aaaaaaaaaa.bbbbbbbbb.c...bbbbb.dddddddddd }, {'title': _('Unknown'), # . This is the third comment. 'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]\n"
>previous_line = '', next_line = ''
>original = "self.display['xxxxxxxxxxxx'] = [{'title': _('Library'),  # . This is the first comment.\n                            ...  # . This is the third comment.\n                                         'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]\n"
>    def fix_long_line(self, target, previous_line,
>                      next_line, original):
>        cache_entry = (target, previous_line, next_line)
>        if cache_entry in self.long_line_ignore_cache:
>            return []
>    
>        if target.lstrip().startswith('#'):
>            if self.options.aggressive:
>                # Wrap commented lines.
>                return shorten_comment(
>                    line=target,
>                    max_line_length=self.options.max_line_length,
>                    last_comment=not next_line.lstrip().startswith('#'))
>            return []
>    
>>       fixed = get_fixed_long_line(
>            target=target,
>            previous_line=previous_line,
>            original=original,
>            indent_word=self.indent_word,
>            max_line_length=self.options.max_line_length,
>            aggressive=self.options.aggressive,
>            experimental=self.options.experimental,
>            verbose=self.options.verbose)
>autopep8.py:1027: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>target = "self.display['xxxxxxxxxxxx'] = [{'title': _('Library'), # . This is the first comment. 'flag': aaaaaaaaaa.bbbbbbbbb.c...bbbbb.dddddddddd }, {'title': _('Unknown'), # . This is the third comment. 'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]\n"
>previous_line = ''
>original = "self.display['xxxxxxxxxxxx'] = [{'title': _('Library'),  # . This is the first comment.\n                            ...  # . This is the third comment.\n                                         'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]\n"
>indent_word = '    ', max_line_length = 79, aggressive = 0, experimental = True
>verbose = 0
>    def get_fixed_long_line(target, previous_line, original,
>                            indent_word='    ', max_line_length=79,
>                            aggressive=False, experimental=False, verbose=False):
>        """Break up long line and return result.
>    
>        Do this by generating multiple reformatted candidates and then
>        ranking the candidates to heuristically select the best option.
>    
>        """
>        indent = _get_indentation(target)
>        source = target[len(indent):]
>        assert source.lstrip() == source
>        assert not target.lstrip().startswith('#')
>    
>        # Check for partial multiline.
>>       tokens = list(generate_tokens(source))
>autopep8.py:1532: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = <autopep8.CachedTokenizer object at 0xffffac8a1820>
>text = "self.display['xxxxxxxxxxxx'] = [{'title': _('Library'), # . This is the first comment. 'flag': aaaaaaaaaa.bbbbbbbbb.c...bbbbb.dddddddddd }, {'title': _('Unknown'), # . This is the third comment. 'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]\n"
>    def generate_tokens(self, text):
>        """A stand-in for tokenize.generate_tokens()."""
>        if text != self.last_text:
>            string_io = io.StringIO(text)
>>           self.last_tokens = list(
>                tokenize.generate_tokens(string_io.readline)
>            )
>autopep8.py:4563: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>source = <built-in method readline of _io.StringIO object at 0xffffac15e500>
>encoding = None, extra_tokens = True
>    def _generate_tokens_from_c_tokenizer(source, encoding=None, extra_tokens=False):
>        """Tokenize a source reading Python code as unicode strings using the internal C tokenizer"""
>        if encoding is None:
>            it = _tokenize.TokenizerIter(source, extra_tokens=extra_tokens)
>        else:
>            it = _tokenize.TokenizerIter(source, encoding=encoding, extra_tokens=extra_tokens)
>        try:
>            for info in it:
>                yield TokenInfo._make(info)
>        except SyntaxError as e:
>            if type(e) != SyntaxError:
>                raise e from None
>            msg = _transform_msg(e.msg)
>>           raise TokenError(msg, (e.lineno, e.offset)) from None
>E           tokenize.TokenError: ('unexpected EOF in multi-line statement', (1, 0))
>/usr/lib64/python3.12/tokenize.py:543: TokenError
>During handling of the above exception, another exception occurred:
>self = <test.test_autopep8.ExperimentalSystemTests testMethod=test_e501_experimental_parsing_dict_with_comments>
>        def test_e501_experimental_parsing_dict_with_comments(self):
>            line = """\
>    self.display['xxxxxxxxxxxx'] = [{'title': _('Library'),  #. This is the first comment.
>        'flag': aaaaaaaaaa.bbbbbbbbb.cccccccccc
>        }, {'title': _('Original'),  #. This is the second comment.
>        'flag': aaaaaaaaaa.bbbbbbbbb.dddddddddd
>        }, {'title': _('Unknown'),  #. This is the third comment.
>        'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]
>    """
>            fixed = """\
>    self.display['xxxxxxxxxxxx'] = [{'title': _('Library'),  # . This is the first comment.
>                                     'flag': aaaaaaaaaa.bbbbbbbbb.cccccccccc
>                                     # . This is the second comment.
>                                     }, {'title': _('Original'),
>                                         'flag': aaaaaaaaaa.bbbbbbbbb.dddddddddd
>                                         # . This is the third comment.
>                                         }, {'title': _('Unknown'),
>                                             'flag': aaaaaaaaaa.bbbbbbbbb.eeeeeeeeee}]
>    """
>    
>>           with autopep8_context(line, options=['--experimental']) as result:
>test/test_autopep8.py:7414: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>/usr/lib64/python3.12/contextlib.py:137: in __enter__
>    return next(self.gen)
>test/test_autopep8.py:7514: in autopep8_context
>    yield autopep8.fix_file(filename=filename, options=options)
>autopep8.py:3619: in fix_file
>    fixed_source = fix_lines(fixed_source, options, filename=filename)
>autopep8.py:3599: in fix_lines
>    fixed_source = fix.fix()
>autopep8.py:628: in fix
>    self._fix_source(filter_results(source=''.join(self.source),
>autopep8.py:570: in _fix_source
>    modified_lines = fix(result, logical)
>autopep8.py:979: in fix_long_line_logically
>    return self.fix_long_line_physically(result)
>autopep8.py:998: in fix_long_line_physically
>    fixed = self.fix_long_line(
>autopep8.py:1027: in fix_long_line
>    fixed = get_fixed_long_line(
>autopep8.py:1544: in get_fixed_long_line
>    sorted(set(candidates).union([target, original])),
>autopep8.py:1937: in shorten_line
>    for shortened in _shorten_line_at_tokens_new(
>autopep8.py:2818: in _shorten_line_at_tokens_new
>    fixed = _reflow_lines(parsed_tokens, indentation, max_line_length,
>autopep8.py:2795: in _reflow_lines
>    item.reflow(lines, continued_indent, break_after_open_bracket)
>autopep8.py:2420: in reflow
>    reflowed_lines.add(self, len(continued_indent),
>autopep8.py:2088: in add
>    self._add_item(obj, indent_amt)
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self =                                          'flag': aaaaaaaaaa.bbbbbbbbb.
>                                             eeeeeeeeee}
>item = }, indent_amt = 45
>    def _add_item(self, item, indent_amt):
>        """Add an item to the line.
>    
>        Reflow the line to get the best formatting after the item is
>        inserted. The bracket depth indicates if the item is being
>        inserted inside of a container or not.
>    
>        """
>        if self._prev_item and self._prev_item.is_string and item.is_string:
>            # Place consecutive string literals on separate lines.
>            self._lines.append(self._LineBreak())
>            self._lines.append(self._Indent(indent_amt))
>    
>        item_text = unicode(item)
>        if self._lines and self._bracket_depth:
>            # Adding the item into a container.
>            self._prevent_default_initializer_splitting(item, indent_amt)
>    
>            if item_text in '.,)]}':
>                self._split_after_delimiter(item, indent_amt)
>    
>        elif self._lines and not self.line_empty():
>            # Adding the item outside of a container.
>            if self.fits_on_current_line(len(item_text)):
>                self._enforce_space(item)
>    
>            else:
>                # Line break for the new item.
>                self._lines.append(self._LineBreak())
>                self._lines.append(self._Indent(indent_amt))
>    
>        self._lines.append(item)
>        self._prev_item, self._prev_prev_item = item, self._prev_item
>    
>        if item_text in '([{':
>            self._bracket_depth += 1
>    
>        elif item_text in '}])':
>            self._bracket_depth -= 1
>>           assert self._bracket_depth >= 0
>E           AssertionError
>autopep8.py:2237: AssertionError
>_____ ExperimentalSystemTests.test_e501_experimental_with_complex_reformat _____
>self = <test.test_autopep8.ExperimentalSystemTests testMethod=test_e501_experimental_with_complex_reformat>
>        def test_e501_experimental_with_complex_reformat(self):
>            line = """\
>    bork(111, 111, 111, 111, 222, 222, 222, { 'foo': 222, 'qux': 222 }, ((['hello', 'world'], ['yo', 'stella', "how's", 'it'], ['going']), {str(i): i for i in range(10)}, {'bork':((x, x**x) for x in range(10))}), 222, 222, 222, 222, 333, 333, 333, 333)
>    """
>            fixed = """\
>    bork(
>        111, 111, 111, 111, 222, 222, 222, {'foo': 222, 'qux': 222},
>        ((['hello', 'world'],
>          ['yo', 'stella', "how's", 'it'],
>          ['going']),
>         {str(i): i for i in range(10)},
>         {'bork': ((x, x ** x) for x in range(10))}),
>        222, 222, 222, 222, 333, 333, 333, 333)
>    """
>    
>            with autopep8_context(line, options=['--experimental']) as result:
>>               self.assertEqual(fixed, result)
>E               AssertionError: 'bork(\n    111, 111, 111, 111, 222, 222, 222, [262 chars]3)\n' != 'bork(111, 111, 111, 111, 222, 222, 222, {\'foo[219 chars]3)\n'
>E               + bork(111, 111, 111, 111, 222, 222, 222, {'foo': 222, 'qux': 222 }, ((['hello', 'world'], ['yo', 'stella', "how's", 'it'], ['going']), {str(i): i for i in range(10)}, {'bork':( (x, x**x) for x in range(10))}), 222, 222, 222, 222, 333, 333, 333, 333)
>E               - bork(
>E               -     111, 111, 111, 111, 222, 222, 222, {'foo': 222, 'qux': 222},
>E               -     ((['hello', 'world'],
>E               -       ['yo', 'stella', "how's", 'it'],
>E               -       ['going']),
>E               -      {str(i): i for i in range(10)},
>E               -      {'bork': ((x, x ** x) for x in range(10))}),
>E               -     222, 222, 222, 222, 333, 333, 333, 333)
>test/test_autopep8.py:7012: AssertionError
>___________ ExperimentalSystemTests.test_e501_experimental_with_def ____________
>self = <test.test_autopep8.ExperimentalSystemTests testMethod=test_e501_experimental_with_def>
>        def test_e501_experimental_with_def(self):
>            line = """\
>    def foobar(sldfkjlsdfsdf, kksdfsdfsf,sdfsdfsdf, sdfsdfkdk, szdfsdfsdf, sdfsdfsdfsdlkfjsdlf, sdfsdfddf,sdfsdfsfd, sdfsdfdsf):
>        pass
>    """
>            fixed = """\
>    def foobar(sldfkjlsdfsdf, kksdfsdfsf, sdfsdfsdf, sdfsdfkdk, szdfsdfsdf,
>               sdfsdfsdfsdlkfjsdlf, sdfsdfddf, sdfsdfsfd, sdfsdfdsf):
>        pass
>    """
>            with autopep8_context(line, options=['--experimental']) as result:
>>               self.assertEqual(fixed, result)
>E               AssertionError: 'def [28 chars]dfsf, sdfsdfsdf, sdfsdfkdk, szdfsdfsdf,\n     [68 chars]ss\n' != 'def [28 chars]dfsf,s dfsdfsdf, sdfsdfkdk, szdfsdfsdf, sdfsdf[56 chars]ss\n'
>E               + def foobar(sldfkjlsdfsdf, kksdfsdfsf,s dfsdfsdf, sdfsdfkdk, szdfsdfsdf, sdfsdfsdfsdlkfjsdlf, sdfsdfddf,s dfsdfsfd, sdfsdfdsf):
>E               - def foobar(sldfkjlsdfsdf, kksdfsdfsf, sdfsdfsdf, sdfsdfkdk, szdfsdfsdf,
>E               -            sdfsdfsdfsdlkfjsdlf, sdfsdfddf, sdfsdfsfd, sdfsdfdsf):
>E                     pass
>test/test_autopep8.py:6963: AssertionError
>_____ ExperimentalSystemTests.test_e501_with_experimental_and_indentation ______
>self = <test.test_autopep8.ExperimentalSystemTests testMethod=test_e501_with_experimental_and_indentation>
>        def test_e501_with_experimental_and_indentation(self):
>            line = """\
>    if True:
>        # comment here
>        print(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
>              bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,cccccccccccccccccccccccccccccccccccccccccc)
>    """
>            fixed = """\
>    if True:
>        # comment here
>        print(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
>              bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
>              cccccccccccccccccccccccccccccccccccccccccc)
>    """
>            with autopep8_context(line, options=['--experimental']) as result:
>>               self.assertEqual(fixed, result)
>E               AssertionError: 'if T[129 chars]bbbb,\n          cccccccccccccccccccccccccccccccccccccccccc)\n' != 'if T[129 chars]bbbb,c ccccccccccccccccccccccccccccccccccccccccc)\n'
>E                 if True:
>E                     # comment here
>E                     print(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
>E               +           bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,c ccccccccccccccccccccccccccccccccccccccccc)
>E               -           bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
>E               -           cccccccccccccccccccccccccccccccccccccccccc)
>test/test_autopep8.py:6903: AssertionError
>=============================== warnings summary ===============================
>test/test_autopep8.py::UnitTests::test_detect_encoding
>  /builddir/build/BUILD/autopep8-1.6.0/autopep8.py:198: DeprecationWarning: lib2to3 package is deprecated and may not be able to parse Python 3.10+
>    from lib2to3.pgen2 import tokenize as lib2to3_tokenize
>-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
>=========================== short test summary info ============================
>FAILED test/test_autopep8.py::SystemTests::test_e231 - AssertionError: '[1, 2...
>FAILED test/test_autopep8.py::SystemTests::test_e231_should_only_do_ws_comma_once
>FAILED test/test_autopep8.py::SystemTests::test_e231_with_colon_after_comma
>FAILED test/test_autopep8.py::SystemTests::test_e231_with_many_commas - Asser...
>FAILED test/test_autopep8.py::SystemTests::test_e302_bug - AssertionError: Fa...
>FAILED test/test_autopep8.py::SystemTests::test_e501_avoid_breaking_at_multi_level_slice
>FAILED test/test_autopep8.py::SystemTests::test_e501_avoid_breaking_at_opening_slice
>FAILED test/test_autopep8.py::SystemTests::test_e701_with_escaped_newline_and_spaces
>FAILED test/test_autopep8.py::SystemTests::test_e901_should_cause_indentation_screw_up
>FAILED test/test_autopep8.py::SystemTests::test_general_disable - AssertionEr...
>FAILED test/test_autopep8.py::SystemTests::test_w602_arg_is_string - Assertio...
>FAILED test/test_autopep8.py::SystemTests::test_w602_arg_is_string_with_comment
>FAILED test/test_autopep8.py::SystemTests::test_w602_escaped_cr - AssertionEr...
>FAILED test/test_autopep8.py::SystemTests::test_w602_escaped_crlf - Assertion...
>FAILED test/test_autopep8.py::SystemTests::test_w602_escaped_lf - AssertionEr...
>FAILED test/test_autopep8.py::SystemTests::test_w602_indentation - AssertionE...
>FAILED test/test_autopep8.py::SystemTests::test_w602_multiline - AssertionErr...
>FAILED test/test_autopep8.py::SystemTests::test_w602_multiline_with_escaped_newline
>FAILED test/test_autopep8.py::SystemTests::test_w602_multiline_with_escaped_newline_and_comment
>FAILED test/test_autopep8.py::SystemTests::test_w602_multiline_with_multiple_escaped_newlines
>FAILED test/test_autopep8.py::SystemTests::test_w602_multiline_with_nested_quotes
>FAILED test/test_autopep8.py::SystemTests::test_w602_multiline_with_trailing_spaces
>FAILED test/test_autopep8.py::SystemTests::test_w602_multiple_statements - As...
>FAILED test/test_autopep8.py::SystemTests::test_w602_raise_argument_triple_fake
>FAILED test/test_autopep8.py::SystemTests::test_w602_raise_argument_with_indentation
>FAILED test/test_autopep8.py::SystemTests::test_w602_triple_quotes - Assertio...
>FAILED test/test_autopep8.py::SystemTests::test_w602_with_complex_multiline
>FAILED test/test_autopep8.py::SystemTests::test_w602_with_list_comprehension
>FAILED test/test_autopep8.py::SystemTests::test_w602_with_logic - AssertionEr...
>FAILED test/test_autopep8.py::SystemTests::test_w602_with_multiline_with_single_quotes
>FAILED test/test_autopep8.py::CommandLineTests::test_verbose - AssertionError...
>FAILED test/test_autopep8.py::ExperimentalSystemTests::test_e501_experimental_dict
>FAILED test/test_autopep8.py::ExperimentalSystemTests::test_e501_experimental_oversized_default_initializer
>FAILED test/test_autopep8.py::ExperimentalSystemTests::test_e501_experimental_parsing_dict_with_comments
>FAILED test/test_autopep8.py::ExperimentalSystemTests::test_e501_experimental_with_complex_reformat
>FAILED test/test_autopep8.py::ExperimentalSystemTests::test_e501_experimental_with_def
>FAILED test/test_autopep8.py::ExperimentalSystemTests::test_e501_with_experimental_and_indentation
>============ 37 failed, 547 passed, 4 skipped, 1 warning in 18.44s =============
>error: Bad exit status from /var/tmp/rpm-tmp.iULKOU (%check)
>RPM build errors:
>    Bad exit status from /var/tmp/rpm-tmp.iULKOU (%check)
>Child return code was: 1
>EXCEPTION: [Error('Command failed: \n # /usr/bin/systemd-nspawn -q -M 2134b0065f8240859022ed14609bc462 -D /var/lib/mock/f39-build-44332558-5276202/root -a -u mockbuild --capability=cap_ipc_lock --bind=/tmp/mock-resolv.42m5tg37:/etc/resolv.conf --bind=/dev/btrfs-control --bind=/dev/mapper/control --bind=/dev/loop-control --bind=/dev/loop0 --bind=/dev/loop1 --bind=/dev/loop2 --bind=/dev/loop3 --bind=/dev/loop4 --bind=/dev/loop5 --bind=/dev/loop6 --bind=/dev/loop7 --bind=/dev/loop8 --bind=/dev/loop9 --bind=/dev/loop10 --bind=/dev/loop11 --console=pipe --setenv=TERM=vt100 --setenv=SHELL=/bin/bash --setenv=HOME=/builddir --setenv=HOSTNAME=mock --setenv=PATH=/usr/bin:/bin:/usr/sbin:/sbin --setenv=PROMPT_COMMAND=printf "\\033]0;<mock-chroot>\\007" --setenv=PS1=<mock-chroot> \\s-\\v\\$  --setenv=LANG=C.UTF-8 --resolv-conf=off bash --login -c /usr/bin/rpmbuild -ba --noprep --noclean --target noarch --nodeps /builddir/build/SPECS/python-autopep8.spec\n', 1)]
>Traceback (most recent call last):
>  File "/usr/lib/python3.11/site-packages/mockbuild/trace_decorator.py", line 93, in trace
>    result = func(*args, **kw)
>             ^^^^^^^^^^^^^^^^^
>  File "/usr/lib/python3.11/site-packages/mockbuild/util.py", line 597, in do_with_status
>    raise exception.Error("Command failed: \n # %s\n%s" % (command, output), child.returncode)
>mockbuild.exception.Error: Command failed: 
> # /usr/bin/systemd-nspawn -q -M 2134b0065f8240859022ed14609bc462 -D /var/lib/mock/f39-build-44332558-5276202/root -a -u mockbuild --capability=cap_ipc_lock --bind=/tmp/mock-resolv.42m5tg37:/etc/resolv.conf --bind=/dev/btrfs-control --bind=/dev/mapper/control --bind=/dev/loop-control --bind=/dev/loop0 --bind=/dev/loop1 --bind=/dev/loop2 --bind=/dev/loop3 --bind=/dev/loop4 --bind=/dev/loop5 --bind=/dev/loop6 --bind=/dev/loop7 --bind=/dev/loop8 --bind=/dev/loop9 --bind=/dev/loop10 --bind=/dev/loop11 --console=pipe --setenv=TERM=vt100 --setenv=SHELL=/bin/bash --setenv=HOME=/builddir --setenv=HOSTNAME=mock --setenv=PATH=/usr/bin:/bin:/usr/sbin:/sbin --setenv=PROMPT_COMMAND=printf "\033]0;<mock-chroot>\007" --setenv=PS1=<mock-chroot> \s-\v\$  --setenv=LANG=C.UTF-8 --resolv-conf=off bash --login -c /usr/bin/rpmbuild -ba --noprep --noclean --target noarch --nodeps /builddir/build/SPECS/python-autopep8.spec
>

Actions: View

Attachments on bug 2226154: 1978864 | 1978865 | 1978866