Python StringIO.getvalue方法代码示例

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def test_line_separator(self):
     output = StringIO()
     writer = HtmlWriter(output)
     writer.start('b')
     writer.end('b')
     writer.element('i')
     assert_equal(repr(output.getvalue()), repr('<b>\n</b>\n<i></i>\n'))

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
def get_lines(suite=(), strings=(), basemillis=100, start_block='',
              end_block='', split_threshold=9999, min_level='INFO'):
    output = StringIO()
    data = JsExecutionResult(suite, None, None, strings, basemillis, min_level=min_level)
    writer = JsResultWriter(output, start_block, end_block, split_threshold)
    writer.write(data, settings={})
    return output.getvalue().splitlines()

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def test_dont_register_signal_handlers_then_run_on_thread(self):
     stream = StringIO()
     thread = threading.Thread(target=run_without_outputs, args=(self.data,),
                               kwargs=dict(stdout=stream, stderr=stream))
     thread.start()
     thread.join()
     output = stream.getvalue()
     assert_true('ERROR' not in output.upper(), 'Errors:\n%s' % output)

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def test_json_dump_mapping(self):
     output = StringIO()
     dumper = JsonDumper(output)
     mapped1 = object()
     mapped2 = "string"
     dumper.dump([mapped1, [mapped2, {mapped2: mapped1}]], mapping={mapped1: "1", mapped2: "a"})
     assert_equal(output.getvalue(), "[1,[a,{a:1}]]")
     assert_raises(ValueError, dumper.dump, [mapped1])

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
    def test_configuring_number_of_separating_spaces(self):
        output = StringIO()
        create_test_case_file().save(output=output, txt_separating_spaces=8)
        expected = """\
*** test case ***         some        and other
A test                    A kw        an arg
"""
        assert_equals(repr(expected), repr(output.getvalue()))

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
    def test_end_of_line_whitespace_is_removed(self):
        output = StringIO()
        create_test_case_file().save(output=output)
        expected = """\
*** test case ***     some    and other
A test                A kw    an arg
"""
        assert_equals(repr(expected), repr(output.getvalue()))

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
class _MockLogger(object):
    def __init__(self):
        self._output = StringIO()

    def message(self, msg):
        self._output.write(msg.message)

    def value(self):
        return self._output.getvalue()

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def test_json_dump_mapping(self):
     output = StringIO()
     dumper = JsonDumper(output)
     mapped1 = object()
     mapped2 = 'string'
     dumper.dump([mapped1, [mapped2, {mapped2: mapped1}]],
                 mapping={mapped1: '1', mapped2: 'a'})
     assert_equal(output.getvalue(), '[1,[a,{a:1}]]')
     assert_raises(ValueError, dumper.dump, [mapped1])

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
class ClosableOutput(object):

    def __init__(self, path):
        self._output = StringIO()
        self._path = path

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

    def write(self, data):
        self._output.write(data)

    def close(self):
        self.value = self._output.getvalue()
        self._output.close()

    def __str__(self):
        return self._path

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def _dump(self, data):
     output = StringIO()
     JsonDumper(output).dump(data)
     return output.getvalue()

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def _add_long_step_and_save(self, format):
     data = create_test_case_file()
     data.testcase_table.tests[0].add_step(["A kw", "1", "2", "3", "4", "6", "7", "8"])
     output = StringIO()
     data.save(format=format, output=output)
     return output.getvalue().strip()

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
class TestHtmlWriter(unittest.TestCase):

    def setUp(self):
        self.output = StringIO()
        self.writer = HtmlWriter(self.output)

    def test_start(self):
        self.writer.start('r')
        self._verify('<r>\n')

    def test_start_without_newline(self):
        self.writer.start('robot', newline=False)
        self._verify('<robot>')

    def test_start_with_attribute(self):
        self.writer.start('robot', {'name': 'Suite1'}, False)
        self._verify('<robot name="Suite1">')

    def test_start_with_attributes(self):
        self.writer.start('test', {'class': '123', 'x': 'y', 'a': 'z'})
        self._verify('<test a="z" class="123" x="y">\n')

    def test_start_with_non_ascii_attributes(self):
        self.writer.start('test', {'name': u'\xA7', u'\xE4': u'\xA7'})
        self._verify(u'<test name="\xA7" \xE4="\xA7">\n')

    def test_start_with_quotes_in_attribute_value(self):
        self.writer.start('x', {'q':'"', 'qs': '""""', 'a': "'"}, False)
        self._verify('<x a="\'" q="&quot;" qs="&quot;&quot;&quot;&quot;">')

    def test_start_with_html_in_attribute_values(self):
        self.writer.start('x', {'1':'<', '2': '&', '3': '</html>'}, False)
        self._verify('<x 1="&lt;" 2="&amp;" 3="&lt;/html&gt;">')

    def test_start_with_newlines_and_tabs_in_attribute_values(self):
        self.writer.start('x', {'1':'\n', '3': 'A\nB\tC', '2': '\t', '4': '\r\n'}, False)
        self._verify('<x 1="&#10;" 2="&#09;" 3="A&#10;B&#09;C" 4="&#13;&#10;">')

    def test_end(self):
        self.writer.start('robot', newline=False)
        self.writer.end('robot')
        self._verify('<robot></robot>\n')

    def test_end_without_newline(self):
        self.writer.start('robot', newline=False)
        self.writer.end('robot', newline=False)
        self._verify('<robot></robot>')

    def test_end_alone(self):
        self.writer.end('suite', newline=False)
        self._verify('</suite>')

    def test_content(self):
        self.writer.start('robot')
        self.writer.content('Hello world!')
        self._verify('<robot>\nHello world!')

    def test_content_with_non_ascii_data(self):
        self.writer.start('robot', newline=False)
        self.writer.content(u'Circle is 360\xB0. ')
        self.writer.content(u'Hyv\xE4\xE4 \xFC\xF6t\xE4!')
        self.writer.end('robot', newline=False)
        expected = u'Circle is 360\xB0. Hyv\xE4\xE4 \xFC\xF6t\xE4!'
        self._verify('<robot>%s</robot>' % expected)

    def test_multiple_content(self):
        self.writer.start('robot')
        self.writer.content('Hello world!')
        self.writer.content('Hi again!')
        self._verify('<robot>\nHello world!Hi again!')

    def test_content_with_chars_needing_escaping(self):
        self.writer.content('Me, "Myself" & I > U')
        self._verify('Me, "Myself" &amp; I &gt; U')

    def test_content_alone(self):
        self.writer.content('hello')
        self._verify('hello')

    def test_none_content(self):
        self.writer.start('robot')
        self.writer.content(None)
        self.writer.content('')
        self._verify('<robot>\n')

    def test_element(self):
        self.writer.element('div', 'content', {'id': '1'})
        self.writer.element('i', newline=False)
        self._verify('<div id="1">content</div>\n<i></i>')

    def test_line_separator(self):
        output = StringIO()
        writer = HtmlWriter(output)
        writer.start('b')
        writer.end('b')
        writer.element('i')
        assert_equal(repr(output.getvalue()), repr('<b>\n</b>\n<i></i>\n'))

    def test_non_ascii(self):
        self.output = StringIO()
#.........这里部分代码省略.........

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def test_combining_results(self):
     output = StringIO()
     writer = TestableOutputWriter(output)
     ExecutionResult(GOLDEN_XML, GOLDEN_XML).visit(writer)
     self._assert_xml_content(self._xml_lines(output.getvalue()), self._xml_lines(GOLDEN_XML_TWICE))

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def _xml_lines(self, text):
     with ETSource(text) as source:
         tree = ET.parse(source)
     output = StringIO()
     tree.write(output)
     return output.getvalue().splitlines()

# 需要导入模块: from robot.utils import StringIO [as 别名]
# 或者: from robot.utils.StringIO import getvalue [as 别名]
 def test_single_result_serialization(self):
     output = StringIO()
     writer = TestableOutputWriter(output)
     ExecutionResult(GOLDEN_XML).visit(writer)
     self._assert_xml_content(self._xml_lines(output.getvalue()), self._xml_lines(GOLDEN_XML))