# sysconf not available or setting not available
return
if nsems_max == -1:
- # indetermine limit, assume that limit is determined
+ # indetermined limit, assume that limit is determined
# by available memory only
return
if nsems_max >= 256:
self._result_queue.put(None)
if wait:
self._queue_management_thread.join()
- # To reduce the risk of openning too many files, remove references to
+ # To reduce the risk of opening too many files, remove references to
# objects that use file descriptors.
self._queue_management_thread = None
self._call_queue = None
Run all tests found in this directory, and print a summary of the results.
Command line flags:
- -q quiet mode: don't prnt anything while the tests are running
+ -q quiet mode: don't print anything while the tests are running
-r run tests repeatedly, look for refcount leaks
-u<resources>
Add resources to the lits of allowed resources. '*' allows all
self.assertEqual(self._dll.tv_i(-42), None)
self.assertEqual(self.S(), -42)
-# The following repeates the above tests with stdcall functions (where
+# The following repeats the above tests with stdcall functions (where
# they are available)
try:
WinDLL
def test_init(self):
# c_int() can be initialized from Python's int, and c_int.
- # Not from c_long or so, which seems strange, abd should
+ # Not from c_long or so, which seems strange, abc should
# probably be changed:
self.assertRaises(TypeError, c_int, c_long(42))
# this is the standard refcount for func
self.assertEqual(grc(func), 2)
- # the CFuncPtr instance holds atr least one refcount on func:
+ # the CFuncPtr instance holds at least one refcount on func:
f = OtherCallback(func)
self.assertTrue(grc(func) > 2)
x = X()
x.a = OtherCallback(func)
- # the CFuncPtr instance holds atr least one refcount on func:
+ # the CFuncPtr instance holds at least one refcount on func:
self.assertTrue(grc(func) > 2)
# and may release it again
f = OtherCallback(func)
- # the CFuncPtr instance holds atr least one refcount on func:
+ # the CFuncPtr instance holds at least one refcount on func:
self.assertTrue(grc(func) > 2)
# create a cycle
def test_emtpy(self):
# I had problems with these
#
- # Although these are patological cases: Empty Structures!
+ # Although these are pathological cases: Empty Structures!
class X(Structure):
_fields_ = []
self.extra_dirs = extra_dirs
def change_roots(self, *names):
- """Change the install direcories pointed by name using root."""
+ """Change the install directories pointed by name using root."""
for name in names:
attr = "install_" + name
setattr(self, attr, change_root(self.root, getattr(self, attr)))
depends on the user's options.
"""
# new behavior when using a template:
- # the file list is recalculated everytime because
+ # the file list is recalculated every time because
# even if MANIFEST.in or setup.py are not changed
# the user might have added some files in the tree that
# need to be included.
cmd.compiler = FakeCompiler()
- # build_libraries is also doing a bit of typoe checking
+ # build_libraries is also doing a bit of typo checking
lib = [('name', {'sources': 'notvalid'})]
self.assertRaises(DistutilsSetupError, cmd.build_libraries, lib)
"""Mock for tkinter.messagebox with an Mbox_func for each function.
This module was 'tkMessageBox' in 2.x; hence the 'import as' in 3.x.
- Example usage in test_module.py for testing functios in module.py:
+ Example usage in test_module.py for testing functions in module.py:
---
from idlelib.idle_test.mock_tk import Mbox
import module
This implements .index without converting the result back to a string.
The result is contrained by the number of lines and linelengths of
- self.data. For many indexes, the result is initally (1, 0).
+ self.data. For many indexes, the result is initially (1, 0).
The input index may have any of several possible forms:
* line.char float: converted to 'line.char' string;
-1: position before terminal \n; for .insert(), .delete
0: position after terminal \n; for .get, .delete index 1
- 1: same viewed as begininning of non-existent next line (for .index)
+ 1: same viewed as beginning of non-existent next line (for .index)
'''
n = len(self.data)
if endflag == 1:
"Scroll screen to make the character at INDEX is visible."
pass
- # The following is a Misc method inheritet by Text.
+ # The following is a Misc method inherited by Text.
# It should properly go in a Misc mock, but is included here for now.
def bind(sequence=None, func=None, add=None):
"""Test the formatting of text inside a Text widget.
This is done with FormatParagraph.format.paragraph_event,
- which calls funtions in the module as appropriate.
+ which calls functions in the module as appropriate.
"""
test_string = (
" '''this is a test of a reformat for a triple "
# Remove the 'itertools'
prefix = it.prefix
it.remove()
- # Replace the node wich contains ('.', 'function') with the
- # function (to be consistant with the second part of the pattern)
+ # Replace the node which contains ('.', 'function') with the
+ # function (to be consistent with the second part of the pattern)
dot.remove()
func.parent.replace(func)
def fixup_simple_stmt(parent, i, stmt_node):
""" if there is a semi-colon all the parts count as part of the same
simple_stmt. We just want the __metaclass__ part so we move
- everything efter the semi-colon into its own simple_stmt node
+ everything after the semi-colon into its own simple_stmt node
"""
for semi_ind, node in enumerate(stmt_node.children):
if node.type == token.SEMI: # *sigh*
self.invalid_syntax("raise E from")
-# Adapated from Python 3's Lib/test/test_grammar.py:GrammarTests.testFuncdef
+# Adaptated from Python 3's Lib/test/test_grammar.py:GrammarTests.testFuncdef
class TestFunctionAnnotations(GrammarTest):
def test_1(self):
self.validate("""def f(x) -> list: pass""")
def CheckCursorConstructorCallCheck(self):
"""
- Verifies that cursor methods check wether base class __init__ was called.
+ Verifies that cursor methods check whether base class __init__ was
+ called.
"""
class Cursor(sqlite.Cursor):
def __init__(self, con):
def CheckConnectionConstructorCallCheck(self):
"""
- Verifies that connection methods check wether base class __init__ was called.
+ Verifies that connection methods check whether base class __init__ was
+ called.
"""
class Connection(sqlite.Connection):
def __init__(self, name):
self.assertEqual(type(value), float)
def CheckNumber2(self):
- """Checks wether converter names are cut off at '(' characters"""
+ """Checks whether converter names are cut off at '(' characters"""
self.cur.execute("insert into test(n2) values (5)")
value = self.cur.execute("select n2 from test").fetchone()[0]
# if the converter is not used, it's an int instead of a float
if sys.platform.startswith("win"):
def _waitfor(func, pathname, waitall=False):
- # Peform the operation
+ # Perform the operation
func(pathname)
# Now setup the wait loop
if waitall:
# required when contention occurs.
timeout = 0.001
while timeout < 1.0:
- # Note we are only testing for the existance of the file(s) in
+ # Note we are only testing for the existence of the file(s) in
# the contents of the directory regardless of any security or
# access rights. If we have made it this far, we have sufficient
# permissions to do that much using Python's equivalent of the
'\tname*1*=%2A%2A%2Afun%2A%2A%2A%20;\tname*2="is it not.pdf"\n'),
),
- # Make sure we also handle it if there are spurrious double qoutes.
+ # Make sure we also handle it if there are spurious double quotes.
'rfc2231_encoded_with_double_quotes': (
("text/plain;"
'\tname*0*="us-ascii\'\'This%20is%20even%20more%20";'
# in double quotes, making the value a valid non-encoded string. The
# old parser decodes this just like the previous case, which may be the
# better Postel rule, but could equally result in borking headers that
- # intentially have quoted quotes in them. We could get this 98% right
- # if we treat it as a quoted string *unless* it matches the
+ # intentionally have quoted quotes in them. We could get this 98%
+ # right if we treat it as a quoted string *unless* it matches the
# charset'lang'value pattern exactly *and* there is at least one
# encoded segment. Implementing that algorithm will require some
# refactoring, so I haven't done it (yet).
[errors.InvalidHeaderDefect]),
# Unrecoverable invalid values. We *could* apply more heuristics to
- # get someing out of the first two, but doing so is not worth the
+ # get something out of the first two, but doing so is not worth the
# effort.
'non_comment_garbage_before': (
def test_fold_unstructured_with_commas(self):
# The old wrapper would fold this at the commas.
h = self.make_header('Subject', "This header is intended to "
- "demonstrate, in a fairly susinct way, that we now do "
+ "demonstrate, in a fairly succinct way, that we now do "
"not give a , special treatment in unstructured headers.")
self.assertEqual(
h.fold(policy=policy.default.clone(max_line_length=60)),
textwrap.dedent("""\
Subject: This header is intended to demonstrate, in a fairly
- susinct way, that we now do not give a , special treatment
+ succinct way, that we now do not give a , special treatment
in unstructured headers.
"""))
self.assertWarns(DeprecationWarning, _runtime_warn)
def testAssertWarnsContext(self):
- # Believe it or not, it is preferrable to duplicate all tests above,
+ # Believe it or not, it is preferable to duplicate all tests above,
# to make sure the __warningregistry__ $@ is circumvented correctly.
def _runtime_warn():
warnings.warn("foo", RuntimeWarning)
# Does loadTestsFromName raise TypeError when the `module` argument
# isn't a module object?
#
- # XXX Accepts the not-a-module object, ignorning the object's type
+ # XXX Accepts the not-a-module object, ignoring the object's type
# This should raise an exception or the method name should be changed
#
# XXX Some people are relying on this, so keep it for now
self.assertEqual(program.testNames, argv[1:])
# it may be better to use platform specific functions to normalise paths
- # rather than accepting '.PY' and '\' as file seprator on Linux / Mac
+ # rather than accepting '.PY' and '\' as file separator on Linux / Mac
# it would also be better to check that a filename is a valid module
# identifier (we have a regex for this in loader.py)
# for invalid filenames should we raise a useful error rather than
@contextlib.contextmanager
def _get_writer(file_or_filename, encoding):
- # returns text write method and release all resourses after using
+ # returns text write method and release all resources after using
try:
write = file_or_filename.write
except AttributeError:
projects / python / commitdiff