pythonbuf fix

include/pybind11/iostream.h

@@ -43,11 +43,15 @@ class pythonbuf : public std::streambuf {
     // simplified to a fully qualified call.
     int _sync() {
         if (pbase() != pptr()) {
-            // This subtraction cannot be negative, so dropping the sign
-            str line(pbase(), static_cast<size_t>(pptr() - pbase()));
 
             {
                 gil_scoped_acquire tmp;
+
+                // This subtraction cannot be negative, so dropping the sign
+                // this invokes python and therefore should be included in the
+                // GIL
+                str line(pbase(), static_cast<size_t>(pptr() - pbase()));
+
                 pywrite(line);
                 pyflush();
             }

tests/CMakeLists.txt

@@ -122,7 +122,8 @@ set(PYBIND11_TEST_FILES
     test_stl_binders.cpp
     test_tagbased_polymorphic.cpp
     test_union.cpp
-    test_virtual_functions.cpp)
+    test_virtual_functions.cpp
+    test_thread.cpp)
 
 # Invoking cmake with something like:
 #     cmake -DPYBIND11_TEST_OVERRIDE="test_callbacks.cpp;test_pickling.cpp" ..

tests/test_thread.cpp

@@ -0,0 +1,53 @@
+/*
+    tests/test_tread.cpp -- thread handling
+
+    Copyright (c) 2020 Nick Bridge <nick.bridge.chess@gmail.com>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "pybind11_tests.h"
+#include <thread>
+#include <atomic>
+#include <iostream>
+#include <pybind11/iostream.h>
+
+
+TEST_SUBMODULE(test_threading, m) {
+  // object to manage C++ thread
+  // simply repeatedly write to std::cerr until stopped
+  // redirect is called at some point to test the safety of scoped_estream_redirect
+  struct TestThread {
+    TestThread() : t_{nullptr}, stop_{false} {
+      auto thread_f = [this] {
+        while( !this->stop_ ) {
+          std::cout << "x" << std::flush;
+          std::this_thread::sleep_for(std::chrono::microseconds(50));
+        } };
+      t_ = new std::thread(std::move(thread_f));
+    }
+    ~TestThread() {
+      delete t_;
+    }
+    void stop() { stop_ = 1; }
+    void join() {
+      py::gil_scoped_release gil_lock;
+      t_->join();
+    }
+    void sleep() {
+      py::gil_scoped_release gil_lock;
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+    std::thread * t_;
+    std::atomic<bool> stop_;
+  };
+
+  py::class_<TestThread>(m, "TestThread")
+      .def(py::init<>())
+      .def("stop", &TestThread::stop)
+      .def("join", &TestThread::join)
+      .def("sleep", &TestThread::sleep);
+
+}
+

tests/test_thread.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+import pytest
+from pybind11_tests import test_threading as m
+from pybind11_tests import iostream
+import time
+
+def test_threading():
+  with iostream.ostream_redirect(stdout=True, stderr=False):
+    # start some threads
+    threads = []
+
+    # start some threads
+    for j in range(20):
+      threads.append( m.TestThread() )
+
+    # give the threads some time to fail
+    threads[0].sleep()
+
+    # stop all the threads
+    for t in threads:
+      t.stop()
+
+    for t in threads:
+      t.join()
+
+  # if a thread segfaults, we don't get here
+  assert True
+