def test_comment8(self):
source = """A convenience factory for creating Records.
Args:
**kwargs: Each keyword argument will be used to initialise an
attribute with the same name as the argument and the given
value.
Returns:
A Record which has a named attribute for each of the keyword arguments.
"""
expected = """A convenience factory for creating Records.
:param \*\*kwargs: Each keyword argument will be used to initialise an
attribute with the same name as the argument and the given
value.
:returns: A Record which has a named attribute for each of the keyword arguments.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment8(self):
source = """A convenience factory for creating Records.
Args:
**kwargs: Each keyword argument will be used to initialise an
attribute with the same name as the argument and the given
value.
Returns:
A Record which has a named attribute for each of the keyword arguments.
"""
expected = """A convenience factory for creating Records.
:param \*\*kwargs: Each keyword argument will be used to initialise an
attribute with the same name as the argument and the given
value.
:returns: A Record which has a named attribute for each of the keyword arguments.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment5(self):
source_lines = [u'An empty Queryable.',
u'',
u'Note: The same empty instance will be returned each time.',
u'',
u'Returns: A Queryable over an empty sequence.',
u'']
expected = """An empty Queryable.
.. note::
The same empty instance will be returned each time.
:returns: A Queryable over an empty sequence.
"""
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment9(self):
source_lines = [
u'Parse a single line of a tree to determine depth and node.', u'',
u'Args:', u' This line is missing an argument name.', u' ',
u'Returns:',
u' A 2-tuple containing the tree 0 based tree depth as the first',
u' element and the node description as the second element.',
u'', u'Raises:',
u' ValueError: If line does not have the expected form.', u''
]
self.assertRaises(HieroglyphError,
lambda: parse_hieroglyph_text(source_lines))
def test_comment2(self):
source = """Determine if all elements in the source sequence satisfy a condition.
All of the source sequence will be consumed.
Note: This method uses immediate execution.
Args:
predicate: An optional single argument function used to test each
elements. If omitted, the bool() function is used resulting in
the elements being tested directly.
Returns:
True if all elements in the sequence meet the predicate condition,
otherwise False.
Raises:
ValueError: If the Queryable is closed()
TypeError: If predicate is not callable.
"""
expected = """Determine if all elements in the source sequence satisfy a condition.
All of the source sequence will be consumed.
.. note::
This method uses immediate execution.
:param predicate: An optional single argument function used to test each
elements. If omitted, the bool() function is used resulting in
the elements being tested directly.
:returns: True if all elements in the sequence meet the predicate condition,
otherwise False.
:raises:
* ValueError - If the Queryable is closed()
* TypeError - If predicate is not callable.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment2(self):
source = """Determine if all elements in the source sequence satisfy a condition.
All of the source sequence will be consumed.
Note: This method uses immediate execution.
Args:
predicate: An optional single argument function used to test each
elements. If omitted, the bool() function is used resulting in
the elements being tested directly.
Returns:
True if all elements in the sequence meet the predicate condition,
otherwise False.
Raises:
ValueError: If the Queryable is closed()
TypeError: If predicate is not callable.
"""
expected = """Determine if all elements in the source sequence satisfy a condition.
All of the source sequence will be consumed.
.. note::
This method uses immediate execution.
:param predicate: An optional single argument function used to test each
elements. If omitted, the bool() function is used resulting in
the elements being tested directly.
:returns: True if all elements in the sequence meet the predicate condition,
otherwise False.
:raises:
* ValueError - If the Queryable is closed()
* TypeError - If predicate is not callable.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment9(self):
source_lines = [u'Parse a single line of a tree to determine depth and node.',
u'',
u'Args:',
u' This line is missing an argument name.',
u' ',
u'Returns:',
u' A 2-tuple containing the tree 0 based tree depth as the first',
u' element and the node description as the second element.',
u'',
u'Raises:',
u' ValueError: If line does not have the expected form.',
u'']
self.assertRaises(HieroglyphError, lambda: parse_hieroglyph_text(source_lines))
def test_comment12(self):
source = """Determine if all elements in the source sequence satisfy a condition.
All of the source sequence will be consumed.
Note: This method uses immediate execution.
Args:
predicate: An optional single argument function used to test each
elements. If omitted, the bool() function is used resulting in
the elements being tested directly.
Returns:
True if all elements in the sequence meet the predicate condition,
otherwise False.
Raises:
This is not a proper exception description
"""
source_lines = source.splitlines()
self.assertRaises(HieroglyphError, lambda: parse_hieroglyph_text(source_lines))
def test_comment12(self):
source = """Determine if all elements in the source sequence satisfy a condition.
All of the source sequence will be consumed.
Note: This method uses immediate execution.
Args:
predicate: An optional single argument function used to test each
elements. If omitted, the bool() function is used resulting in
the elements being tested directly.
Returns:
True if all elements in the sequence meet the predicate condition,
otherwise False.
Raises:
This is not a proper exception description
"""
source_lines = source.splitlines()
self.assertRaises(HieroglyphError,
lambda: parse_hieroglyph_text(source_lines))
def test_comment5(self):
source_lines = [
u'An empty Queryable.', u'',
u'Note: The same empty instance will be returned each time.', u'',
u'Returns: A Queryable over an empty sequence.', u''
]
expected = """An empty Queryable.
.. note::
The same empty instance will be returned each time.
:returns: A Queryable over an empty sequence.
"""
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment1(self):
source = """Fetches rows from a Bigtable.
This is a continuation of the opening paragraph.
Retrieves rows pertaining to the given keys from the Table instance
represented by big_table. Silly things may happen if
other_silly_variable is not None.
Args:
big_table: An open Bigtable Table instance.
keys: A sequence of strings representing the key of each table row
to fetch.
other_silly_variable (str): Another optional variable, that has a much
longer name than the other args, and which does nothing.
Returns:
A dict mapping keys to the corresponding table row data
fetched. Each row is represented as a tuple of strings. For
example:
{'Serak': ('Rigel VII', 'Preparer'),
'Zim': ('Irk', 'Invader'),
'Lrrr': ('Omicron Persei 8', 'Emperor')}
If a key from the keys argument is missing from the dictionary,
then that row was not found in the table.
Raises:
IOError: An error occurred accessing the bigtable.Table object.
"""
expected = """ Fetches rows from a Bigtable.
This is a continuation of the opening paragraph.
Retrieves rows pertaining to the given keys from the Table instance
represented by big_table. Silly things may happen if
other_silly_variable is not None.
:param big_table: An open Bigtable Table instance.
:param keys: A sequence of strings representing the key of each table row
to fetch.
:param other_silly_variable: Another optional variable, that has a much
longer name than the other args, and which does nothing.
:type other_silly_variable: str
:returns: A dict mapping keys to the corresponding table row data
fetched. Each row is represented as a tuple of strings. For
example:
{'Serak': ('Rigel VII', 'Preparer'),
'Zim': ('Irk', 'Invader'),
'Lrrr': ('Omicron Persei 8', 'Emperor')}
If a key from the keys argument is missing from the dictionary,
then that row was not found in the table.
:raises:
IOError - An error occurred accessing the bigtable.Table object.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment11(self):
source = """Projects each element of a sequence to an intermediate new sequence,
flattens the resulting sequences into one sequence and optionally
transforms the flattened sequence using a selector function.
Warning: This method may explode at short notice.
Args:
collection_selector: A unary function mapping each element of the
source iterable into an intermediate sequence. The single
argument of the collection_selector is the value of an element
from the source sequence. The return value should be an
iterable derived from that element value. The default
collection_selector, which is the identity function, assumes
that each element of the source sequence is itself iterable.
result_selector: An optional unary function mapping the elements in
the flattened intermediate sequence to corresponding elements
of the result sequence. The single argument of the
result_selector is the value of an element from the flattened
intermediate sequence. The return value should be the
corresponding value in the result sequence. The default
result_selector is the identity function.
Returns:
A Queryable over a generated sequence whose elements are the result
of applying the one-to-many collection_selector to each element of
the source sequence, concatenating the results into an intermediate
sequence, and then mapping each of those elements through the
result_selector into the result sequence.
Raises:
ValueError: If this Queryable has been closed.
TypeError: If either collection_selector or result_selector are not
callable.
"""
expected = """ Projects each element of a sequence to an intermediate new sequence,
flattens the resulting sequences into one sequence and optionally
transforms the flattened sequence using a selector function.
.. warning::
This method may explode at short notice.
:param collection_selector: A unary function mapping each element of the
source iterable into an intermediate sequence. The single
argument of the collection_selector is the value of an element
from the source sequence. The return value should be an
iterable derived from that element value. The default
collection_selector, which is the identity function, assumes
that each element of the source sequence is itself iterable.
:param result_selector: An optional unary function mapping the elements in
the flattened intermediate sequence to corresponding elements
of the result sequence. The single argument of the
result_selector is the value of an element from the flattened
intermediate sequence. The return value should be the
corresponding value in the result sequence. The default
result_selector is the identity function.
:returns: A Queryable over a generated sequence whose elements are the result
of applying the one-to-many collection_selector to each element of
the source sequence, concatenating the results into an intermediate
sequence, and then mapping each of those elements through the
result_selector into the result sequence.
:raises:
* ValueError - If this Queryable has been closed.
* TypeError - If either collection_selector or result_selector are not
callable.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment10(self):
source = """
Execute the command described by concatenating the string function arguments
with the p4 -s global scripting flag and return the results in a dictionary.
For example, to run the command::
p4 -s fstat -T depotFile foo.h
call::
p4('fstat', '-T', 'depotFile', 'foo.h')
Args:
args: The arguments to the p4 command as a list of objects which will
be converted to strings.
Returns:
A dictionary of lists where each key in the dictionary is the field name
from the command output, and each value is a list of output lines in
order.
Raises:
PerforceError: If the command could not be run or if the command
reported an error.
"""
expected = """
Execute the command described by concatenating the string function arguments
with the p4 -s global scripting flag and return the results in a dictionary.
For example, to run the command::
p4 -s fstat -T depotFile foo.h
call::
p4('fstat', '-T', 'depotFile', 'foo.h')
:param args: The arguments to the p4 command as a list of objects which will
be converted to strings.
:returns: A dictionary of lists where each key in the dictionary is the field name
from the command output, and each value is a list of output lines in
order.
:raises:
PerforceError - If the command could not be run or if the command
reported an error.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment1(self):
source = """Fetches rows from a Bigtable.
This is a continuation of the opening paragraph.
Retrieves rows pertaining to the given keys from the Table instance
represented by big_table. Silly things may happen if
other_silly_variable is not None.
Args:
big_table: An open Bigtable Table instance.
keys: A sequence of strings representing the key of each table row
to fetch.
other_silly_variable (str): Another optional variable, that has a much
longer name than the other args, and which does nothing.
Returns:
A dict mapping keys to the corresponding table row data
fetched. Each row is represented as a tuple of strings. For
example:
{'Serak': ('Rigel VII', 'Preparer'),
'Zim': ('Irk', 'Invader'),
'Lrrr': ('Omicron Persei 8', 'Emperor')}
If a key from the keys argument is missing from the dictionary,
then that row was not found in the table.
Raises:
IOError: An error occurred accessing the bigtable.Table object.
"""
expected = """ Fetches rows from a Bigtable.
This is a continuation of the opening paragraph.
Retrieves rows pertaining to the given keys from the Table instance
represented by big_table. Silly things may happen if
other_silly_variable is not None.
:param big_table: An open Bigtable Table instance.
:param keys: A sequence of strings representing the key of each table row
to fetch.
:param other_silly_variable: Another optional variable, that has a much
longer name than the other args, and which does nothing.
:type other_silly_variable: str
:returns: A dict mapping keys to the corresponding table row data
fetched. Each row is represented as a tuple of strings. For
example:
{'Serak': ('Rigel VII', 'Preparer'),
'Zim': ('Irk', 'Invader'),
'Lrrr': ('Omicron Persei 8', 'Emperor')}
If a key from the keys argument is missing from the dictionary,
then that row was not found in the table.
:raises:
IOError - An error occurred accessing the bigtable.Table object.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment11(self):
source = """Projects each element of a sequence to an intermediate new sequence,
flattens the resulting sequences into one sequence and optionally
transforms the flattened sequence using a selector function.
Warning: This method may explode at short notice.
Args:
collection_selector: A unary function mapping each element of the
source iterable into an intermediate sequence. The single
argument of the collection_selector is the value of an element
from the source sequence. The return value should be an
iterable derived from that element value. The default
collection_selector, which is the identity function, assumes
that each element of the source sequence is itself iterable.
result_selector: An optional unary function mapping the elements in
the flattened intermediate sequence to corresponding elements
of the result sequence. The single argument of the
result_selector is the value of an element from the flattened
intermediate sequence. The return value should be the
corresponding value in the result sequence. The default
result_selector is the identity function.
Returns:
A Queryable over a generated sequence whose elements are the result
of applying the one-to-many collection_selector to each element of
the source sequence, concatenating the results into an intermediate
sequence, and then mapping each of those elements through the
result_selector into the result sequence.
Raises:
ValueError: If this Queryable has been closed.
TypeError: If either collection_selector or result_selector are not
callable.
"""
expected = """ Projects each element of a sequence to an intermediate new sequence,
flattens the resulting sequences into one sequence and optionally
transforms the flattened sequence using a selector function.
.. warning::
This method may explode at short notice.
:param collection_selector: A unary function mapping each element of the
source iterable into an intermediate sequence. The single
argument of the collection_selector is the value of an element
from the source sequence. The return value should be an
iterable derived from that element value. The default
collection_selector, which is the identity function, assumes
that each element of the source sequence is itself iterable.
:param result_selector: An optional unary function mapping the elements in
the flattened intermediate sequence to corresponding elements
of the result sequence. The single argument of the
result_selector is the value of an element from the flattened
intermediate sequence. The return value should be the
corresponding value in the result sequence. The default
result_selector is the identity function.
:returns: A Queryable over a generated sequence whose elements are the result
of applying the one-to-many collection_selector to each element of
the source sequence, concatenating the results into an intermediate
sequence, and then mapping each of those elements through the
result_selector into the result sequence.
:raises:
* ValueError - If this Queryable has been closed.
* TypeError - If either collection_selector or result_selector are not
callable.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)
def test_comment10(self):
source = """
Execute the command described by concatenating the string function arguments
with the p4 -s global scripting flag and return the results in a dictionary.
For example, to run the command::
p4 -s fstat -T depotFile foo.h
call::
p4('fstat', '-T', 'depotFile', 'foo.h')
Args:
args: The arguments to the p4 command as a list of objects which will
be converted to strings.
Returns:
A dictionary of lists where each key in the dictionary is the field name
from the command output, and each value is a list of output lines in
order.
Raises:
PerforceError: If the command could not be run or if the command
reported an error.
"""
expected = """
Execute the command described by concatenating the string function arguments
with the p4 -s global scripting flag and return the results in a dictionary.
For example, to run the command::
p4 -s fstat -T depotFile foo.h
call::
p4('fstat', '-T', 'depotFile', 'foo.h')
:param args: The arguments to the p4 command as a list of objects which will
be converted to strings.
:returns: A dictionary of lists where each key in the dictionary is the field name
from the command output, and each value is a list of output lines in
order.
:raises:
PerforceError - If the command could not be run or if the command
reported an error.
"""
source_lines = source.splitlines()
actual_lines = parse_hieroglyph_text(source_lines)
expected_lines = expected.splitlines()
self.assertEqual(len(actual_lines), len(expected_lines))
for actual_line, result_line in zip(actual_lines, expected_lines):
if len(actual_line.strip()) == 0:
self.assertTrue(len(result_line.strip()) == 0)
else:
self.assertEqual(actual_line, result_line)