webkitpy: remove webkitpy.common.array_stream
authordpranke@chromium.org <dpranke@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 18 Feb 2012 23:51:52 +0000 (23:51 +0000)
committerdpranke@chromium.org <dpranke@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 18 Feb 2012 23:51:52 +0000 (23:51 +0000)
https://bugs.webkit.org/show_bug.cgi?id=78952

Reviewed by Eric Seidel.

Turns out array_stream didn't really do anything that StringIO
didn't do (at least as of Python 2.6). This change removes it
and updates all of the callers. Where possible, I changed the
test assertions in order to capture the intent more clearly,
e.g., instead of calling self.assertTrue('foo' in stream.get()),
we have self.assertContainsLine(stream, 'foo'), and instead of
self.assertTrue(stream.empty()), we have self.assertEmpty(stream) -
the latter isn't that much more readable, but StringIO doesn't
export an empty() method.

* Scripts/webkitpy/common/array_stream.py: Removed.
* Scripts/webkitpy/common/array_stream_unittest.py: Removed.
* Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:
(passing_run):
(run_and_capture):
(StreamTestingMixin):
(StreamTestingMixin.assertContains):
(StreamTestingMixin.assertContainsLine):
(StreamTestingMixin.assertEmpty):
(StreamTestingMixin.assertNotEmpty):
(LintTest):
(LintTest.test_lint_test_files):
(LintTest.test_lint_test_files__errors):
(MainTest):
(MainTest.test_child_process_1):
(MainTest.test_child_processes_2):
(MainTest.test_child_processes_min):
(MainTest.test_help_printing):
(MainTest.test_hung_thread):
(MainTest.test_no_tests_found):
(MainTest.test_no_tests_found_2):
(MainTest.test_repeat_each_iterations_num_tests):
(MainTest.test_test_list):
(MainTest.test_unexpected_failures):
(MainTest.test_worker_model__inline_with_child_processes):
(MainTest.test_additional_platform_directory):
(RebaselineTest):
(RebaselineTest.assertBaselines):
(RebaselineTest.test_reset_results):
(RebaselineTest.test_missing_results):
(RebaselineTest.test_new_baseline):
* Scripts/webkitpy/layout_tests/views/metered_stream.py:
(MeteredStream.update):
* Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py:
(TestMeteredStream.test_regular):
* Scripts/webkitpy/layout_tests/views/printing_unittest.py:
(TestUtilityFunctions.assertEmpty):
(TestUtilityFunctions):
(TestUtilityFunctions.assertNotEmpty):
(TestUtilityFunctions.assertWritten):
(TestUtilityFunctions.test_configure_logging):
(Testprinter.assertEmpty):
(Testprinter):
(Testprinter.assertNotEmpty):
(Testprinter.assertWritten):
(Testprinter.reset):
(Testprinter.get_printer):
(Testprinter.test_help_printer):
(Testprinter.do_switch_tests.do_helper):
(Testprinter.test_print_one_line_summary):
(Testprinter.test_print_test_result):
(Testprinter.test_print_progress):
(Testprinter.test_write_nothing):
(Testprinter.test_write_misc):
(Testprinter.test_write_everything):
(Testprinter.test_write_verbose):
(Testprinter.test_print_unexpected_results):
* Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py:
(MainTest.assertWritten):
(create_runner):
(test_run_test_set):
(test_run_test_set_kills_drt_per_run):
(test_run_test_set_for_parser_tests):
(test_run_test_set_with_json_output):
(test_run_test_set_with_json_source):
(test_run_test_set_with_multiple_repositories):
(test_upload_json):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@108175 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Tools/ChangeLog
Tools/Scripts/webkitpy/common/array_stream.py [deleted file]
Tools/Scripts/webkitpy/common/array_stream_unittest.py [deleted file]
Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py
Tools/Scripts/webkitpy/layout_tests/views/metered_stream.py
Tools/Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py
Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py
Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py

index 5cf7cc9..162088d 100644 (file)
@@ -1,3 +1,88 @@
+2012-02-18  Dirk Pranke  <dpranke@chromium.org>
+
+        webkitpy: remove webkitpy.common.array_stream
+        https://bugs.webkit.org/show_bug.cgi?id=78952
+
+        Reviewed by Eric Seidel.
+
+        Turns out array_stream didn't really do anything that StringIO
+        didn't do (at least as of Python 2.6). This change removes it
+        and updates all of the callers. Where possible, I changed the
+        test assertions in order to capture the intent more clearly,
+        e.g., instead of calling self.assertTrue('foo' in stream.get()),
+        we have self.assertContainsLine(stream, 'foo'), and instead of
+        self.assertTrue(stream.empty()), we have self.assertEmpty(stream) -
+        the latter isn't that much more readable, but StringIO doesn't
+        export an empty() method.
+
+        * Scripts/webkitpy/common/array_stream.py: Removed.
+        * Scripts/webkitpy/common/array_stream_unittest.py: Removed.
+        * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:
+        (passing_run):
+        (run_and_capture):
+        (StreamTestingMixin):
+        (StreamTestingMixin.assertContains):
+        (StreamTestingMixin.assertContainsLine):
+        (StreamTestingMixin.assertEmpty):
+        (StreamTestingMixin.assertNotEmpty):
+        (LintTest):
+        (LintTest.test_lint_test_files):
+        (LintTest.test_lint_test_files__errors):
+        (MainTest):
+        (MainTest.test_child_process_1):
+        (MainTest.test_child_processes_2):
+        (MainTest.test_child_processes_min):
+        (MainTest.test_help_printing):
+        (MainTest.test_hung_thread):
+        (MainTest.test_no_tests_found):
+        (MainTest.test_no_tests_found_2):
+        (MainTest.test_repeat_each_iterations_num_tests):
+        (MainTest.test_test_list):
+        (MainTest.test_unexpected_failures):
+        (MainTest.test_worker_model__inline_with_child_processes):
+        (MainTest.test_additional_platform_directory):
+        (RebaselineTest):
+        (RebaselineTest.assertBaselines):
+        (RebaselineTest.test_reset_results):
+        (RebaselineTest.test_missing_results):
+        (RebaselineTest.test_new_baseline):
+        * Scripts/webkitpy/layout_tests/views/metered_stream.py:
+        (MeteredStream.update):
+        * Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py:
+        (TestMeteredStream.test_regular):
+        * Scripts/webkitpy/layout_tests/views/printing_unittest.py:
+        (TestUtilityFunctions.assertEmpty):
+        (TestUtilityFunctions):
+        (TestUtilityFunctions.assertNotEmpty):
+        (TestUtilityFunctions.assertWritten):
+        (TestUtilityFunctions.test_configure_logging):
+        (Testprinter.assertEmpty):
+        (Testprinter):
+        (Testprinter.assertNotEmpty):
+        (Testprinter.assertWritten):
+        (Testprinter.reset):
+        (Testprinter.get_printer):
+        (Testprinter.test_help_printer):
+        (Testprinter.do_switch_tests.do_helper):
+        (Testprinter.test_print_one_line_summary):
+        (Testprinter.test_print_test_result):
+        (Testprinter.test_print_progress):
+        (Testprinter.test_write_nothing):
+        (Testprinter.test_write_misc):
+        (Testprinter.test_write_everything):
+        (Testprinter.test_write_verbose):
+        (Testprinter.test_print_unexpected_results):
+        * Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py:
+        (MainTest.assertWritten):
+        (create_runner):
+        (test_run_test_set):
+        (test_run_test_set_kills_drt_per_run):
+        (test_run_test_set_for_parser_tests):
+        (test_run_test_set_with_json_output):
+        (test_run_test_set_with_json_source):
+        (test_run_test_set_with_multiple_repositories):
+        (test_upload_json):
+
 2012-02-18  Kevin Ollivier  <kevino@theolliviers.com>
 
         [wx] Add the WebCore/page/scrolling directory to the build dirs.
