def test_issue4(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.
'''
source_lines = source.splitlines()
try:
parse_cartouche_text(source_lines)
except UnboundLocalError:
self.fail("parse_cartouche_text raised UnboundLocalError")
def test_issue4(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.
'''
source_lines = source.splitlines()
try:
parse_cartouche_text(source_lines)
except UnboundLocalError:
self.fail("parse_cartouche_text raised UnboundLocalError")
def test_issue11(self):
source = """
Raises:
Exception: This is a multi-line
bug.
"""
source_lines = source.splitlines()
parse_cartouche_text(source_lines)
def test_issue2(self):
source = '''
A docstring.
Args:
arg1: Some argument
Returns: Some kind of value.
Raises:
exceptions.SomeError: There was some error.
'''
expected = '''
A docstring.
:param arg1: Some argument
:returns: Some kind of value.
:raises:
exceptions.SomeError - There was some error.
'''
source_lines = source.splitlines()
actual_lines = parse_cartouche_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_cartouche_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_comment15(self):
source = """A well.
A well represents a borehole which is drilled in order to discover or
delimit a petroleum deposit and/ or to produce petroleum or water for
injection purposes, to inject gas, water or other medium, or to map or
monitor well parameters. A well may have one or several termination points.
(source: Norwegian Petroleum Directorate)
domain.rox respects this definition in the model. The Well
owns its child WellTracks, which in turn own their child Surveys
and LogRuns.
Attributes:
name: The name of the Well, as a string. For each Project, each Well
must be uniquely named.
project: The Project that owns the Well.
rkb_elevation (double): The Rotary Kelly Bushing elevation for
the well.
well_track: The well track.
wellhead: The coordinate location of the wellhead, as a 3-tuple.
Individual elements of this tuple can be extracted as
`well.wellhead.x`, `well.wellhead.y`, and `well.wellhead.z`.
"""
source_lines = source.splitlines()
actual_lines = parse_cartouche_text(source_lines)
pass
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_cartouche_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_comment16(self):
source = """The example docstring for the Example class.
Within this class docstring we can both describe the class, but also
use an attributes heading to list the attributes we expect the
instances of the class to have. There is no specific provision for
distinguishing between class attributes and instance attributes at
this point, so you should make that distinction clear in your
descriptions.
Attributes:
fred: This attribute description just runs to a single line.
shiela: This attribute description is somewhat longer and spans
multiple lines. Subsequent lines are indented one further
level.
jim (int): As with function or method docstrings you can
optionally provide a type in parentheses after the attribute
name and before the colon which separates the name from the
description.
harry: With longer attribute descriptions it can help to separate
the attributes with blank lines. This takes up more room in
the source code but is much easier to read when using the
help() function.
"""
source_lines = source.splitlines()
actual_lines = parse_cartouche_text(source_lines)
pass
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_cartouche_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_cartouche_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_issue2(self):
source = '''
A docstring.
Args:
arg1: Some argument
Returns: Some kind of value.
Raises:
exceptions.SomeError: There was some error.
'''
expected = '''
A docstring.
:param arg1: Some argument
:returns: Some kind of value.
:raises:
exceptions.SomeError - There was some error.
'''
source_lines = source.splitlines()
actual_lines = parse_cartouche_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_comment4(self):
source_lines = [
u('Determine if all elements in the source sequence satisfy a condition.'
),
u(''),
u('All of the source sequence will be consumed.'),
u(''),
u('Note: This method uses immediate execution.'),
u(''),
u('Args:'),
u(' predicate: An optional single argument function used to test each'
),
u(' elements. If omitted, the bool() function is used resulting in'
),
u(' the elements being tested directly.'),
u(''),
u('Returns:'),
u(' True if all elements in the sequence meet the predicate condition,'
),
u(' otherwise False.'),
u(''),
u('Raises:'),
u(' ValueError: If the Queryable is closed()'),
u(' TypeError: If predicate is not callable.'),
u('')
]
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.
"""
actual_lines = parse_cartouche_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_comment17(self):
source = """A test comment including a Usage block.
In this example we test that including a code sample within a usage
block works just fine.
Usage:
foos = [bar for bar in animals if bar is sheep]
print(foos)
"""
source_lines = source.splitlines()
actual_lines = parse_cartouche_text(source_lines)
pass
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_cartouche_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_issue3(self):
lines = [u('Parse a single line of a tree to determine depth and node.'),
u(''),
u('Args:'),
u(' A single line string from a SCons dependency tree.'),
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(CartoucheSyntaxError, lambda: parse_cartouche_text(lines))
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(CartoucheError, lambda: parse_cartouche_text(source_lines))
def test_comment14(self):
source = """Create a predicate which performs an identity comparison of its
argument with a value.
Args:
rhs: (right-hand-side) The value against which the identity test will
be performed.
Returns:
A unary predicate function which determines whether its single
arguments (lhs) has the same identity - that is, is the same object -
as rhs.
"""
source_lines = source.splitlines()
self.assertRaises(CartoucheSyntaxError, lambda: parse_cartouche_text(source_lines))
def test_comment14(self):
source = """Create a predicate which performs an identity comparison of its
argument with a value.
Args:
rhs: (right-hand-side) The value against which the identity test will
be performed.
Returns:
A unary predicate function which determines whether its single
arguments (lhs) has the same identity - that is, is the same object -
as rhs.
"""
source_lines = source.splitlines()
self.assertRaises(CartoucheSyntaxError,
lambda: parse_cartouche_text(source_lines))
def test_issue8(self):
source = '''
A docstring.
Args:
arg1 (some.type): Some argument
'''
expected = '''
A docstring.
:param arg1: Some argument
:type arg1: some.type
'''
source_lines = source.splitlines()
actual_lines = parse_cartouche_text(source_lines)
actual = "\n".join(actual_lines)
self.assertEqual(expected, actual)
def test_issue3(self):
lines = [
u('Parse a single line of a tree to determine depth and node.'),
u(''),
u('Args:'),
u(' A single line string from a SCons dependency tree.'),
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(CartoucheSyntaxError,
lambda: parse_cartouche_text(lines))
def test_issue8(self):
source = '''
A docstring.
Args:
arg1 (some.type): Some argument
'''
expected = '''
A docstring.
:param arg1: Some argument
:type arg1: some.type
'''
source_lines = source.splitlines()
actual_lines = parse_cartouche_text(source_lines)
actual = "\n".join(actual_lines)
self.assertEqual(expected, actual)
def test_comment18(self):
source = """A test comment including a Usage block.
In this example we test that including a code sample within a usage
block works just fine. We you a substantial block of code with lots
of interesting indentation to ensure everything is working fine.
Usage:
result = []
indent = ' ' * self.indent
# Render the param description
description = []
for child in self.children:
child_lines = child.render_rst()
description.extend(child_lines)
name = self.name.replace('*', r'\*')
first_description = description[0].lstrip() if len(description) else ''
if not first_description:
# TODO: Emit a warning about a missing argument description
pass
result.append("{indent}:param {name}: {first_description}".format(
indent=indent, name=name,
first_description=first_description))
result.extend(description[1:])
# If a type was specified render the type
if self.type is not None:
result.append("{indent}:type {name}: {type}".format(indent=indent,
name=self.name, type=self.type))
result.append('')
ensure_terminal_blank(result)
return result
"""
source_lines = source.splitlines()
actual_lines = parse_cartouche_text(source_lines)
pass
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(CartoucheError,
lambda: parse_cartouche_text(source_lines))
def test_issue1(self):
source = """
Bulleted arguments and exceptions.
Args:
* arg1: Argument 1.
* arg2: Argument 2.
Returns:
Some value.
Raises:
* SomeError: If there is a problem.
* AnotherError: If there's some other problem.
"""
expected = """
Bulleted arguments and exceptions.
:param arg1: Argument 1.
:param arg2: Argument 2.
:returns: Some value.
:raises:
* SomeError - If there is a problem.
* AnotherError - If there's some other problem.
"""
with bulleted_args(), bulleted_raises():
source_lines = source.splitlines()
actual_lines = parse_cartouche_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_issue1(self):
source = """
Bulleted arguments and exceptions.
Args:
* arg1: Argument 1.
* arg2: Argument 2.
Returns:
Some value.
Raises:
* SomeError: If there is a problem.
* AnotherError: If there's some other problem.
"""
expected = """
Bulleted arguments and exceptions.
:param arg1: Argument 1.
:param arg2: Argument 2.
:returns: Some value.
:raises:
* SomeError - If there is a problem.
* AnotherError - If there's some other problem.
"""
with bulleted_args(), bulleted_raises():
source_lines = source.splitlines()
actual_lines = parse_cartouche_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_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(CartoucheError, lambda: parse_cartouche_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(CartoucheError,
lambda: parse_cartouche_text(source_lines))
def test_comment13(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.
Yields:
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_cartouche_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_cartouche_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_cartouche_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_cartouche_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_cartouche_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_comment13(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.
Yields:
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_cartouche_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)
