Skip to content

Commit

Permalink
Spell "With" instead of "with".
Browse files Browse the repository at this point in the history
  • Loading branch information
@serhiy-storchaka
serhiy-storchaka committed Jan 11, 2025
1 parent b825e23 commit a54e693
Show file tree
Hide file tree
Showing 12 changed files with 167 additions and 167 deletions.
24 changes: 12 additions & 12 deletions Doc/library/unittest.rst
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1224,17 +1224,17 @@ Test cases
| <TestCase.assertCountEqual>` | elements in the same number, | |
| | regardless of their order. | |
+---------------------------------------+--------------------------------+--------------+
| :meth:`assertStartswith(a, b) | ``a.startswith(b)`` | 3.14 |
| <TestCase.assertStartswith>` | | |
| :meth:`assertStartsWith(a, b) | ``a.startswith(b)`` | 3.14 |
| <TestCase.assertStartsWith>` | | |
+---------------------------------------+--------------------------------+--------------+
| :meth:`assertNotStartswith(a, b) | ``not a.startswith(b)`` | 3.14 |
| <TestCase.assertNotStartswith>` | | |
| :meth:`assertNotStartsWith(a, b) | ``not a.startswith(b)`` | 3.14 |
| <TestCase.assertNotStartsWith>` | | |
+---------------------------------------+--------------------------------+--------------+
| :meth:`assertEndswith(a, b) | ``a.endswith(b)`` | 3.14 |
| <TestCase.assertEndswith>` | | |
| :meth:`assertEndsWith(a, b) | ``a.endswith(b)`` | 3.14 |
| <TestCase.assertEndsWith>` | | |
+---------------------------------------+--------------------------------+--------------+
| :meth:`assertNotEndswith(a, b) | ``not a.endswith(b)`` | 3.14 |
| <TestCase.assertNotEndswith>` | | |
| :meth:`assertNotEndsWith(a, b) | ``not a.endswith(b)`` | 3.14 |
| <TestCase.assertNotEndsWith>` | | |
+---------------------------------------+--------------------------------+--------------+
| :meth:`assertHasAttr(a, b) | ``hastattr(a, b)`` | 3.14 |
| <TestCase.assertHasAttr>` | | |
Expand Down Expand Up @@ -1310,17 +1310,17 @@ Test cases

.. versionadded:: 3.2

.. method:: assertStartswith(s, prefix, msg=None)
.. method:: assertNotStartswith(s, prefix, msg=None)
.. method:: assertStartsWith(s, prefix, msg=None)
.. method:: assertNotStartsWith(s, prefix, msg=None)

Test that the unicode or byte string *s* starts (or does not start)
with a *prefix*.
*prefix* can also be a tuple of strings to try.

.. versionadded:: next

.. method:: assertEndswith(s, suffix, msg=None)
.. method:: assertNotEndswith(s, suffix, msg=None)
.. method:: assertEndsWith(s, suffix, msg=None)
.. method:: assertNotEndsWith(s, suffix, msg=None)

Test that the unicode or byte string *s* ends (or does not end)
with a *suffix*.
Expand Down
8 changes: 4 additions & 4 deletions Doc/whatsnew/3.14.rst
View file
Original file line number Diff line number Diff line change
Expand Up @@ -679,10 +679,10 @@ unittest
- :meth:`~unittest.TestCase.assertIsSubclass` and
:meth:`~unittest.TestCase.assertNotIsSubclass` check whether the object
is a subclass of a particular class, or of one of a tuple of classes.
- :meth:`~unittest.TestCase.assertStartswith`,
:meth:`~unittest.TestCase.assertNotStartswith`,
:meth:`~unittest.TestCase.assertEndswith` and
:meth:`~unittest.TestCase.assertNotEndswith` check whether the unicode
- :meth:`~unittest.TestCase.assertStartsWith`,
:meth:`~unittest.TestCase.assertNotStartsWith`,
:meth:`~unittest.TestCase.assertEndsWith` and
:meth:`~unittest.TestCase.assertNotEndsWith` check whether the unicode
or byte string starts or ends with particular string(s).

(Contributed by Serhiy Storchaka in :gh:`71339`.)
Expand Down
6 changes: 3 additions & 3 deletions Lib/test/test_gdb/test_misc.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@ def gdb_has_frame_select():
"Python was compiled with optimizations")
class PyListTests(DebuggerTests):
def assertListing(self, expected, actual):
self.assertEndswith(actual, expected)
self.assertEndsWith(actual, expected)

def test_basic_command(self):
'Verify that the "py-list" command works'
Expand Down Expand Up @@ -103,15 +103,15 @@ def test_down_at_bottom(self):
'Verify handling of "py-down" at the bottom of the stack'
bt = self.get_stack_trace(script=SAMPLE_SCRIPT,
cmds_after_breakpoint=['py-down'])
self.assertEndswith(bt,
self.assertEndsWith(bt,
'Unable to find a newer python frame\n')

@unittest.skipUnless(HAS_PYUP_PYDOWN, "test requires py-up/py-down commands")
def test_up_at_top(self):
'Verify handling of "py-up" at the top of the stack'
bt = self.get_stack_trace(script=SAMPLE_SCRIPT,
cmds_after_breakpoint=['py-up'] * 5)
self.assertEndswith(bt,
self.assertEndsWith(bt,
'Unable to find an older python frame\n')

@unittest.skipUnless(HAS_PYUP_PYDOWN, "test requires py-up/py-down commands")
Expand Down
4 changes: 2 additions & 2 deletions Lib/test/test_importlib/resources/test_functional.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -83,7 +83,7 @@ def test_read_text(self):
),
'\x00\x01\x02\x03',
)
self.assertEndswith( # ignore the BOM
self.assertEndsWith( # ignore the BOM
resources.read_text(
self.anchor01,
'utf-16.file',
Expand Down Expand Up @@ -135,7 +135,7 @@ def test_open_text(self):
'utf-16.file',
errors='backslashreplace',
) as f:
self.assertEndswith( # ignore the BOM
self.assertEndsWith( # ignore the BOM
f.read(),
'Hello, UTF-16 world!\n'.encode('utf-16-le').decode(
errors='backslashreplace',
Expand Down
110 changes: 55 additions & 55 deletions Lib/test/test_typing.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1426,96 +1426,96 @@ def test_variadic_class_repr_is_correct(self):
class A(Generic[*Ts]): pass
class B(Generic[Unpack[Ts]]): pass

self.assertEndswith(repr(A[()]), 'A[()]')
self.assertEndswith(repr(B[()]), 'B[()]')
self.assertEndswith(repr(A[float]), 'A[float]')
self.assertEndswith(repr(B[float]), 'B[float]')
self.assertEndswith(repr(A[float, str]), 'A[float, str]')
self.assertEndswith(repr(B[float, str]), 'B[float, str]')

self.assertEndswith(repr(A[*tuple[int, ...]]),
self.assertEndsWith(repr(A[()]), 'A[()]')
self.assertEndsWith(repr(B[()]), 'B[()]')
self.assertEndsWith(repr(A[float]), 'A[float]')
self.assertEndsWith(repr(B[float]), 'B[float]')
self.assertEndsWith(repr(A[float, str]), 'A[float, str]')
self.assertEndsWith(repr(B[float, str]), 'B[float, str]')

self.assertEndsWith(repr(A[*tuple[int, ...]]),
'A[*tuple[int, ...]]')
self.assertEndswith(repr(B[Unpack[Tuple[int, ...]]]),
self.assertEndsWith(repr(B[Unpack[Tuple[int, ...]]]),
'B[typing.Unpack[typing.Tuple[int, ...]]]')

self.assertEndswith(repr(A[float, *tuple[int, ...]]),
self.assertEndsWith(repr(A[float, *tuple[int, ...]]),
'A[float, *tuple[int, ...]]')
self.assertEndswith(repr(A[float, Unpack[Tuple[int, ...]]]),
self.assertEndsWith(repr(A[float, Unpack[Tuple[int, ...]]]),
'A[float, typing.Unpack[typing.Tuple[int, ...]]]')

self.assertEndswith(repr(A[*tuple[int, ...], str]),
self.assertEndsWith(repr(A[*tuple[int, ...], str]),
'A[*tuple[int, ...], str]')
self.assertEndswith(repr(B[Unpack[Tuple[int, ...]], str]),
self.assertEndsWith(repr(B[Unpack[Tuple[int, ...]], str]),
'B[typing.Unpack[typing.Tuple[int, ...]], str]')

self.assertEndswith(repr(A[float, *tuple[int, ...], str]),
self.assertEndsWith(repr(A[float, *tuple[int, ...], str]),
'A[float, *tuple[int, ...], str]')
self.assertEndswith(repr(B[float, Unpack[Tuple[int, ...]], str]),
self.assertEndsWith(repr(B[float, Unpack[Tuple[int, ...]], str]),
'B[float, typing.Unpack[typing.Tuple[int, ...]], str]')

def test_variadic_class_alias_repr_is_correct(self):
Ts = TypeVarTuple('Ts')
class A(Generic[Unpack[Ts]]): pass

B = A[*Ts]
self.assertEndswith(repr(B), 'A[typing.Unpack[Ts]]')
self.assertEndswith(repr(B[()]), 'A[()]')
self.assertEndswith(repr(B[float]), 'A[float]')
self.assertEndswith(repr(B[float, str]), 'A[float, str]')
self.assertEndsWith(repr(B), 'A[typing.Unpack[Ts]]')
self.assertEndsWith(repr(B[()]), 'A[()]')
self.assertEndsWith(repr(B[float]), 'A[float]')
self.assertEndsWith(repr(B[float, str]), 'A[float, str]')

C = A[Unpack[Ts]]
self.assertEndswith(repr(C), 'A[typing.Unpack[Ts]]')
self.assertEndswith(repr(C[()]), 'A[()]')
self.assertEndswith(repr(C[float]), 'A[float]')
self.assertEndswith(repr(C[float, str]), 'A[float, str]')
self.assertEndsWith(repr(C), 'A[typing.Unpack[Ts]]')
self.assertEndsWith(repr(C[()]), 'A[()]')
self.assertEndsWith(repr(C[float]), 'A[float]')
self.assertEndsWith(repr(C[float, str]), 'A[float, str]')

D = A[*Ts, int]
self.assertEndswith(repr(D), 'A[typing.Unpack[Ts], int]')
self.assertEndswith(repr(D[()]), 'A[int]')
self.assertEndswith(repr(D[float]), 'A[float, int]')
self.assertEndswith(repr(D[float, str]), 'A[float, str, int]')
self.assertEndsWith(repr(D), 'A[typing.Unpack[Ts], int]')
self.assertEndsWith(repr(D[()]), 'A[int]')
self.assertEndsWith(repr(D[float]), 'A[float, int]')
self.assertEndsWith(repr(D[float, str]), 'A[float, str, int]')

E = A[Unpack[Ts], int]
self.assertEndswith(repr(E), 'A[typing.Unpack[Ts], int]')
self.assertEndswith(repr(E[()]), 'A[int]')
self.assertEndswith(repr(E[float]), 'A[float, int]')
self.assertEndswith(repr(E[float, str]), 'A[float, str, int]')
self.assertEndsWith(repr(E), 'A[typing.Unpack[Ts], int]')
self.assertEndsWith(repr(E[()]), 'A[int]')
self.assertEndsWith(repr(E[float]), 'A[float, int]')
self.assertEndsWith(repr(E[float, str]), 'A[float, str, int]')

F = A[int, *Ts]
self.assertEndswith(repr(F), 'A[int, typing.Unpack[Ts]]')
self.assertEndswith(repr(F[()]), 'A[int]')
self.assertEndswith(repr(F[float]), 'A[int, float]')
self.assertEndswith(repr(F[float, str]), 'A[int, float, str]')
self.assertEndsWith(repr(F), 'A[int, typing.Unpack[Ts]]')
self.assertEndsWith(repr(F[()]), 'A[int]')
self.assertEndsWith(repr(F[float]), 'A[int, float]')
self.assertEndsWith(repr(F[float, str]), 'A[int, float, str]')

G = A[int, Unpack[Ts]]
self.assertEndswith(repr(G), 'A[int, typing.Unpack[Ts]]')
self.assertEndswith(repr(G[()]), 'A[int]')
self.assertEndswith(repr(G[float]), 'A[int, float]')
self.assertEndswith(repr(G[float, str]), 'A[int, float, str]')
self.assertEndsWith(repr(G), 'A[int, typing.Unpack[Ts]]')
self.assertEndsWith(repr(G[()]), 'A[int]')
self.assertEndsWith(repr(G[float]), 'A[int, float]')
self.assertEndsWith(repr(G[float, str]), 'A[int, float, str]')

H = A[int, *Ts, str]
self.assertEndswith(repr(H), 'A[int, typing.Unpack[Ts], str]')
self.assertEndswith(repr(H[()]), 'A[int, str]')
self.assertEndswith(repr(H[float]), 'A[int, float, str]')
self.assertEndswith(repr(H[float, str]), 'A[int, float, str, str]')
self.assertEndsWith(repr(H), 'A[int, typing.Unpack[Ts], str]')
self.assertEndsWith(repr(H[()]), 'A[int, str]')
self.assertEndsWith(repr(H[float]), 'A[int, float, str]')
self.assertEndsWith(repr(H[float, str]), 'A[int, float, str, str]')

I = A[int, Unpack[Ts], str]
self.assertEndswith(repr(I), 'A[int, typing.Unpack[Ts], str]')
self.assertEndswith(repr(I[()]), 'A[int, str]')
self.assertEndswith(repr(I[float]), 'A[int, float, str]')
self.assertEndswith(repr(I[float, str]), 'A[int, float, str, str]')
self.assertEndsWith(repr(I), 'A[int, typing.Unpack[Ts], str]')
self.assertEndsWith(repr(I[()]), 'A[int, str]')
self.assertEndsWith(repr(I[float]), 'A[int, float, str]')
self.assertEndsWith(repr(I[float, str]), 'A[int, float, str, str]')

J = A[*Ts, *tuple[str, ...]]
self.assertEndswith(repr(J), 'A[typing.Unpack[Ts], *tuple[str, ...]]')
self.assertEndswith(repr(J[()]), 'A[*tuple[str, ...]]')
self.assertEndswith(repr(J[float]), 'A[float, *tuple[str, ...]]')
self.assertEndswith(repr(J[float, str]), 'A[float, str, *tuple[str, ...]]')
self.assertEndsWith(repr(J), 'A[typing.Unpack[Ts], *tuple[str, ...]]')
self.assertEndsWith(repr(J[()]), 'A[*tuple[str, ...]]')
self.assertEndsWith(repr(J[float]), 'A[float, *tuple[str, ...]]')
self.assertEndsWith(repr(J[float, str]), 'A[float, str, *tuple[str, ...]]')

K = A[Unpack[Ts], Unpack[Tuple[str, ...]]]
self.assertEndswith(repr(K), 'A[typing.Unpack[Ts], typing.Unpack[typing.Tuple[str, ...]]]')
self.assertEndswith(repr(K[()]), 'A[typing.Unpack[typing.Tuple[str, ...]]]')
self.assertEndswith(repr(K[float]), 'A[float, typing.Unpack[typing.Tuple[str, ...]]]')
self.assertEndswith(repr(K[float, str]), 'A[float, str, typing.Unpack[typing.Tuple[str, ...]]]')
self.assertEndsWith(repr(K), 'A[typing.Unpack[Ts], typing.Unpack[typing.Tuple[str, ...]]]')
self.assertEndsWith(repr(K[()]), 'A[typing.Unpack[typing.Tuple[str, ...]]]')
self.assertEndsWith(repr(K[float]), 'A[float, typing.Unpack[typing.Tuple[str, ...]]]')
self.assertEndsWith(repr(K[float, str]), 'A[float, str, typing.Unpack[typing.Tuple[str, ...]]]')

def test_cannot_subclass(self):
with self.assertRaisesRegex(TypeError, NOT_A_BASE_TYPE % 'TypeVarTuple'):
Expand Down
Loading

0 comments on commit a54e693

Please sign in to comment.