diff --git a/Tools/Scripts/webkitpy/common/array_stream.py b/Tools/Scripts/webkitpy/common/array_stream.py
deleted file mode 100644 (file)
index 7d2c439..0000000
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/usr/bin/python
-# Copyright (C) 2010 Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-"""Package that private an array-based implementation of a stream."""
-
-
-class ArrayStream(object):
-    """Simple class that implmements a stream interface on top of an array.
-
-    This is used primarily by unit test classes to mock output streams. It
-    performs a similar function to StringIO, but (a) it is write-only, and
-    (b) it can be used to retrieve each individual write(); StringIO 
-    concatenates all of the writes together.
-    """
-
-    def __init__(self, tty=False):
-        self._contents = []
-        self._tty = tty
-
-    def write(self, msg):
-        """Implement stream.write() by appending to the stream's contents."""
-        self._contents.append(msg)
-
-    def get(self):
-        """Return the contents of a stream (as an array)."""
-        return self._contents
-
-    def reset(self):
-        """Empty the stream."""
-        self._contents = []
-
-    def empty(self):
-        """Return whether the stream is empty."""
-        return (len(self._contents) == 0)
-
-    def flush(self):
-        """Flush the stream (a no-op implemented for compatibility)."""
-        pass
-
-    def __repr__(self):
-        return '<ArrayStream: ' + str(self._contents) + '>'
-
-    def isatty(self):
-        return self._tty
diff --git a/Tools/Scripts/webkitpy/common/array_stream_unittest.py b/Tools/Scripts/webkitpy/common/array_stream_unittest.py
deleted file mode 100644 (file)
index 1a9b34a..0000000
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/python
-# Copyright (C) 2010 Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-"""Unit tests for array_stream.py."""
-
-import pdb
-import unittest
-
-from webkitpy.common.array_stream import ArrayStream
-
-
-class ArrayStreamTest(unittest.TestCase):
-    def assertEmpty(self, a_stream):
-        self.assertTrue(a_stream.empty())
-
-    def assertNotEmpty(self, a_stream):
-        self.assertFalse(a_stream.empty())
-
-    def assertContentsMatch(self, a_stream, contents):
-        self.assertEquals(a_stream.get(), contents)
-
-    def test_basics(self):
-        a = ArrayStream()
-        self.assertEmpty(a)
-        self.assertContentsMatch(a, [])
-
-        a.flush()
-        self.assertEmpty(a)
-        self.assertContentsMatch(a, [])
-
-        a.write("foo")
-        a.write("bar")
-        self.assertNotEmpty(a)
-        self.assertContentsMatch(a, ["foo", "bar"])
-
-        a.flush()
-        self.assertNotEmpty(a)
-        self.assertContentsMatch(a, ["foo", "bar"])
-
-        a.reset()
-        self.assertEmpty(a)
-        self.assertContentsMatch(a, [])
-
-        self.assertEquals(str(a), "<ArrayStream: []>")
-
-        a.write("foo")
-        self.assertNotEmpty(a)
-        self.assertContentsMatch(a, ["foo"])
-        self.assertEquals(str(a), "<ArrayStream: ['foo']>")
-
-if __name__ == '__main__':
-    unittest.main()
index 8793f37..66876cc 100755 (executable)
@@ -35,6 +35,7 @@ import json
 import logging
 import Queue
 import re
+import StringIO
 import sys
 import thread
 import time
@@ -47,7 +48,6 @@ from webkitpy.common.system import path
 # (bug 63846).
 SHOULD_TEST_PROCESSES = sys.platform not in ('cygwin', 'win32')
 
-from webkitpy.common import array_stream
 from webkitpy.common.system import outputcapture
 from webkitpy.common.system.crashlogs_unittest import make_mock_crash_report_darwin
 from webkitpy.common.host_mock import MockHost
