This sort of follows on from other cleanup of test_bytes.py in Issue 19587.

Currently buffer_tests defines one base test class, MixinBytesBufferCommonTests, which is used by test_bytes.py to test bytearray (but not bytes!). However there are other tests defined in test_bytes.py, or string_tests.py, which are run, or could be run, for both bytearray and bytes. I haven’t checking too closely, but I think all the methods in buffer_tests could be merged with other methods and collected into string_tests.BaseTest. Then they would get run for bytes, bytearray, str, and UserString.

The following methods are probably redundant with class string_tests.MixinStrUnicodeUserStringTest (only run for str and UserString). It looks like there is no bytes version of these tests:

* test_islower/upper/title/space/alpha/alnum/digit()
* test_title()
* test_splitlines()

test_capitalize() looks redundant with half of the method in string_tests.CommonTest (also only run for str and UserString). Again there doesn’t seem to be a bytes version of it. I think the common part could be moved into BaseTest, and the unicode-specific part left where it is.

The following are probably also redundant with class string_tests.CommonTest:

* test_ljust/rjust/center()
* test_swapcase()
* test_zfill()

For ljust(), rjust() and center(), there are also tests run for bytes and bytearray in test_bytes.BaseBytesTest that could also be merged at the same time. But swapcase() and zfill() don’t seem to be currently tested for bytes.

I didn’t end up merging test_ljust/rjust/center() from test_bytes. Those tests are more specific to bytes and bytearray, so they are better left as-is.

It looks to me that all tests from CommonTest except test_capitalize_nonascii can be merged into BaseTest.

A number of tests from MixinStrUnicodeUserStringTest could be applied to bytes and bytearray too.

I think we should left only two classes in string_tests: common tests for str, UserString, bytes and bytearray, and common tests for str and UserString that are not applicable to bytes and bytearray.

Yes what you say about re-arranging the methods in string_tests.py makes sense to me. There might also be some factorizing possible between specific methods in test_bytes.py and the (currently) string-only test methods. But I would like to handle these as separate steps, to keep the patch size under control, ensure we don’t lose any important test cases in the process, etc.

I meant that the patch can be smaller if move more tests from CommonTest to BaseTest without changing order. Here is smaller patch.

I see what you meant about making the diff smaller. However in your patch you also moved three extra methods into BaseTest: test_additional_(r)split() and test_strip().

I prefer to handle these three methods in a separate patch that deals with test_bytes.BytesBaseTest, which also has split() and strip() tests. So this third patch moves those three methods back to CommonTest.

Unfortunately Mercurial can't handle moving file fragments. The history of these methods will be lost. That is why I prefer the patch with minimal moving.

Are there any disadvantages of having test_additional_(r)split() and test_strip() in BaseTest?

Okay you convinced me to leave those methods in the same relative position as in your patch. I can sympathize with keeping the Mercurial history small. :)

The only disadvantage is a couple extra microseconds wasted doing redundant tests. I will try and work on factoring out some of those tests next.

And would be nice to backport these changes to 2.7. This will help backporting new future tests.

I discovered a flaw in the bytearray tests: most of them don’t actually test bytearray objects! This is easy to fix in Python 3, and I added a test case to ensure that the arguments are converted to the expected type.

However porting this fix to Python 2 was trickier. A few of the bytearray methods do not accept bytearray arguments:

>>> bytearray(b"abc").ljust(10, bytearray(b"*"))
TypeError: ljust() argument 2 must be char, not bytearray
>>> bytearray(b"abc").rjust(10, bytearray(b"*"))
TypeError: rjust() argument 2 must be char, not bytearray
>>> bytearray(b"abc").center(10, bytearray(b"*"))
TypeError: center() argument 2 must be char, not bytearray

I adapted the tests from the deleted buffer_tests.py file to override the relevant tests from string_tests.py, so that we continue to test bytearray methods but with str a.k.a. bytes arguments.

Nice.

> I discovered a flaw in the bytearray tests: most of them don’t actually test bytearray objects!

Good catch!

> I adapted the tests from the deleted buffer_tests.py file to override the relevant tests from string_tests.py, so that we continue to test bytearray methods but with str a.k.a. bytes arguments.

The patch LGTM. But may be instead of duplicating tests add fixfillchartype() (calling fixtype() by default)? If this don't complicate tests too much.

New changeset 197e1f8b28b7 by Martin Panter in branch '3.5':
Issue #26257: Eliminate buffer_tests.py and fix ByteArrayAsStringTest
https://hg.python.org/cpython/rev/197e1f8b28b7

New changeset ea598d69b7d3 by Martin Panter in branch 'default':
Issue #26257: Merge buffer_tests cleanup from 3.5
https://hg.python.org/cpython/rev/ea598d69b7d3

New changeset 26f1543e806c by Martin Panter in branch '2.7':
Issue #26257: Eliminate buffer_tests.py and fix ByteArrayAsStringTest
https://hg.python.org/cpython/rev/26f1543e806c

Thanks for you help with this Serhiy. Instead of your fixfillchartype(), I went with special “if self.type2test is bytearray” checks in the common tests.