fix: use bool flag instead of nullptr sentinel for moved-from state

Using `old == nullptr` as the moved-from sentinel was incorrect because
nullptr is a valid original rdbuf() value (e.g. `std::ostream os(nullptr)`).
Replace with an explicit `active` flag so the destructor correctly
restores nullptr buffers.

Add tests for the nullptr-rdbuf edge case.

Author: kounelisagis

include/pybind11/iostream.h

@@ -169,6 +169,7 @@ class scoped_ostream_redirect {
     std::streambuf *old;
     std::ostream &costream;
     detail::pythonbuf buffer;
+    bool active = true;
 
 public:
     explicit scoped_ostream_redirect(std::ostream &costream = std::cout,
@@ -179,15 +180,15 @@ class scoped_ostream_redirect {
     }
 
     ~scoped_ostream_redirect() {
-        if (old) {
+        if (active) {
             costream.rdbuf(old);
         }
     }
 
     scoped_ostream_redirect(const scoped_ostream_redirect &) = delete;
     scoped_ostream_redirect(scoped_ostream_redirect &&other) noexcept
         : old(other.old), costream(other.costream), buffer(std::move(other.buffer)) {
-        other.old = nullptr;     // Disarm moved-from destructor
+        other.active = false;    // Disarm moved-from destructor
         costream.rdbuf(&buffer); // Re-point stream to our buffer
     }
     scoped_ostream_redirect &operator=(const scoped_ostream_redirect &) = delete;

tests/test_iostream.cpp

@@ -124,10 +124,30 @@ TEST_SUBMODULE(iostream, m) {
         .def("join", &TestThread::join)
         .def("sleep", &TestThread::sleep);
 
-    m.def("move_redirect_output", [](const std::string &msg) {
+    m.def("move_redirect_output", [](const std::string &msg_before, const std::string &msg_after) {
         py::scoped_ostream_redirect redir1(std::cout, py::module_::import("sys").attr("stdout"));
-        std::cout << "before" << std::flush;
+        std::cout << msg_before << std::flush;
         py::scoped_ostream_redirect redir2(std::move(redir1));
-        std::cout << msg << std::flush;
+        std::cout << msg_after << std::flush;
+    });
+
+    // Redirect a stream whose original rdbuf is nullptr, then move the redirect.
+    // Verifies that nullptr is correctly restored (not confused with a moved-from sentinel).
+    m.def("move_redirect_null_rdbuf", [](const std::string &msg) {
+        std::ostream os(nullptr);
+        py::scoped_ostream_redirect redir1(os, py::module_::import("sys").attr("stdout"));
+        os << msg << std::flush;
+        py::scoped_ostream_redirect redir2(std::move(redir1));
+        os << msg << std::flush;
+        // After redir2 goes out of scope, os.rdbuf() should be restored to nullptr.
+    });
+
+    m.def("get_null_rdbuf_restored", [](const std::string &msg) -> bool {
+        std::ostream os(nullptr);
+        {
+            py::scoped_ostream_redirect redir(os, py::module_::import("sys").attr("stdout"));
+            os << msg << std::flush;
+        }
+        return os.rdbuf() == nullptr;
     });
 }

tests/test_iostream.py

@@ -285,12 +285,23 @@ def test_redirect_both(capfd):
 
 
 def test_move_redirect(capsys):
-    m.move_redirect_output("after")
+    m.move_redirect_output("before_move", "after_move")
     stdout, stderr = capsys.readouterr()
-    assert stdout == "beforeafter"
+    assert stdout == "before_moveafter_move"
     assert not stderr
 
 
+def test_move_redirect_null_rdbuf(capsys):
+    m.move_redirect_null_rdbuf("hello")
+    stdout, stderr = capsys.readouterr()
+    assert stdout == "hellohello"
+    assert not stderr
+
+
+def test_null_rdbuf_restored():
+    assert m.get_null_rdbuf_restored("test")
+
+
 @pytest.mark.skipif(sys.platform.startswith("emscripten"), reason="Requires threads")
 def test_threading():
     with m.ostream_redirect(stdout=True, stderr=False):