@@ -90,10 +90,10 @@ def passing_run(extra_args=None, port_obj=None, record_results=False, tests_incl
     if not port_obj:
         host = host or MockHost()
         port_obj = host.port_factory.get(port_name=options.platform, options=options)
-    buildbot_output = array_stream.ArrayStream()
-    regular_output = array_stream.ArrayStream()
+    buildbot_output = StringIO.StringIO()
+    regular_output = StringIO.StringIO()
     res = run_webkit_tests.run(port_obj, options, parsed_args, buildbot_output=buildbot_output, regular_output=regular_output)
-    return res == 0 and regular_output.empty() and buildbot_output.empty()
+    return res == 0 and not regular_output.getvalue() and not buildbot_output.getvalue()
 
 
 def logging_run(extra_args=None, port_obj=None, record_results=False, tests_included=False, host=None, new_results=False):
@@ -113,8 +113,8 @@ def run_and_capture(port_obj, options, parsed_args):
     oc = outputcapture.OutputCapture()
     try:
         oc.capture_output()
-        buildbot_output = array_stream.ArrayStream()
-        regular_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
+        regular_output = StringIO.StringIO()
         res = run_webkit_tests.run(port_obj, options, parsed_args,
                                    buildbot_output=buildbot_output,
                                    regular_output=regular_output)
@@ -178,7 +178,21 @@ def get_tests_run(extra_args=None, tests_included=False, flatten_batches=False,
 unexpected_tests_count = 12
 
 
-class LintTest(unittest.TestCase):
+class StreamTestingMixin(object):
+    def assertContains(self, stream, string):
+        self.assertTrue(string in stream.getvalue())
+
+    def assertContainsLine(self, stream, string):
+        self.assertTrue(string in stream.buflist)
+
+    def assertEmpty(self, stream):
+        self.assertFalse(stream.getvalue())
+
+    def assertNotEmpty(self, stream):
+        self.assertTrue(stream.getvalue())
+
+
+class LintTest(unittest.TestCase, StreamTestingMixin):
     def test_all_configurations(self):
 
         class FakePort(object):
@@ -233,8 +247,8 @@ class LintTest(unittest.TestCase):
     def test_lint_test_files(self):
         res, out, err, user = logging_run(['--lint-test-files'])
         self.assertEqual(res, 0)
-        self.assertTrue(out.empty())
-        self.assertTrue(any(['Lint succeeded' in msg for msg in err.get()]))
+        self.assertEmpty(out)
+        self.assertContains(err, 'Lint succeeded')
 
     def test_lint_test_files__errors(self):
         options, parsed_args = parse_args(['--lint-test-files'])
@@ -244,11 +258,11 @@ class LintTest(unittest.TestCase):
         res, out, err = run_and_capture(port_obj, options, parsed_args)
 
         self.assertEqual(res, -1)
-        self.assertTrue(out.empty())
-        self.assertTrue(any(['Lint failed' in msg for msg in err.get()]))
+        self.assertEmpty(out)
+        self.assertTrue(any(['Lint failed' in msg for msg in err.buflist]))
 
 
-class MainTest(unittest.TestCase):
+class MainTest(unittest.TestCase, StreamTestingMixin):
     def test_accelerated_compositing(self):
         # This just tests that we recognize the command line args
         self.assertTrue(passing_run(['--accelerated-video']))
@@ -271,7 +285,7 @@ class MainTest(unittest.TestCase):
         if SHOULD_TEST_PROCESSES:
             _, _, regular_output, _ = logging_run(
                 ['--print', 'config', '--worker-model', 'processes', '--child-processes', '1'])
-            self.assertTrue(any(['Running 1 ' in line for line in regular_output.get()]))
+            self.assertTrue(any(['Running 1 ' in line for line in regular_output.buflist]))
 
     def test_child_processes_2(self):
         # This test seems to fail on win32.
@@ -280,14 +294,14 @@ class MainTest(unittest.TestCase):
         if SHOULD_TEST_PROCESSES:
             _, _, regular_output, _ = logging_run(
                 ['--print', 'config', '--worker-model', 'processes', '--child-processes', '2'])
-            self.assertTrue(any(['Running 2 ' in line for line in regular_output.get()]))
+            self.assertTrue(any(['Running 2 ' in line for line in regular_output.buflist]))
 
     def test_child_processes_min(self):
         if SHOULD_TEST_PROCESSES:
             _, _, regular_output, _ = logging_run(
                 ['--print', 'config', '--worker-model', 'processes', '--child-processes', '2', 'passes'],
                 tests_included=True)
-            self.assertTrue(any(['Running 1 ' in line for line in regular_output.get()]))
+            self.assertTrue(any(['Running 1 ' in line for line in regular_output.buflist]))
 
     def test_dryrun(self):
         batch_tests_run = get_tests_run(['--dry-run'])
@@ -322,16 +336,16 @@ class MainTest(unittest.TestCase):
     def test_help_printing(self):
         res, out, err, user = logging_run(['--help-printing'])
         self.assertEqual(res, 0)
-        self.assertTrue(out.empty())
-        self.assertFalse(err.empty())
+        self.assertEmpty(out)
+        self.assertNotEmpty(err)
 
     def test_hung_thread(self):
         res, out, err, user = logging_run(['--run-singly', '--time-out-ms=50',
                                           'failures/expected/hang.html'],
                                           tests_included=True)
         self.assertEqual(res, 0)
-        self.assertFalse(out.empty())
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(out)
+        self.assertNotEmpty(err)
 
     def test_keyboard_interrupt(self):
         # Note that this also tests running a test marked as SKIP if
@@ -347,14 +361,14 @@ class MainTest(unittest.TestCase):
     def test_no_tests_found(self):
         res, out, err, user = logging_run(['resources'], tests_included=True)
         self.assertEqual(res, -1)
-        self.assertTrue(out.empty())
-        self.assertTrue('No tests to run.\n' in err.get())
+        self.assertEmpty(out)
+        self.assertContainsLine(err, 'No tests to run.\n')
 
     def test_no_tests_found_2(self):
         res, out, err, user = logging_run(['foo'], tests_included=True)
         self.assertEqual(res, -1)
-        self.assertTrue(out.empty())
-        self.assertTrue('No tests to run.\n' in err.get())
+        self.assertEmpty(out)
+        self.assertContainsLine(err, 'No tests to run.\n')
 
     def test_randomize_order(self):
         # FIXME: verify order was shuffled
@@ -393,8 +407,8 @@ class MainTest(unittest.TestCase):
                                         '--print', 'everything',
                                         'passes/text.html', 'failures/expected/text.html'],
                                        tests_included=True, host=host, record_results=True)
-        self.assertTrue("=> Results: 8/16 tests passed (50.0%)\n" in out.get())
-        self.assertTrue(err.get()[-2] == "All 16 tests ran as expected.\n")
+        self.assertContainsLine(out, "=> Results: 8/16 tests passed (50.0%)\n")
+        self.assertContainsLine(err, "All 16 tests ran as expected.\n")
 
     def test_run_chunk(self):
         # Test that we actually select the right chunk
