svn+ssh://pythondev@svn.python.org/python/trunk
........
r64475 | raymond.hettinger | 2008-06-22 22:29:28 -0500 (Sun, 22 Jun 2008) | 1 line
Issue 3161: Missing import and test.
........
r64544 | georg.brandl | 2008-06-26 16:12:55 -0500 (Thu, 26 Jun 2008) | 2 lines
Use newer versions of externals.
........
r64545 | benjamin.peterson | 2008-06-26 16:23:30 -0500 (Thu, 26 Jun 2008) | 1 line
add a htmlview directive
........
r64550 | brett.cannon | 2008-06-26 19:32:16 -0500 (Thu, 26 Jun 2008) | 2 lines
Ignore .pyc and .pyo files.
........
r64557 | mark.dickinson | 2008-06-27 05:11:52 -0500 (Fri, 27 Jun 2008) | 3 lines
Remove trailing 'L's from numerator and denominator in the
repr() of a Fraction instance.
........
r64558 | mark.dickinson | 2008-06-27 06:03:21 -0500 (Fri, 27 Jun 2008) | 2 lines
Add Jean Brouwers for his work on math.sum
........
r64565 | raymond.hettinger | 2008-06-27 16:34:24 -0500 (Fri, 27 Jun 2008) | 1 line
Fix whitespace in example code.
........
r64570 | hyeshik.chang | 2008-06-27 20:04:31 -0500 (Fri, 27 Jun 2008) | 8 lines
Give information for compililation of _multiprocessing.SemLock on FreeBSD:
FreeBSD's P1003.1b semaphore support is highly experimental and
it's disabled by default. Even if a user loads the experimental
kernel module manually, _multiprocessing doesn't work correctly due
to several known incompatibilities around sem_unlink and sem_getvalue,
yet.
........
r64577 | raymond.hettinger | 2008-06-28 17:16:53 -0500 (Sat, 28 Jun 2008) | 1 line
Issue 3230: Do not the set specific size macro.
........
r64582 | benjamin.peterson | 2008-06-28 18:06:05 -0500 (Sat, 28 Jun 2008) | 2 lines
convert test_audioop to unittest. Thanks to Giampaolo Rodola.
........
r64583 | benjamin.peterson | 2008-06-28 18:06:49 -0500 (Sat, 28 Jun 2008) | 1 line
rewrap
........
r64585 | benjamin.peterson | 2008-06-28 18:35:31 -0500 (Sat, 28 Jun 2008) | 1 line
fix typo
........
r64590 | benjamin.peterson | 2008-06-29 08:43:07 -0500 (Sun, 29 Jun 2008) | 1 line
reinstate the ending backtick. thanks Nick :)
........
r64592 | vinay.sajip | 2008-06-29 16:25:28 -0500 (Sun, 29 Jun 2008) | 2 lines
Removed out-of-date comment in _install_handlers and
used issubclass in place of equality comparison of classes.
........
r64593 | vinay.sajip | 2008-06-29 16:27:15 -0500 (Sun, 29 Jun 2008) | 1 line
Updated to reflect change in logging.config to remove out-of-date comment in _install_handlers and the use of issubclass in place of equality comparison of classes.
........
r64625 | georg.brandl | 2008-07-01 14:59:00 -0500 (Tue, 01 Jul 2008) | 2 lines
Add a link to PEP 324.
........
r64630 | georg.brandl | 2008-07-01 15:18:10 -0500 (Tue, 01 Jul 2008) | 2 lines
#3216: fix Execute's parameter description.
........
r64638 | georg.brandl | 2008-07-01 15:50:02 -0500 (Tue, 01 Jul 2008) | 2 lines
#
1410739: add a footnote about "is" and "unusual" behavior.
........
r64647 | benjamin.peterson | 2008-07-01 18:33:06 -0500 (Tue, 01 Jul 2008) | 1 line
add ABC to the glossary
........
r64655 | mark.dickinson | 2008-07-02 04:37:01 -0500 (Wed, 02 Jul 2008) | 7 lines
Replace occurrences of '\d' with '[0-9]' in Decimal regex, to make sure
that the behaviour of Decimal doesn't change if/when re.UNICODE becomes
assumed in Python 3.0.
Also add a check that alternative Unicode digits (e.g. u'\N{FULLWIDTH
DIGIT ONE}') are *not* accepted in a numeric string.
........
r64656 | nick.coghlan | 2008-07-02 08:09:19 -0500 (Wed, 02 Jul 2008) | 1 line
Issue 3190: pydoc now hides module __package__ attributes
........
r64663 | jesse.noller | 2008-07-02 11:44:09 -0500 (Wed, 02 Jul 2008) | 1 line
Reenable the manager tests with Amaury's threading fix
........
r64664 | facundo.batista | 2008-07-02 11:52:55 -0500 (Wed, 02 Jul 2008) | 4 lines
Issue #449227: Now with the rlcompleter module, callable objects are
added a '(' when completed.
........
fi
@if [ ! -d tools/docutils ]; then \
echo "Checking out Docutils..."; \
- svn checkout $(SVNROOT)/external/docutils-0.4/docutils tools/docutils; \
+ svn checkout $(SVNROOT)/external/docutils-0.5/docutils tools/docutils; \
fi
@if [ ! -d tools/jinja ]; then \
echo "Checking out Jinja..."; \
- svn checkout $(SVNROOT)/external/Jinja-1.1/jinja tools/jinja; \
+ svn checkout $(SVNROOT)/external/Jinja-1.2/jinja tools/jinja; \
fi
@if [ ! -d tools/pygments ]; then \
echo "Checking out Pygments..."; \
- svn checkout $(SVNROOT)/external/Pygments-0.9/pygments tools/pygments; \
+ svn checkout $(SVNROOT)/external/Pygments-0.10/pygments tools/pygments; \
fi
update: checkout
@echo "Building finished; now copy build/pydoc-topics/pydoc_topics.py " \
"into the Lib/ directory"
+htmlview: html
+ $(PYTHON) -c "import webbrowser; webbrowser.open('build/html/index.html')"
clean:
-rm -rf build/*
-rm -rf tools/sphinx
The typical Python prompt of the interactive shell when entering code for
an indented code block.
+ Abstract Base Class
+ Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
+ providing a way to define interfaces when other techniques like :func:`hasattr`
+ would be clumsy. Python comes with many builtin ABCs for data structures
+ (in the :mod:`collections` module), numbers (in the :mod:`numbers`
+ module), and streams (in the :mod:`io` module). You can create your own
+ ABC with the :mod:`abc` module.
+
argument
A value passed to a function or method, assigned to a name local to
the body. A function or method may have both positional arguments and
be any object with a :meth:`__hash__` function, not just integers starting
from zero. Called a hash in Perl.
- duck-typing
+ duck-typing
Pythonic programming style that determines an object's type by inspection
of its method or attribute signature rather than by explicit relationship
to some type object ("If it looks like a duck and quacks like a duck, it
must be a duck.") By emphasizing interfaces rather than specific types,
well-designed code improves its flexibility by allowing polymorphic
substitution. Duck-typing avoids tests using :func:`type` or
- :func:`isinstance`. Instead, it typically employs :func:`hasattr` tests or
- :term:`EAFP` programming.
+ :func:`isinstance`. (Note, however, that duck-typing can be complemented
+ with abstract base classes.) Instead, it typically employs :func:`hasattr`
+ tests or :term:`EAFP` programming.
EAFP
Easier to ask for forgiveness than permission. This common Python coding
.. sectionauthor:: Georg Brandl
.. much of the content adapted from docstrings
-This module provides the infrastructure for defining abstract base classes
-(ABCs) in Python, as outlined in :pep:`3119`; see the PEP for why this was added
-to Python. (See also :pep:`3141` and the :mod:`numbers` module regarding a type
-hierarchy for numbers based on ABCs.)
+This module provides the infrastructure for defining :term:`abstract base
+classes` (ABCs) in Python, as outlined in :pep:`3119`; see the PEP for why this
+was added to Python. (See also :pep:`3141` and the :mod:`numbers` module
+regarding a type hierarchy for numbers based on ABCs.)
The :mod:`collections` module has some concrete classes that derive from
ABCs; these can, of course, be further derived. In addition the
raise ValueError('Got unexpected field names: %r' % kwds.keys())
return result
<BLANKLINE>
- def __getnewargs__(self):
- return tuple(self)
+ def __getnewargs__(self):
+ return tuple(self)
<BLANKLINE>
x = property(itemgetter(0))
y = property(itemgetter(1))
-
:mod:`msilib` --- Read and write Microsoft Installer files
==========================================================
------------
-.. method:: View.Execute([params=None])
+.. method:: View.Execute(params)
- Execute the SQL query of the view, through :cfunc:`MSIViewExecute`. *params* is
- an optional record describing actual values of the parameter tokens in the
- query.
+ Execute the SQL query of the view, through :cfunc:`MSIViewExecute`. If
+ *params* is not ``None``, it is a record describing actual values of the
+ parameter tokens in the query.
.. method:: View.GetColumnInfo(kind)
>>> import readline
>>> readline.parse_and_bind("tab: complete")
>>> readline. <TAB PRESSED>
- readline.__doc__ readline.get_line_buffer readline.read_init_file
- readline.__file__ readline.insert_text readline.set_completer
- readline.__name__ readline.parse_and_bind
+ readline.__doc__ readline.get_line_buffer( readline.read_init_file(
+ readline.__file__ readline.insert_text( readline.set_completer(
+ readline.__name__ readline.parse_and_bind(
>>> readline.
The :mod:`rlcompleter` module is designed for use with Python's interactive
Information about how the :mod:`subprocess` module can be used to replace these
modules and functions can be found in the following sections.
+.. seealso::
+
+ :pep:`324` -- PEP proposing the subprocess module
+
Using the subprocess Module
---------------------------
:pep:`3129` - Class Decorators
-Class definitions, like function definitions, may be wrapped by one or
-more :term:`decorator` expressions. The evaluation rules for the
-decorator expressions are the same as for functions. The result must
-be a class object, which is then bound to the class name.
+Class definitions, like function definitions, may be wrapped by one or more
+:term:`decorator` expressions. The evaluation rules for the decorator
+expressions are the same as for functions. The result must be a class object,
+which is then bound to the class name.
.. rubric:: Footnotes
The operators :keyword:`is` and :keyword:`is not` test for object identity: ``x
is y`` is true if and only if *x* and *y* are the same object. ``x is not y``
-yields the inverse truth value.
+yields the inverse truth value. [#]_
.. _booleans:
identity only, but this caused surprises because people expected to be able
to test a dictionary for emptiness by comparing it to ``{}``.
+.. [#] Due to automatic garbage-collection, free lists, and the dynamic nature of
+ descriptors, you may notice seemingly unusual behaviour in certain uses of
+ the :keyword:`is` operator, like those involving comparisons between instance
+ methods, or constants. Check their documentation for more info.
"""
from abc import ABCMeta, abstractmethod
+import sys
__all__ = ["Hashable", "Iterable", "Iterator",
"Sized", "Container", "Callable",
# other meaning for \d than the numbers [0-9].
import re
-_parser = re.compile(r""" # A numeric string consists of:
+_parser = re.compile(r""" # A numeric string consists of:
# \s*
- (?P<sign>[-+])? # an optional sign, followed by either...
+ (?P<sign>[-+])? # an optional sign, followed by either...
(
- (?=\d|\.\d) # ...a number (with at least one digit)
- (?P<int>\d*) # consisting of a (possibly empty) integer part
- (\.(?P<frac>\d*))? # followed by an optional fractional part
- (E(?P<exp>[-+]?\d+))? # followed by an optional exponent, or...
+ (?=[0-9]|\.[0-9]) # ...a number (with at least one digit)
+ (?P<int>[0-9]*) # having a (possibly empty) integer part
+ (\.(?P<frac>[0-9]*))? # followed by an optional fractional part
+ (E(?P<exp>[-+]?[0-9]+))? # followed by an optional exponent, or...
|
- Inf(inity)? # ...an infinity, or...
+ Inf(inity)? # ...an infinity, or...
|
- (?P<signal>s)? # ...an (optionally signaling)
- NaN # NaN
- (?P<diag>\d*) # with (possibly empty) diagnostic information.
+ (?P<signal>s)? # ...an (optionally signaling)
+ NaN # NaN
+ (?P<diag>[0-9]*) # with (possibly empty) diagnostic info.
)
# \s*
\Z
def __repr__(self):
"""repr(self)"""
- return ('Fraction(%r, %r)' % (self._numerator, self._denominator))
+ return ('Fraction(%s, %s)' % (self._numerator, self._denominator))
def __str__(self):
"""str(self)"""
h.setLevel(logging._levelNames[level])
if len(fmt):
h.setFormatter(formatters[fmt])
- #temporary hack for FileHandler and MemoryHandler.
- if klass == logging.handlers.MemoryHandler:
+ if issubclass(klass, logging.handlers.MemoryHandler):
if "target" in opts:
target = cp.get(sectname,"target")
else:
def visiblename(name, all=None):
"""Decide whether to show documentation on a variable."""
# Certain special names are redundant.
- if name in ('__builtins__', '__doc__', '__file__', '__path__',
- '__module__', '__name__', '__slots__'): return 0
+ _hidden_names = ('__builtins__', '__doc__', '__file__', '__path__',
+ '__module__', '__name__', '__slots__', '__package__')
+ if name in _hidden_names: return 0
# Private names are hidden, but special names are displayed.
if name.startswith('__') and name.endswith('__'): return 1
if all is not None:
except IndexError:
return None
+ def _callable_postfix(self, val, word):
+ if callable(val):
+ word = word + "("
+ return word
+
def global_matches(self, text):
"""Compute matches when text is a simple name.
import keyword
matches = []
n = len(text)
- for list in [keyword.kwlist,
- builtins.__dict__,
- self.namespace]:
- for word in list:
- if word[:n] == text and word != "__builtins__":
- matches.append(word)
+ for word in keyword.kwlist:
+ if word[:n] == text:
+ matches.append(word)
+ for nspace in [builtins.__dict__, self.namespace]:
+ for word, val in nspace.items():
+ if word[:n] == text and word != "builtins":
+ matches.append(self._callable_postfix(val, word))
return matches
def attr_matches(self, text):
n = len(attr)
for word in words:
if word[:n] == attr and word != "__builtins__":
- matches.append("%s.%s" % (expr, word))
+ val = getattr(object, word)
+ word = self._callable_postfix(val, "%s.%s" % (expr, word))
+ matches.append(word)
return matches
def get_class_members(klass):
-# Test audioop.
import audioop
-from test.support import verbose
+import unittest
+from test.support import run_unittest
+
def gendata1():
return b'\0\1\2'
def gendata2():
- if verbose:
- print('getsample')
if audioop.getsample(b'\0\1', 2, 0) == 1:
return b'\0\0\0\1\0\2'
else:
return b'\0\0\1\0\2\0'
def gendata4():
- if verbose:
- print('getsample')
if audioop.getsample(b'\0\0\0\1', 4, 0) == 1:
return b'\0\0\0\0\0\0\0\1\0\0\0\2'
else:
return b'\0\0\0\0\1\0\0\0\2\0\0\0'
-def testmax(data):
- if verbose:
- print('max')
- if audioop.max(data[0], 1) != 2 or \
- audioop.max(data[1], 2) != 2 or \
- audioop.max(data[2], 4) != 2:
- return 0
- return 1
-
-def testminmax(data):
- if verbose:
- print('minmax')
- if audioop.minmax(data[0], 1) != (0, 2) or \
- audioop.minmax(data[1], 2) != (0, 2) or \
- audioop.minmax(data[2], 4) != (0, 2):
- return 0
- return 1
-
-def testmaxpp(data):
- if verbose:
- print('maxpp')
- if audioop.maxpp(data[0], 1) != 0 or \
- audioop.maxpp(data[1], 2) != 0 or \
- audioop.maxpp(data[2], 4) != 0:
- return 0
- return 1
-
-def testavg(data):
- if verbose:
- print('avg')
- if audioop.avg(data[0], 1) != 1 or \
- audioop.avg(data[1], 2) != 1 or \
- audioop.avg(data[2], 4) != 1:
- return 0
- return 1
-
-def testavgpp(data):
- if verbose:
- print('avgpp')
- if audioop.avgpp(data[0], 1) != 0 or \
- audioop.avgpp(data[1], 2) != 0 or \
- audioop.avgpp(data[2], 4) != 0:
- return 0
- return 1
-
-def testrms(data):
- if audioop.rms(data[0], 1) != 1 or \
- audioop.rms(data[1], 2) != 1 or \
- audioop.rms(data[2], 4) != 1:
- return 0
- return 1
-
-def testcross(data):
- if verbose:
- print('cross')
- if audioop.cross(data[0], 1) != 0 or \
- audioop.cross(data[1], 2) != 0 or \
- audioop.cross(data[2], 4) != 0:
- return 0
- return 1
-
-def testadd(data):
- if verbose:
- print('add')
- data2 = []
- for d in data:
- str = bytearray(len(d))
- for i,b in enumerate(d):
- str[i] = 2*b
- data2.append(str)
- if audioop.add(data[0], data[0], 1) != data2[0] or \
- audioop.add(data[1], data[1], 2) != data2[1] or \
- audioop.add(data[2], data[2], 4) != data2[2]:
- return 0
- return 1
-
-def testbias(data):
- if verbose:
- print('bias')
- # Note: this test assumes that avg() works
- d1 = audioop.bias(data[0], 1, 100)
- d2 = audioop.bias(data[1], 2, 100)
- d4 = audioop.bias(data[2], 4, 100)
- if audioop.avg(d1, 1) != 101 or \
- audioop.avg(d2, 2) != 101 or \
- audioop.avg(d4, 4) != 101:
- return 0
- return 1
-
-def testlin2lin(data):
- if verbose:
- print('lin2lin')
- # too simple: we test only the size
- for d1 in data:
- for d2 in data:
- got = len(d1)//3
- wtd = len(d2)//3
- if len(audioop.lin2lin(d1, got, wtd)) != len(d2):
- return 0
- return 1
-
-def testadpcm2lin(data):
- # Very cursory test
- if audioop.adpcm2lin(b'\0\0', 1, None) != (b'\0\0\0\0', (0,0)):
- return 0
- return 1
-
-def testlin2adpcm(data):
- if verbose:
- print('lin2adpcm')
- # Very cursory test
- if audioop.lin2adpcm(b'\0\0\0\0', 1, None) != (b'\0\0', (0,0)):
- return 0
- return 1
-
-def testlin2alaw(data):
- if verbose:
- print('lin2alaw')
- if audioop.lin2alaw(data[0], 1) != b'\xd5\xc5\xf5' or \
- audioop.lin2alaw(data[1], 2) != b'\xd5\xd5\xd5' or \
- audioop.lin2alaw(data[2], 4) != b'\xd5\xd5\xd5':
- return 0
- return 1
-
-def testalaw2lin(data):
- if verbose:
- print('alaw2lin')
- # Cursory
- d = audioop.lin2alaw(data[0], 1)
- if audioop.alaw2lin(d, 1) != data[0]:
- return 0
- return 1
-
-def testlin2ulaw(data):
- if verbose:
- print('lin2ulaw')
- if audioop.lin2ulaw(data[0], 1) != b'\xff\xe7\xdb' or \
- audioop.lin2ulaw(data[1], 2) != b'\xff\xff\xff' or \
- audioop.lin2ulaw(data[2], 4) != b'\xff\xff\xff':
- return 0
- return 1
-
-def testulaw2lin(data):
- if verbose:
- print('ulaw2lin')
- # Cursory
- d = audioop.lin2ulaw(data[0], 1)
- if audioop.ulaw2lin(d, 1) != data[0]:
- return 0
- return 1
-
-def testmul(data):
- if verbose:
- print('mul')
- data2 = []
- for d in data:
- str = bytearray(len(d))
- for i,b in enumerate(d):
- str[i] = 2*b
- data2.append(str)
- if audioop.mul(data[0], 1, 2) != data2[0] or \
- audioop.mul(data[1],2, 2) != data2[1] or \
- audioop.mul(data[2], 4, 2) != data2[2]:
- return 0
- return 1
-
-def testratecv(data):
- if verbose:
- print('ratecv')
- state = None
- d1, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
- d2, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
- if d1 + d2 != b'\000\000\001\001\002\001\000\000\001\001\002':
- return 0
- return 1
-
-def testreverse(data):
- if verbose:
- print('reverse')
- if audioop.reverse(data[0], 1) != b'\2\1\0':
- return 0
- return 1
-
-def testtomono(data):
- if verbose:
- print('tomono')
- data2 = bytearray()
- for d in data[0]:
- data2.append(d)
- data2.append(d)
- if audioop.tomono(data2, 1, 0.5, 0.5) != data[0]:
- return 0
- return 1
-
-def testtostereo(data):
- if verbose:
- print('tostereo')
- data2 = bytearray()
- for d in data[0]:
- data2.append(d)
- data2.append(d)
- if audioop.tostereo(data[0], 1, 1, 1) != data2:
- return 0
- return 1
-
-def testfindfactor(data):
- if verbose:
- print('findfactor')
- if audioop.findfactor(data[1], data[1]) != 1.0:
- return 0
- return 1
-
-def testfindfit(data):
- if verbose:
- print('findfit')
- if audioop.findfit(data[1], data[1]) != (0, 1.0):
- return 0
- return 1
-
-def testfindmax(data):
- if verbose:
- print('findmax')
- if audioop.findmax(data[1], 1) != 2:
- return 0
- return 1
-
-def testgetsample(data):
- if verbose:
- print('getsample')
- for i in range(3):
- if audioop.getsample(data[0], 1, i) != i or \
- audioop.getsample(data[1], 2, i) != i or \
- audioop.getsample(data[2], 4, i) != i:
- return 0
- return 1
-
-def testone(name, data):
- try:
- func = eval('test'+name)
- except NameError:
- print('No test found for audioop.'+name+'()')
- return
- try:
- rv = func(data)
- except Exception as e:
- print('Test FAILED for audioop.'+name+'() (with %s)' % repr(e))
- return
- if not rv:
- print('Test FAILED for audioop.'+name+'()')
-
-def test_main():
- data = [gendata1(), gendata2(), gendata4()]
- names = dir(audioop)
- # We know there is a routine 'add'
- routines = []
- for n in names:
- if type(eval('audioop.'+n)) == type(audioop.add):
- routines.append(n)
- for n in routines:
- testone(n, data)
+data = [gendata1(), gendata2(), gendata4()]
+
+
+class TestAudioop(unittest.TestCase):
+
+ def test_max(self):
+ self.assertEqual(audioop.max(data[0], 1), 2)
+ self.assertEqual(audioop.max(data[1], 2), 2)
+ self.assertEqual(audioop.max(data[2], 4), 2)
+
+ def test_minmax(self):
+ self.assertEqual(audioop.minmax(data[0], 1), (0, 2))
+ self.assertEqual(audioop.minmax(data[1], 2), (0, 2))
+ self.assertEqual(audioop.minmax(data[2], 4), (0, 2))
+
+ def test_maxpp(self):
+ self.assertEqual(audioop.maxpp(data[0], 1), 0)
+ self.assertEqual(audioop.maxpp(data[1], 2), 0)
+ self.assertEqual(audioop.maxpp(data[2], 4), 0)
+
+ def test_avg(self):
+ self.assertEqual(audioop.avg(data[0], 1), 1)
+ self.assertEqual(audioop.avg(data[1], 2), 1)
+ self.assertEqual(audioop.avg(data[2], 4), 1)
+
+ def test_avgpp(self):
+ self.assertEqual(audioop.avgpp(data[0], 1), 0)
+ self.assertEqual(audioop.avgpp(data[1], 2), 0)
+ self.assertEqual(audioop.avgpp(data[2], 4), 0)
+
+ def test_rms(self):
+ self.assertEqual(audioop.rms(data[0], 1), 1)
+ self.assertEqual(audioop.rms(data[1], 2), 1)
+ self.assertEqual(audioop.rms(data[2], 4), 1)
+
+ def test_cross(self):
+ self.assertEqual(audioop.cross(data[0], 1), 0)
+ self.assertEqual(audioop.cross(data[1], 2), 0)
+ self.assertEqual(audioop.cross(data[2], 4), 0)
+
+ def test_add(self):
+ data2 = []
+ for d in data:
+ str = bytearray(len(d))
+ for i,b in enumerate(d):
+ str[i] = 2*b
+ data2.append(str)
+ self.assertEqual(audioop.add(data[0], data[0], 1), data2[0])
+ self.assertEqual(audioop.add(data[1], data[1], 2), data2[1])
+ self.assertEqual(audioop.add(data[2], data[2], 4), data2[2])
+
+ def test_bias(self):
+ # Note: this test assumes that avg() works
+ d1 = audioop.bias(data[0], 1, 100)
+ d2 = audioop.bias(data[1], 2, 100)
+ d4 = audioop.bias(data[2], 4, 100)
+ self.assertEqual(audioop.avg(d1, 1), 101)
+ self.assertEqual(audioop.avg(d2, 2), 101)
+ self.assertEqual(audioop.avg(d4, 4), 101)
+
+ def test_lin2lin(self):
+ # too simple: we test only the size
+ for d1 in data:
+ for d2 in data:
+ got = len(d1)//3
+ wtd = len(d2)//3
+ self.assertEqual(len(audioop.lin2lin(d1, got, wtd)), len(d2))
+
+ def test_adpcm2lin(self):
+ # Very cursory test
+ self.assertEqual(audioop.adpcm2lin(b'\0\0', 1, None), (b'\0\0\0\0', (0,0)))
+
+ def test_lin2adpcm(self):
+ # Very cursory test
+ self.assertEqual(audioop.lin2adpcm(b'\0\0\0\0', 1, None), (b'\0\0', (0,0)))
+
+ def test_lin2alaw(self):
+ self.assertEqual(audioop.lin2alaw(data[0], 1), b'\xd5\xc5\xf5')
+ self.assertEqual(audioop.lin2alaw(data[1], 2), b'\xd5\xd5\xd5')
+ self.assertEqual(audioop.lin2alaw(data[2], 4), b'\xd5\xd5\xd5')
+
+ def test_alaw2lin(self):
+ # Cursory
+ d = audioop.lin2alaw(data[0], 1)
+ self.assertEqual(audioop.alaw2lin(d, 1), data[0])
+
+ def test_lin2ulaw(self):
+ self.assertEqual(audioop.lin2ulaw(data[0], 1), b'\xff\xe7\xdb')
+ self.assertEqual(audioop.lin2ulaw(data[1], 2), b'\xff\xff\xff')
+ self.assertEqual(audioop.lin2ulaw(data[2], 4), b'\xff\xff\xff')
+
+ def test_ulaw2lin(self):
+ # Cursory
+ d = audioop.lin2ulaw(data[0], 1)
+ self.assertEqual(audioop.ulaw2lin(d, 1), data[0])
+
+ def test_mul(self):
+ data2 = []
+ for d in data:
+ str = bytearray(len(d))
+ for i,b in enumerate(d):
+ str[i] = 2*b
+ data2.append(str)
+ self.assertEqual(audioop.mul(data[0], 1, 2), data2[0])
+ self.assertEqual(audioop.mul(data[1],2, 2), data2[1])
+ self.assertEqual(audioop.mul(data[2], 4, 2), data2[2])
+
+ def test_ratecv(self):
+ state = None
+ d1, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
+ d2, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
+ self.assertEqual(d1 + d2, b'\000\000\001\001\002\001\000\000\001\001\002')
+
+ def test_reverse(self):
+ self.assertEqual(audioop.reverse(data[0], 1), b'\2\1\0')
+
+ def test_tomono(self):
+ data2 = bytearray()
+ for d in data[0]:
+ data2.append(d)
+ data2.append(d)
+ self.assertEqual(audioop.tomono(data2, 1, 0.5, 0.5), data[0])
+
+ def test_tostereo(self):
+ data2 = bytearray()
+ for d in data[0]:
+ data2.append(d)
+ data2.append(d)
+ self.assertEqual(audioop.tostereo(data[0], 1, 1, 1), data2)
+
+ def test_findfactor(self):
+ self.assertEqual(audioop.findfactor(data[1], data[1]), 1.0)
+
+ def test_findfit(self):
+ self.assertEqual(audioop.findfit(data[1], data[1]), (0, 1.0))
+
+ def test_findmax(self):
+ self.assertEqual(audioop.findmax(data[1], 1), 2)
+
+ def test_getsample(self):
+ for i in range(3):
+ self.assertEqual(audioop.getsample(data[0], 1, i), i)
+ self.assertEqual(audioop.getsample(data[1], 2, i), i)
+ self.assertEqual(audioop.getsample(data[2], 4, i), i)
+def test_main():
+ run_unittest(TestAudioop)
if __name__ == '__main__':
test_main()
self.failUnless(isinstance(sample(), Set))
self.failUnless(issubclass(sample, Set))
+ def test_hash_Set(self):
+ class OneTwoThreeSet(Set):
+ def __init__(self):
+ self.contents = [1, 2, 3]
+ def __contains__(self, x):
+ return x in self.contents
+ def __len__(self):
+ return len(self.contents)
+ def __iter__(self):
+ return iter(self.contents)
+ def __hash__(self):
+ return self._hash()
+ a, b = OneTwoThreeSet(), OneTwoThreeSet()
+ self.failUnless(hash(a) == hash(b))
+
def test_MutableSet(self):
self.failUnless(isinstance(set(), MutableSet))
self.failUnless(issubclass(set, MutableSet))
self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
self.assertEqual(str(Decimal(' -7.89')), '-7.89')
+ #but alternate unicode digits should not
+ self.assertEqual(str(Decimal('\uff11')), 'NaN')
+
def test_explicit_from_tuples(self):
#zero
def testStringification(self):
self.assertEquals("Fraction(7, 3)", repr(F(7, 3)))
+ self.assertEquals("Fraction(6283185307, 2000000000)",
+ repr(F('3.1415926535')))
+ self.assertEquals("Fraction(-1, 100000000000000000000)",
+ repr(F(1, -10**20)))
self.assertEquals("7/3", str(F(7, 3)))
self.assertEquals("7", str(F(7, 1)))
def sqr(x, wait=0.0):
time.sleep(wait)
return x*x
-"""
class _TestPool(BaseTestCase):
def test_apply(self):
join = TimingWrapper(self.pool.join)
join()
self.assertTrue(join.elapsed < 0.2)
-"""
#
# Test that manager has expected number of shared objects left
#
self.assertRaises(ValueError, a.send_bytes, msg, 4, -1)
-"""
class _TestListenerClient(BaseTestCase):
ALLOWED_TYPES = ('processes', 'threads')
self.assertEqual(conn.recv(), 'hello')
p.join()
l.close()
-"""
#
# Test of sending connection and socket objects between processes
#
multiprocessing.get_logger().setLevel(LOG_LEVEL)
- #ProcessesMixin.pool = multiprocessing.Pool(4)
- #ThreadsMixin.pool = multiprocessing.dummy.Pool(4)
- #ManagerMixin.manager.__init__()
- #ManagerMixin.manager.start()
- #ManagerMixin.pool = ManagerMixin.manager.Pool(4)
+ ProcessesMixin.pool = multiprocessing.Pool(4)
+ ThreadsMixin.pool = multiprocessing.dummy.Pool(4)
+ ManagerMixin.manager.__init__()
+ ManagerMixin.manager.start()
+ ManagerMixin.pool = ManagerMixin.manager.Pool(4)
testcases = (
- sorted(testcases_processes.values(), key=lambda tc:tc.__name__) #+
- #sorted(testcases_threads.values(), key=lambda tc:tc.__name__) +
- #sorted(testcases_manager.values(), key=lambda tc:tc.__name__)
+ sorted(testcases_processes.values(), key=lambda tc:tc.__name__) +
+ sorted(testcases_threads.values(), key=lambda tc:tc.__name__) +
+ sorted(testcases_manager.values(), key=lambda tc:tc.__name__)
)
loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase
suite = unittest.TestSuite(loadTestsFromTestCase(tc) for tc in testcases)
run(suite)
- #ThreadsMixin.pool.terminate()
- #ProcessesMixin.pool.terminate()
- #ManagerMixin.pool.terminate()
- #ManagerMixin.manager.shutdown()
+ ThreadsMixin.pool.terminate()
+ ProcessesMixin.pool.terminate()
+ ManagerMixin.pool.terminate()
+ ManagerMixin.manager.shutdown()
- #del ProcessesMixin.pool, ThreadsMixin.pool, ManagerMixin.pool
+ del ProcessesMixin.pool, ThreadsMixin.pool, ManagerMixin.pool
def main():
test_main(unittest.TextTestRunner(verbosity=2).run)
DATA
__author__ = 'Benjamin Peterson'
__credits__ = 'Nobody'
- __package__ = None
__version__ = '1.2.3.4'
VERSION
<tr><td bgcolor="#55aa55"><tt> </tt></td><td> </td>
<td width="100%%"><strong>__author__</strong> = 'Benjamin Peterson'<br>
<strong>__credits__</strong> = 'Nobody'<br>
-<strong>__package__</strong> = None<br>
<strong>__version__</strong> = '1.2.3.4'</td></tr></table><p>
<table width="100%%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#7799ee">
Tom Bridgman
Richard Brodie
Daniel Brotsky
+Jean Brouwers
Gary S. Brown
Oleg Broytmann
Dave Brueck
PyObject *key;
long hash;
- if (dictresize(mp, PySet_GET_SIZE(seq)))
+ if (dictresize(mp, Py_SIZE(seq)))
return NULL;
while (_PyDict_Next(seq, &pos, &key, &oldvalue, &hash)) {
HAVE_BROKEN_SEM_UNLINK=1
)
libraries = []
+
+ elif platform in ('freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
+ # FreeBSD's P1003.1b semaphore support is very experimental
+ # and has many known problems. (as of June 2008)
+ macros = dict( # FreeBSD
+ HAVE_SEM_OPEN=0,
+ HAVE_SEM_TIMEDWAIT=0,
+ HAVE_FD_TRANSFER=1,
+ )
+ libraries = []
+
else: # Linux and other unices
macros = dict(
HAVE_SEM_OPEN=1,
projects / python / commitdiff