Rebase and squash.

Author: aklajnert

src/_pytest/capture.py

@@ -358,11 +358,17 @@ def close(self):
             self._capture.stop_capturing()
             self._capture = None
 
-    def readouterr(self):
+    def readouterr(self, combined=False, flush=True):
         """Read and return the captured output so far, resetting the internal buffer.
 
         :return: captured content as a namedtuple with ``out`` and ``err`` string attributes
         """
+        if combined:
+            return CaptureResult(self._get_combined(), None)
+        if flush is False:
+            if self.captureclass is not OrderedCapture:
+                raise AttributeError("Only capsys can read streams without flushing.")
+            OrderedCapture.set_flush(False)
         captured_out, captured_err = self._captured_out, self._captured_err
         if self._capture is not None:
             out, err = self._capture.readouterr()
@@ -372,6 +378,13 @@ def readouterr(self):
         self._captured_err = self.captureclass.EMPTY_BUFFER
         return CaptureResult(captured_out, captured_err)
 
+    def _get_combined(self):
+        if self.captureclass is not OrderedCapture:
+            raise AttributeError("Only capsys is able to combine streams.")
+        result = "".join(line[0] for line in OrderedCapture.streams)
+        OrderedCapture.flush()
+        return result
+
     def _suspend(self):
         """Suspends this fixture's own capturing temporarily."""
         if self._capture is not None:
@@ -637,12 +650,16 @@ def __init__(self, fd, tmpfile=None):
         name = patchsysdict[fd]
         self._old = getattr(sys, name)
         self.name = name
+        self.fd = fd
         if tmpfile is None:
             if name == "stdin":
                 tmpfile = DontReadFromInput()
             else:
-                tmpfile = CaptureIO()
+                tmpfile = self._get_writer()
         self.tmpfile = tmpfile
+        
+    def _get_writer(self):
+        return CaptureIO()
 
     def __repr__(self):
         return "<{} {} _old={} _state={!r} tmpfile={!r}>".format(
@@ -705,14 +722,65 @@ def __init__(self, fd, tmpfile=None):
         self.tmpfile = tmpfile
 
 
+
+class OrderedCapture(SysCapture):
+    """Capture class that keeps streams in order."""
+    streams = collections.deque()
+    _flush = True
+
+    def _get_writer(self):
+        return OrderedWriter(self.fd)
+
+    def snap(self):
+        res = self.tmpfile.getvalue()
+        if self.name == "stderr":
+            # both streams are being read one after another, while stderr is last - it will clear the queue
+            self.flush()
+        return res
+    
+    @classmethod
+    def set_flush(cls, flush: bool) -> None:
+        cls._flush = flush
+        
+    @classmethod
+    def flush(cls) -> None:
+        """Clear streams. """
+        if cls._flush is False:
+            cls.set_flush(True)
+        else:
+            cls.streams.clear()
+            
+    @classmethod
+    def close(cls) -> None:
+        cls.set_flush(True)
+        cls.flush()
+        
 map_fixname_class = {
     "capfd": FDCapture,
     "capfdbinary": FDCaptureBinary,
-    "capsys": SysCapture,
+    "capsys": OrderedCapture,
     "capsysbinary": SysCaptureBinary,
 }
 
 
+class OrderedWriter:
+    encoding = sys.getdefaultencoding()
+
+    def __init__(self, fd: int) -> None:
+        super().__init__()
+        self._fd = fd  # type: int
+
+    def write(self, text, **kwargs):
+        OrderedCapture.streams.append((text, self._fd))
+        return len(text)
+
+    def getvalue(self):
+        return "".join((line[0] for line in OrderedCapture.streams if line[1] == self._fd))
+
+    def close(self):
+        OrderedCapture.close()
+
+
 class DontReadFromInput:
     encoding = None
 

testing/test_capture.py

@@ -1572,3 +1572,34 @@ def test__get_multicapture() -> None:
     pytest.raises(ValueError, _get_multicapture, "unknown").match(
         r"^unknown capturing method: 'unknown'"
     )
+
+def test_combined_streams(capsys):
+    """Show that capsys is capable of preserving chronological order of streams."""
+    print("stdout1")
+    print("stdout2")
+    print("stderr1", file=sys.stderr)
+    print("stdout3")
+    print("stderr2", file=sys.stderr)
+    print("stderr3", file=sys.stderr)
+    print("stdout4")
+    print("stdout5")
+
+    # this won't clear streams
+    out, err = capsys.readouterr(flush=False)
+    assert "stdout1" in out
+    assert "stdout1" not in err
+    assert "stderr1" in err
+    assert "stderr1" not in out
+
+    out, err = capsys.readouterr(combined=True)
+    assert (
+        out == "stdout1\n"
+        "stdout2\n"
+        "stderr1\n"
+        "stdout3\n"
+        "stderr2\n"
+        "stderr3\n"
+        "stdout4\n"
+        "stdout5\n"
+    )
+    assert err is None