@@ -475,7 +489,7 @@ class MainTest(unittest.TestCase):
         res, out, err, user = logging_run(['--test-list=%s' % filename],
                                           tests_included=True, host=host)
         self.assertEqual(res, -1)
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(err)
 
     def test_test_list_with_prefix(self):
         host = MockHost()
@@ -490,8 +504,8 @@ class MainTest(unittest.TestCase):
         res, out, err, user = logging_run(tests_included=True)
 
         self.assertEqual(res, unexpected_tests_count)
-        self.assertFalse(out.empty())
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(out)
+        self.assertNotEmpty(err)
         self.assertEqual(user.opened_urls, [path.abspath_to_uri('/tmp/layout-test-results/results.html')])
 
     def test_missing_and_unexpected_results(self):
@@ -741,7 +755,7 @@ class MainTest(unittest.TestCase):
         res, out, err, user = logging_run(['--worker-model', 'inline',
                                            '--child-processes', '2'])
         self.assertEqual(res, 0)
-        self.assertTrue('--worker-model=inline overrides --child-processes\n' in err.get())
+        self.assertContainsLine(err, '--worker-model=inline overrides --child-processes\n')
 
     def test_worker_model__processes(self):
         if SHOULD_TEST_PROCESSES:
@@ -795,7 +809,7 @@ class MainTest(unittest.TestCase):
         self.assertTrue(passing_run(['--additional-platform-directory', '/tmp/foo', '--additional-platform-directory', '/tmp/bar']))
 
         res, buildbot_output, regular_output, user = logging_run(['--additional-platform-directory', 'foo'])
-        self.assertTrue('--additional-platform-directory=foo is ignored since it is not absolute\n' in regular_output.get())
+        self.assertContainsLine(regular_output, '--additional-platform-directory=foo is ignored since it is not absolute\n')
 
     def test_no_http_and_force(self):
         # See test_run_force, using --force raises an exception.
@@ -861,14 +875,14 @@ class EndToEndTest(unittest.TestCase):
             {"expected": "PASS", "ref_file": "reftests/foo/matching-ref.html", "actual": "IMAGE", "is_mismatch_reftest": True})
 
 
-class RebaselineTest(unittest.TestCase):
+class RebaselineTest(unittest.TestCase, StreamTestingMixin):
     def assertBaselines(self, file_list, file, extensions, err):
         "assert that the file_list contains the baselines."""
         for ext in extensions:
             baseline = file + "-expected" + ext
             baseline_msg = 'Writing new expected result "%s"\n' % baseline[1:]
             self.assertTrue(any(f.find(baseline) != -1 for f in file_list))
-            self.assertTrue(baseline_msg in err.get())
+            self.assertContainsLine(err, baseline_msg)
 
     # FIXME: Add tests to ensure that we're *not* writing baselines when we're not
     # supposed to be.
@@ -885,7 +899,7 @@ class RebaselineTest(unittest.TestCase):
         file_list = host.filesystem.written_files.keys()
         file_list.remove('/tmp/layout-test-results/tests_run0.txt')
         self.assertEquals(res, 0)
-        self.assertTrue(out.empty())
+        self.assertEmpty(out)
         self.assertEqual(len(file_list), 4)
         self.assertBaselines(file_list, "/passes/image", [".txt", ".png"], err)
         self.assertBaselines(file_list, "/failures/expected/missing_image", [".txt", ".png"], err)
@@ -903,7 +917,7 @@ class RebaselineTest(unittest.TestCase):
         file_list = host.filesystem.written_files.keys()
         file_list.remove('/tmp/layout-test-results/tests_run0.txt')
         self.assertEquals(res, 0)
-        self.assertFalse(out.empty())
+        self.assertNotEmpty(out)
         self.assertEqual(len(file_list), 6)
         self.assertBaselines(file_list, "/failures/unexpected/missing_text", [".txt"], err)
         self.assertBaselines(file_list, "/platform/test-mac-leopard/failures/unexpected/missing_image", [".png"], err)
@@ -921,7 +935,7 @@ class RebaselineTest(unittest.TestCase):
         file_list = host.filesystem.written_files.keys()
         file_list.remove('/tmp/layout-test-results/tests_run0.txt')
         self.assertEquals(res, 0)
-        self.assertTrue(out.empty())
+        self.assertEmpty(out)
         self.assertEqual(len(file_list), 4)
         self.assertBaselines(file_list,
             "/platform/test-mac-leopard/passes/image", [".txt", ".png"], err)
index a3c2df4..b5c233b 100644 (file)
@@ -67,10 +67,6 @@ class MeteredStream:
         """Write a message that will be overwritten by subsequent update() or write() calls."""
         self._overwrite(txt)
 
-    def flush(self):
-        # This seems to be needed on Python 2.5 for some reason.
-        self._stream.flush()
-
     def _overwrite(self, txt):
         # Print the necessary number of backspaces to erase the previous
         # message.
index 7fd0b82..359cfcf 100644 (file)
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+import StringIO
 import unittest
 
-from webkitpy.common.array_stream import ArrayStream
 from webkitpy.layout_tests.views.metered_stream import MeteredStream
 
 
 class TestMeteredStream(unittest.TestCase):
     def test_regular(self):
-        a = ArrayStream()
-        m = MeteredStream(stream=a)
-        self.assertTrue(a.empty())
+        a = StringIO.StringIO()
+        m = MeteredStream(a)
+        self.assertFalse(a.getvalue())
 
         # basic test
         m.write("foo")
         exp = ['foo']
-        self.assertEquals(a.get(), exp)
+        self.assertEquals(a.buflist, exp)
 
         # now check that a second write() does not overwrite the first.
         m.write("bar")
         exp.append('bar')
-        self.assertEquals(a.get(), exp)
+        self.assertEquals(a.buflist, exp)
 
         m.update("batter")
         exp.append('batter')
-        self.assertEquals(a.get(), exp)
+        self.assertEquals(a.buflist, exp)
 
         # The next update() should overwrite the laste update() but not the
         # other text. Note that the cursor is effectively positioned at the
