Python utils.StringIO类代码示例

 def _read_html(self, doctree, rawdata):
     htmlfile = StringIO()
     htmlfile.write(publish_from_doctree(
         doctree, writer_name='html',
         settings_overrides={'output_encoding': 'UTF-8'}))
     htmlfile.seek(0)
     return HtmlReader().read(htmlfile, rawdata)

 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 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()

    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()))

    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()))

 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])

 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)

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()

 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])

 def test_non_ascii(self):
     self.output = StringIO()
     writer = HtmlWriter(self.output)
     writer.start(u'p', attrs={'name': u'hyv\xe4\xe4'}, newline=False)
     writer.content(u'y\xf6')
     writer.element('i', u't\xe4', newline=False)
     writer.end('p', newline=False)
     self._verify(u'<p name="hyv\xe4\xe4">y\xf6<i>t\xe4</i></p>')

 def __init__(self, stdout=True):
     if stdout:
         self._original = sys.stdout
         self._set_stream = self._set_stdout
     else:
         self._original = sys.stderr
         self._set_stream = self._set_stderr
     self._stream = StringIO()
     self._set_stream(self._stream)

class PythonCapturer(object):

    def __init__(self, stdout=True):
        if stdout:
            self._original = sys.stdout
            self._set_stream = self._set_stdout
        else:
            self._original = sys.stderr
            self._set_stream = self._set_stderr
        self._stream = StringIO()
        self._set_stream(self._stream)

    def _set_stdout(self, stream):
        sys.stdout = stream

    def _set_stderr(self, stream):
        sys.stderr = stream

    def release(self):
        # Original stream must be restored before closing the current
        self._set_stream(self._original)
        try:
            return self._get_value(self._stream)
        finally:
            self._stream.close()
            self._avoid_at_exit_errors(self._stream)

    def _get_value(self, stream):
        try:
            return decode_output(stream.getvalue())
        except UnicodeError:
            # Error occurs if non-ASCII chars logged both as str and unicode.
            stream.buf = decode_output(stream.buf)
            stream.buflist = [decode_output(item) for item in stream.buflist]
            return stream.getvalue()

    def _avoid_at_exit_errors(self, stream):
        # Avoid ValueError at program exit when logging module tries to call
        # methods of streams it has intercepted that are already closed.
        # Which methods are called, and does logging silence possible errors,
        # depends on Python/Jython version. For related discussion see
        # http://bugs.python.org/issue6333
        stream.write = lambda s: None
        stream.flush = lambda: None

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

 def test_run_multiple_times_with_different_stdout_and_stderr(self):
     stdout, stderr = StringIO(), StringIO()
     self._run(stdout, stderr)
     self._assert_normal_stdout_stderr_are_empty()
     self._assert_output(stdout, [('My Suite', 2), ('My Test', 1)])
     self._assert_output(stderr, [('Hello, world!', 1)])
     stdout.close(); stderr.close()
     output = StringIO()
     self._run(output, output, variable='MESSAGE:Hi, again!')
     self._assert_normal_stdout_stderr_are_empty()
     self._assert_output(output, [('My Suite', 2), ('My Test', 1),
                                  ('Hi, again!', 1), ('Hello, world!', 0)])
     output.close()
     self._run(variable='MESSAGE:Last hi!')
     self._assert_output(sys.__stdout__, [('My Suite', 2), ('My Test', 1)])
     self._assert_output(sys.__stderr__, [('Last hi!', 1), ('Hello, world!', 0)])

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