@@ -59,22 +59,23 @@ class TestMeteredStream(unittest.TestCase):
         m.update("foo")
         exp.append('\b\b\b\b\b\b      \b\b\b\b\b\b')
         exp.append('foo')
-        self.assertEquals(a.get(), exp)
+        self.assertEquals(a.buflist, exp)
 
         # now check that a write() does overwrite the update
         m.write("foo")
         exp.append('\b\b\b   \b\b\b')
         exp.append('foo')
-        self.assertEquals(a.get(), exp)
+        self.assertEquals(a.buflist, exp)
 
         # Now test that we only back up to the most recent newline.
 
         # Note also that we do not back up to erase the most recent write(),
         # i.e., write()s do not get erased.
-        a.reset()
+        a = StringIO.StringIO()
+        m = MeteredStream(a)
         m.update("foo\nbar")
         m.update("baz")
-        self.assertEquals(a.get(), ['foo\nbar', '\b\b\b   \b\b\b', 'baz'])
+        self.assertEquals(a.buflist, ['foo\nbar', '\b\b\b   \b\b\b', 'baz'])
 
 
 if __name__ == '__main__':
index 0916e8e..6899d2c 100644 (file)
 
 import logging
 import optparse
+import StringIO
 import time
 import unittest
 
-from webkitpy.common import array_stream
 from webkitpy.common.host_mock import MockHost
 
 from webkitpy.common.system import logtesting
@@ -54,24 +54,33 @@ def get_options(args):
 
 
 class TestUtilityFunctions(unittest.TestCase):
+    def assertEmpty(self, stream):
+        self.assertFalse(stream.getvalue())
+
+    def assertNotEmpty(self, stream):
+        self.assertTrue(stream.getvalue())
+
+    def assertWritten(self, stream, contents):
+        self.assertEquals(stream.buflist, contents)
+
     def test_configure_logging(self):
         options, args = get_options([])
-        stream = array_stream.ArrayStream()
+        stream = StringIO.StringIO()
         handler = printing._configure_logging(stream, options.verbose)
         logging.info("this should be logged")
-        self.assertFalse(stream.empty())
+        self.assertNotEmpty(stream)
 
-        stream.reset()
+        stream = StringIO.StringIO()
         logging.debug("this should not be logged")
-        self.assertTrue(stream.empty())
+        self.assertEmpty(stream)
 
         printing._restore_logging(handler)
 
-        stream.reset()
+        stream = StringIO.StringIO()
         options, args = get_options(['--verbose'])
         handler = printing._configure_logging(stream, options.verbose)
         logging.debug("this should be logged")
-        self.assertFalse(stream.empty())
+        self.assertNotEmpty(stream)
         printing._restore_logging(handler)
 
     def test_print_options(self):
@@ -110,6 +119,19 @@ class TestUtilityFunctions(unittest.TestCase):
 
 
 class  Testprinter(unittest.TestCase):
+    def assertEmpty(self, stream):
+        self.assertFalse(stream.getvalue())
+
+    def assertNotEmpty(self, stream):
+        self.assertTrue(stream.getvalue())
+
+    def assertWritten(self, stream, contents):
+        self.assertEquals(stream.buflist, contents)
+
+    def reset(self, stream):
+        stream.buflist = []
+        stream.buf = ''
+
     def get_printer(self, args=None, tty=False):
         args = args or []
         printing_options = printing.print_options()
@@ -119,8 +141,9 @@ class  Testprinter(unittest.TestCase):
         self._port = host.port_factory.get('test', options)
         nproc = 2
 
-        regular_output = array_stream.ArrayStream(tty=tty)
-        buildbot_output = array_stream.ArrayStream()
+        regular_output = StringIO.StringIO()
+        regular_output.isatty = lambda: tty
+        buildbot_output = StringIO.StringIO()
         printer = printing.Printer(self._port, options, regular_output,
                                    buildbot_output, configure_logging=True)
         return printer, regular_output, buildbot_output
@@ -151,16 +174,16 @@ class  Testprinter(unittest.TestCase):
         # This routine should print something to stdout. testing what it is
         # is kind of pointless.
         printer.help_printing()
-        self.assertFalse(err.empty())
-        self.assertTrue(out.empty())
+        self.assertNotEmpty(err)
+        self.assertEmpty(out)
 
     def do_switch_tests(self, method_name, switch, to_buildbot,
                         message='hello', exp_err=None, exp_bot=None):
         def do_helper(method_name, switch, message, exp_err, exp_bot):
             printer, err, bot = self.get_printer(['--print', switch], tty=True)
             getattr(printer, method_name)(message)
-            self.assertEqual(err.get(), exp_err)
-            self.assertEqual(bot.get(), exp_bot)
+            self.assertEqual(err.buflist, exp_err)
+            self.assertEqual(bot.buflist, exp_bot)
 
         if to_buildbot:
             if exp_err is None:
@@ -211,31 +234,27 @@ class  Testprinter(unittest.TestCase):
     def test_print_one_line_summary(self):
         printer, err, out = self.get_printer(['--print', 'nothing'])
         printer.print_one_line_summary(1, 1, 0)
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
 
         printer, err, out = self.get_printer(['--print', 'one-line-summary'])
         printer.print_one_line_summary(1, 1, 0)
-        self.assertEquals(err.get(), ["All 1 tests ran as expected.\n", "\n"])
+        self.assertWritten(err, ["All 1 tests ran as expected.\n", "\n"])
 
         printer, err, out = self.get_printer(['--print', 'everything'])
         printer.print_one_line_summary(1, 1, 0)
-        self.assertEquals(err.get(), ["All 1 tests ran as expected.\n", "\n"])
+        self.assertWritten(err, ["All 1 tests ran as expected.\n", "\n"])
 
-        err.reset()
+        printer, err, out = self.get_printer(['--print', 'everything'])
         printer.print_one_line_summary(2, 1, 1)
-        self.assertEquals(err.get(),
-                          ["1 test ran as expected, 1 didn't:\n", "\n"])
+        self.assertWritten(err, ["1 test ran as expected, 1 didn't:\n", "\n"])
 
-        err.reset()
+        printer, err, out = self.get_printer(['--print', 'everything'])
         printer.print_one_line_summary(3, 2, 1)
-        self.assertEquals(err.get(),
-                          ["2 tests ran as expected, 1 didn't:\n", "\n"])
+        self.assertWritten(err, ["2 tests ran as expected, 1 didn't:\n", "\n"])
 
-        err.reset()
+        printer, err, out = self.get_printer(['--print', 'everything'])
         printer.print_one_line_summary(3, 2, 0)
-        self.assertEquals(err.get(),
-                          ['\n', "2 tests ran as expected (1 didn't run).\n",
-                           '\n'])
+        self.assertWritten(err, ['\n', "2 tests ran as expected (1 didn't run).\n", '\n'])
 
 
     def test_print_test_result(self):
@@ -253,55 +272,55 @@ class  Testprinter(unittest.TestCase):
         result = self.get_result('passes/image.html')
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
 
         printer, err, out = self.get_printer(['--print', 'unexpected'])
         printer.print_test_result(result, expected=True, exp_str='',
                                   got_str='')
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
-        self.assertEquals(err.get(),
-                          ['  passes/image.html -> unexpected pass\n'])
+        self.assertWritten(err, ['  passes/image.html -> unexpected pass\n'])
 
         printer, err, out = self.get_printer(['--print', 'everything'])
         printer.print_test_result(result, expected=True, exp_str='',
                                   got_str='')
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
 
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
-        self.assertEquals(err.get(),
-                          ['  passes/image.html -> unexpected pass\n'])
+        self.assertWritten(err, ['  passes/image.html -> unexpected pass\n'])
 
         printer, err, out = self.get_printer(['--print', 'nothing'])
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
 
         printer, err, out = self.get_printer(['--print',
                                               'trace-unexpected'])
         printer.print_test_result(result, expected=True, exp_str='',
                                   got_str='')
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
 
         printer, err, out = self.get_printer(['--print',
                                               'trace-unexpected'])
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(err)
 
         printer, err, out = self.get_printer(['--print',
                                               'trace-unexpected'])
         result = self.get_result("passes/text.html")
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(err)
 
-        err.reset()
+        printer, err, out = self.get_printer(['--print',
+                                              'trace-unexpected'])
+        result = self.get_result("passes/text.html")
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(err)
 
         printer, err, out = self.get_printer(['--print', 'trace-everything'])
         result = self.get_result('passes/image.html')
@@ -316,9 +335,10 @@ class  Testprinter(unittest.TestCase):
         result = self.get_result('failures/expected/missing_image.html')
         printer.print_test_result(result, expected=True, exp_str='',
                                   got_str='')
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(err)
 
-        err.reset()
+        printer, err, out = self.get_printer(['--print', 'trace-everything'])
+        result = self.get_result('passes/image.html')
         printer.print_test_result(result, expected=False, exp_str='',
                                   got_str='')
 
@@ -332,12 +352,12 @@ class  Testprinter(unittest.TestCase):
 
         # First, test that we print nothing.
         printer.print_progress(rs, False, paths)
-        self.assertTrue(out.empty())
-        self.assertTrue(err.empty())
+        self.assertEmpty(out)
+        self.assertEmpty(err)
 
         printer.print_progress(rs, True, paths)
-        self.assertTrue(out.empty())
-        self.assertTrue(err.empty())
+        self.assertEmpty(out)
+        self.assertEmpty(err)
 
         self.times = [1, 2, 12, 13, 14, 23, 33]
 
@@ -352,69 +372,71 @@ class  Testprinter(unittest.TestCase):
             printer, err, out = self.get_printer(['--print', 'one-line-progress'])
             printer.print_progress(rs, False, paths)
             printer.print_progress(rs, False, paths)
-            self.assertTrue(out.empty())
-            self.assertTrue(err.empty())
+            self.assertEmpty(out)
+            self.assertEmpty(err)
 
             printer.print_progress(rs, False, paths)
-            self.assertTrue(out.empty())
-            self.assertFalse(err.empty())
+            self.assertEmpty(out)
+            self.assertNotEmpty(err)
 
-            err.reset()
-            out.reset()
+            self.reset(err)
+            self.reset(out)
             printer.print_progress(rs, True, paths)
-            self.assertTrue(out.empty())
-            self.assertTrue(err.empty())
+            self.assertEmpty(out)
+            self.assertEmpty(err)
 
             printer.print_progress(rs, True, paths)
-            self.assertTrue(out.empty())
-            self.assertFalse(err.empty())
+            self.assertEmpty(out)
+            self.assertNotEmpty(err)
 
             # Now reconfigure the printer to test printing to a TTY instead of a file.
             self.times = [1, 1.01, 2, 3]
             printer, err, out = self.get_printer(['--print', 'one-line-progress'], tty=True)
             printer.print_progress(rs, False, paths)
             printer.print_progress(rs, False, paths)
-            self.assertTrue(out.empty())
-            self.assertTrue(err.empty())
+            self.assertEmpty(out)
+            self.assertEmpty(err)
 
             printer.print_progress(rs, False, paths)
-            self.assertTrue(out.empty())
-            self.assertFalse(err.empty())
+            self.assertEmpty(out)
+            self.assertNotEmpty(err)
 
-            err.reset()
-            out.reset()
+            self.reset(err)
+            self.reset(out)
             printer.print_progress(rs, True, paths)
-            self.assertTrue(out.empty())
-            self.assertFalse(err.empty())
+            self.assertEmpty(out)
+            self.assertNotEmpty(err)
         finally:
             time.time = orig_time
 
     def test_write_nothing(self):
         printer, err, out = self.get_printer(['--print', 'nothing'])
         printer.write("foo")
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
 
     def test_write_misc(self):
         printer, err, out = self.get_printer(['--print', 'misc'])
         printer.write("foo")
-        self.assertFalse(err.empty())
-        err.reset()
+        self.assertNotEmpty(err)
+
+        printer, err, out = self.get_printer(['--print', 'misc'])
         printer.write("foo", "config")
-        self.assertTrue(err.empty())
+        self.assertEmpty(err)
 
     def test_write_everything(self):
         printer, err, out = self.get_printer(['--print', 'everything'])
         printer.write("foo")
-        self.assertFalse(err.empty())
-        err.reset()
+        self.assertNotEmpty(err)
+
+        printer, err, out = self.get_printer(['--print', 'everything'])
         printer.write("foo", "config")
-        self.assertFalse(err.empty())
+        self.assertNotEmpty(err)
 
     def test_write_verbose(self):
         printer, err, out = self.get_printer(['--verbose'])
         printer.write("foo")
-        self.assertTrue(not err.empty() and "foo" in err.get()[0])
-        self.assertTrue(out.empty())
+        self.assertTrue("foo" in err.buflist[0])
+        self.assertEmpty(out)
 
     def test_print_unexpected_results(self):
         # This routine is the only one that prints stuff that the bots
@@ -470,68 +492,60 @@ class  Testprinter(unittest.TestCase):
         printer, err, out = self.get_printer(['--print', 'nothing'])
         ur = get_unexpected_results(expected=False, passing=False, flaky=False)
         printer.print_unexpected_results(ur)
-        self.assertTrue(err.empty())
-        self.assertTrue(out.empty())
+        self.assertEmpty(err)
+        self.assertEmpty(out)
 
         printer, err, out = self.get_printer(['--print', 'unexpected-results'])
 
         # test everything running as expected
         ur = get_unexpected_results(expected=True, passing=False, flaky=False)
         printer.print_unexpected_results(ur)
-        self.assertTrue(err.empty())
-        self.assertTrue(out.empty())
+        self.assertEmpty(err)
+        self.assertEmpty(out)
 
         # test failures
-        err.reset()
-        out.reset()
+        printer, err, out = self.get_printer(['--print', 'unexpected-results'])
         ur = get_unexpected_results(expected=False, passing=False, flaky=False)
         printer.print_unexpected_results(ur)
-        self.assertTrue(err.empty())
-        self.assertFalse(out.empty())
+        self.assertEmpty(err)
+        self.assertNotEmpty(out)
 
         # test unexpected flaky
-        err.reset()
-        out.reset()
+        printer, err, out = self.get_printer(['--print', 'unexpected-results'])
         ur = get_unexpected_results(expected=False, passing=False, flaky=True)
         printer.print_unexpected_results(ur)
-        self.assertTrue(err.empty())
-        self.assertFalse(out.empty())
+        self.assertEmpty(err)
+        self.assertNotEmpty(out)
 
-        err.reset()
-        out.reset()
         printer, err, out = self.get_printer(['--print', 'everything'])
         ur = get_unexpected_results(expected=False, passing=False, flaky=False)
         printer.print_unexpected_results(ur)
-        self.assertTrue(err.empty())
-        self.assertFalse(out.empty())
+        self.assertEmpty(err)
+        self.assertNotEmpty(out)
 
         expectations = """
 BUGX : failures/expected/crash.html = CRASH
 BUGX : failures/expected/timeout.html = TIMEOUT
 """
-        err.reset()
-        out.reset()
+        printer, err, out = self.get_printer(['--print', 'unexpected-results'])
         ur = get_unexpected_results(expected=False, passing=False, flaky=False)
         printer.print_unexpected_results(ur)
-        self.assertTrue(err.empty())
-        self.assertFalse(out.empty())
+        self.assertEmpty(err)
+        self.assertNotEmpty(out)
 
-        err.reset()
-        out.reset()
+        printer, err, out = self.get_printer(['--print', 'unexpected-results'])
         ur = get_unexpected_results(expected=False, passing=True, flaky=False)
         printer.print_unexpected_results(ur)
-        self.assertTrue(err.empty())
-        self.assertFalse(out.empty())
+        self.assertEmpty(err)
+        self.assertNotEmpty(out)
 
         # Test handling of --verbose as well.
-        err.reset()
-        out.reset()
         printer, err, out = self.get_printer(['--verbose'])
         ur = get_unexpected_results(expected=False, passing=False, flaky=False)
         printer.print_unexpected_results(ur)
         # FIXME: debug output from the port and scm objects may or may not go
         # to stderr, so there's no point in testing its contents here.
-        self.assertFalse(out.empty())
+        self.assertNotEmpty(out)
 
     def test_print_unexpected_results_buildbot(self):
         # FIXME: Test that print_unexpected_results() produces the printer the
index 7a04796..e194072 100755 (executable)
@@ -33,7 +33,6 @@ import StringIO
 import json
 import unittest
 
-from webkitpy.common import array_stream
 from webkitpy.common.host_mock import MockHost
 from webkitpy.common.system.filesystem_mock import MockFileSystem
 from webkitpy.common.system.outputcapture import OutputCapture
@@ -44,6 +43,9 @@ from webkitpy.performance_tests.perftestsrunner import PerfTestsRunner
 
 
 class MainTest(unittest.TestCase):
+    def assertWritten(self, stream, contents):
+        self.assertEquals(stream.buflist, contents)
+
     class TestDriver:
         def run_test(self, driver_input):
             text = ''
@@ -108,8 +110,8 @@ max 1120
             """do nothing"""
 
     def create_runner(self, buildbot_output=None, args=[], regular_output=None, driver_class=TestDriver):
-        buildbot_output = buildbot_output or array_stream.ArrayStream()
-        regular_output = regular_output or array_stream.ArrayStream()
+        buildbot_output = buildbot_output or StringIO.StringIO()
+        regular_output = regular_output or StringIO.StringIO()
 
         options, parsed_args = PerfTestsRunner._parse_args(args)
         test_port = TestPort(host=MockHost(), options=options)
@@ -145,15 +147,14 @@ max 1120
         self.assertFalse(self.run_test('crash.html'))
 
     def test_run_test_set(self):
-        buildbot_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
         runner = self.create_runner(buildbot_output)
         dirname = runner._base_path + '/inspector/'
         tests = [dirname + 'pass.html', dirname + 'silent.html', dirname + 'failed.html',
             dirname + 'tonguey.html', dirname + 'timeout.html', dirname + 'crash.html']
         unexpected_result_count = runner._run_tests_set(tests, runner._port)
         self.assertEqual(unexpected_result_count, len(tests) - 1)
-        self.assertEqual(len(buildbot_output.get()), 1)
-        self.assertEqual(buildbot_output.get()[0], 'RESULT group_name: test_name= 42 ms\n')
+        self.assertWritten(buildbot_output, ['RESULT group_name: test_name= 42 ms\n'])
 
     def test_run_test_set_kills_drt_per_run(self):
 
@@ -163,7 +164,7 @@ max 1120
             def stop(self):
                 TestDriverWithStopCount.stop_count += 1
 
-        buildbot_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
         runner = self.create_runner(buildbot_output, driver_class=TestDriverWithStopCount)
 
         dirname = runner._base_path + '/inspector/'
@@ -180,7 +181,7 @@ max 1120
             def start(self):
                 TestDriverWithStartCount.start_count += 1
 
-        buildbot_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
         runner = self.create_runner(buildbot_output, args=["--pause-before-testing"], driver_class=TestDriverWithStartCount)
 
         dirname = runner._base_path + '/inspector/'
@@ -197,27 +198,26 @@ max 1120
             self.assertEqual(logs, "Running inspector/pass.html (1 of 1)\n\n")
 
     def test_run_test_set_for_parser_tests(self):
-        buildbot_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
         runner = self.create_runner(buildbot_output)
         tests = [runner._base_path + '/Bindings/event-target-wrapper.html', runner._base_path + '/Parser/some-parser.html']
         unexpected_result_count = runner._run_tests_set(tests, runner._port)
         self.assertEqual(unexpected_result_count, 0)
-        self.assertEqual(buildbot_output.get()[0], 'RESULT Bindings: event-target-wrapper= 1489.05 ms\n')
-        self.assertEqual(buildbot_output.get()[1], 'median= 1487.0 ms, stdev= 14.46 ms, min= 1471.0 ms, max= 1510.0 ms\n')
-        self.assertEqual(buildbot_output.get()[2], 'RESULT Parser: some-parser= 1100.0 ms\n')
-        self.assertEqual(buildbot_output.get()[3], 'median= 1101.0 ms, stdev= 11.0 ms, min= 1080.0 ms, max= 1120.0 ms\n')
+        self.assertWritten(buildbot_output, ['RESULT Bindings: event-target-wrapper= 1489.05 ms\n',
+                                             'median= 1487.0 ms, stdev= 14.46 ms, min= 1471.0 ms, max= 1510.0 ms\n',
+                                             'RESULT Parser: some-parser= 1100.0 ms\n',
+                                             'median= 1101.0 ms, stdev= 11.0 ms, min= 1080.0 ms, max= 1120.0 ms\n'])
 
     def test_run_test_set_with_json_output(self):
-        buildbot_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
         runner = self.create_runner(buildbot_output, args=['--output-json-path=/mock-checkout/output.json'])
         runner._host.filesystem.files[runner._base_path + '/inspector/pass.html'] = True
         runner._host.filesystem.files[runner._base_path + '/Bindings/event-target-wrapper.html'] = True
         runner._timestamp = 123456789
         self.assertEqual(runner.run(), 0)
-        self.assertEqual(len(buildbot_output.get()), 3)
-        self.assertEqual(buildbot_output.get()[0], 'RESULT Bindings: event-target-wrapper= 1489.05 ms\n')
-        self.assertEqual(buildbot_output.get()[1], 'median= 1487.0 ms, stdev= 14.46 ms, min= 1471.0 ms, max= 1510.0 ms\n')
-        self.assertEqual(buildbot_output.get()[2], 'RESULT group_name: test_name= 42 ms\n')
+        self.assertWritten(buildbot_output, ['RESULT Bindings: event-target-wrapper= 1489.05 ms\n',
+                                             'median= 1487.0 ms, stdev= 14.46 ms, min= 1471.0 ms, max= 1510.0 ms\n',
+                                             'RESULT group_name: test_name= 42 ms\n'])
 
         self.assertEqual(json.loads(runner._host.filesystem.files['/mock-checkout/output.json']), {
             "timestamp": 123456789, "results":
@@ -226,7 +226,7 @@ max 1120
             "webkit-revision": 5678})
 
     def test_run_test_set_with_json_source(self):
-        buildbot_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
         runner = self.create_runner(buildbot_output, args=['--output-json-path=/mock-checkout/output.json',
             '--source-json-path=/mock-checkout/source.json'])
         runner._host.filesystem.files['/mock-checkout/source.json'] = '{"key": "value"}'
@@ -234,10 +234,9 @@ max 1120
         runner._host.filesystem.files[runner._base_path + '/Bindings/event-target-wrapper.html'] = True
         runner._timestamp = 123456789
         self.assertEqual(runner.run(), 0)
-        self.assertEqual(len(buildbot_output.get()), 3)
-        self.assertEqual(buildbot_output.get()[0], 'RESULT Bindings: event-target-wrapper= 1489.05 ms\n')
-        self.assertEqual(buildbot_output.get()[1], 'median= 1487.0 ms, stdev= 14.46 ms, min= 1471.0 ms, max= 1510.0 ms\n')
-        self.assertEqual(buildbot_output.get()[2], 'RESULT group_name: test_name= 42 ms\n')
+        self.assertWritten(buildbot_output, ['RESULT Bindings: event-target-wrapper= 1489.05 ms\n',
+                                             'median= 1487.0 ms, stdev= 14.46 ms, min= 1471.0 ms, max= 1510.0 ms\n',
+                                             'RESULT group_name: test_name= 42 ms\n'])
 
         self.assertEqual(json.loads(runner._host.filesystem.files['/mock-checkout/output.json']), {
             "timestamp": 123456789, "results":
@@ -247,7 +246,7 @@ max 1120
             "key": "value"})
 
     def test_run_test_set_with_multiple_repositories(self):
-        buildbot_output = array_stream.ArrayStream()
+        buildbot_output = StringIO.StringIO()
         runner = self.create_runner(buildbot_output, args=['--output-json-path=/mock-checkout/output.json'])
         runner._host.filesystem.files[runner._base_path + '/inspector/pass.html'] = True
         runner._timestamp = 123456789
@@ -284,7 +283,7 @@ max 1120
         self.assertEqual(runner.run(), -3)
 
     def test_upload_json(self):
-        regular_output = array_stream.ArrayStream()
+        regular_output = StringIO.StringIO()
         runner = self.create_runner(regular_output=regular_output)
         runner._host.filesystem.files['/mock-checkout/some.json'] = 'some content'