WIP: rebase pipe redirect onto current redirect interface

src/catch2/internal/catch_output_redirect.cpp

@@ -17,12 +17,18 @@
 #include <iosfwd>
 #include <sstream>
 
-#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <thread>
+#endif
+
+#if defined( CATCH_CONFIG_NEW_CAPTURE ) || defined(CATCH_CONFIG_USE_ASYNC)
 # if defined( _MSC_VER )
 # include <io.h> //_dup and _dup2
+# include <fcntl.h> // _O_BINARY
 # define dup _dup
 # define dup2 _dup2
 # define fileno _fileno
+# define close _close
 # else
 # include <unistd.h> // dup and dup2
 # endif
@@ -48,13 +54,13 @@ namespace Catch {
  * that the underlying stream's rdbuf aren't changed by other
  * users.
  */
- class RedirectedStreamNew {
+ class RedirectedStream {
  std::ostream& m_originalStream;
  std::ostream& m_redirectionStream;
  std::streambuf* m_prevBuf;
 
  public:
- RedirectedStreamNew( std::ostream& originalStream,
+ RedirectedStream( std::ostream& originalStream,
  std::ostream& redirectionStream ):
  m_originalStream( originalStream ),
  m_redirectionStream( redirectionStream ),
@@ -72,7 +78,7 @@ namespace Catch {
  */
  class StreamRedirect : public OutputRedirect {
  ReusableStringStream m_redirectedOut, m_redirectedErr;
- RedirectedStreamNew m_cout, m_cerr, m_clog;
+ RedirectedStream m_cout, m_cerr, m_clog;
 
  public:
  StreamRedirect():
@@ -244,6 +250,246 @@ namespace Catch {
 
 #endif // CATCH_CONFIG_NEW_CAPTURE
 
+
+#if defined( CATCH_CONFIG_USE_ASYNC )
+
+ struct UniqueFileDescriptor final {
+ constexpr UniqueFileDescriptor() noexcept;
+ explicit UniqueFileDescriptor( int value ) noexcept;
+
+ UniqueFileDescriptor( UniqueFileDescriptor const& ) = delete;
+ constexpr UniqueFileDescriptor(
+ UniqueFileDescriptor&& other ) noexcept;
+
+ ~UniqueFileDescriptor() noexcept;
+
+ UniqueFileDescriptor&
+ operator=( UniqueFileDescriptor const& ) = delete;
+ UniqueFileDescriptor&
+ operator=( UniqueFileDescriptor&& other ) noexcept;
+
+ constexpr int get();
+
+ private:
+ int m_value;
+ };
+
+ struct OutputFileRedirector final {
+ explicit OutputFileRedirector( std::FILE* file,
+ std::string& result );
+
+ OutputFileRedirector( OutputFileRedirector const& ) = delete;
+ OutputFileRedirector( OutputFileRedirector&& ) = delete;
+
+ ~OutputFileRedirector() noexcept;
+
+ OutputFileRedirector&
+ operator=( OutputFileRedirector const& ) = delete;
+ OutputFileRedirector& operator=( OutputFileRedirector&& ) = delete;
+
+ private:
+ std::FILE* m_file;
+ int m_fd;
+ UniqueFileDescriptor m_previous;
+ std::thread m_readThread;
+ };
+
+ struct PipeRedirect final {
+ PipeRedirect( std::string& output, std::string& error ):
+ m_output{ stdout, output }, m_error{ stderr, error } {}
+
+ private:
+ OutputFileRedirector m_output;
+ OutputFileRedirector m_error;
+ };
+
+ class PipeRedirectWrapper : public OutputRedirect {
+ void activateImpl() override { m_redirect = Detail::make_unique<PipeRedirect>( m_stdout, m_stderr ); }
+ void deactivateImpl() override { m_redirect.reset(); }
+ std::string getStdout() override { return m_stdout; }
+ std::string getStderr() override { return m_stderr; }
+ void clearBuffers() override {
+ m_stdout.clear();
+ m_stderr.clear();
+ }
+ Detail::unique_ptr<PipeRedirect> m_redirect;
+ std::string m_stdout, m_stderr;
+ };
+
+ static inline void close_or_throw( int descriptor ) {
+ if ( close( descriptor ) ) {
+ CATCH_INTERNAL_ERROR( "close-or-throw" );
+ //CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+ }
+ }
+
+ static inline int dup_or_throw( int descriptor ) {
+ int result{ dup( descriptor ) };
+
+ if ( result == -1 ) {
+ CATCH_INTERNAL_ERROR( "dup-or-throw" );
+ //CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+ }
+
+ return result;
+ }
+
+ static inline int dup2_or_throw( int sourceDescriptor,
+ int destinationDescriptor ) {
+ int result{ dup2( sourceDescriptor, destinationDescriptor ) };
+
+ if ( result == -1 ) {
+ CATCH_INTERNAL_ERROR( "dup2-or-throw" );
+ //CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+ }
+
+ return result;
+ }
+
+ static inline int fileno_or_throw( std::FILE* file ) {
+ int result{ fileno( file ) };
+
+ if ( result == -1 ) {
+ CATCH_INTERNAL_ERROR( "fileno-or-throw" );
+ //CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+ }
+
+ return result;
+ }
+
+ static inline void pipe_or_throw( int descriptors[2] ) {
+# if defined( _MSC_VER )
+ constexpr int defaultPipeSize{ 0 };
+
+ int result{ _pipe( descriptors, defaultPipeSize, _O_BINARY ) };
+# else
+ int result{ pipe( descriptors ) };
+# endif
+
+ if ( result ) {
+ CATCH_INTERNAL_ERROR( "pipe-or-throw" );
+ // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+ }
+ }
+
+ static inline size_t
+ read_or_throw( int descriptor, void* buffer, size_t size ) {
+# if defined( _MSC_VER )
+ int result{
+ _read( descriptor, buffer, static_cast<unsigned>( size ) ) };
+# else
+ ssize_t result{ read( descriptor, buffer, size ) };
+# endif
+
+ if ( result == -1 ) {
+ CATCH_INTERNAL_ERROR( "read-or-throw" );
+ //CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+ }
+
+ return static_cast<size_t>( result );
+ }
+
+ static inline void fflush_or_throw( std::FILE* file ) {
+ if ( std::fflush( file ) ) {
+ CATCH_INTERNAL_ERROR( "fflush-or-throw" );
+ // CATCH_SYSTEM_ERROR( errno, std::generic_category() );
+ }
+ }
+
+ constexpr UniqueFileDescriptor::UniqueFileDescriptor() noexcept:
+ m_value{} {}
+
+ UniqueFileDescriptor::UniqueFileDescriptor( int value ) noexcept:
+ m_value{ value } {}
+
+ constexpr UniqueFileDescriptor::UniqueFileDescriptor(
+ UniqueFileDescriptor&& other ) noexcept:
+ m_value{ other.m_value } {
+ other.m_value = 0;
+ }
+
+ UniqueFileDescriptor::~UniqueFileDescriptor() noexcept {
+ if ( m_value == 0 ) { return; }
+
+ close_or_throw(
+ m_value ); // std::terminate on failure (due to noexcept)
+ }
+
+ UniqueFileDescriptor& UniqueFileDescriptor::operator=(
+ UniqueFileDescriptor&& other ) noexcept {
+ std::swap( m_value, other.m_value );
+ return *this;
+ }
+
+ constexpr int UniqueFileDescriptor::get() { return m_value; }
+
+ static inline void
+ create_pipe( UniqueFileDescriptor& readDescriptor,
+ UniqueFileDescriptor& writeDescriptor ) {
+ readDescriptor = {};
+ writeDescriptor = {};
+
+ int descriptors[2];
+ pipe_or_throw( descriptors );
+
+ readDescriptor = UniqueFileDescriptor{ descriptors[0] };
+ writeDescriptor = UniqueFileDescriptor{ descriptors[1] };
+ }
+
+ static inline void read_thread( UniqueFileDescriptor&& file,
+ std::string& result ) {
+ std::string buffer{};
+ constexpr size_t bufferSize{ 4096 };
+ buffer.resize( bufferSize );
+ size_t sizeRead{};
+
+ while ( ( sizeRead = read_or_throw(
+ file.get(), &buffer[0], bufferSize ) ) != 0 ) {
+ result.append( buffer.data(), sizeRead );
+ }
+ }
+
+ OutputFileRedirector::OutputFileRedirector( FILE* file,
+ std::string& result ):
+ m_file{ file },
+ m_fd{ fileno_or_throw( m_file ) },
+ m_previous{ dup_or_throw( m_fd ) } {
+ fflush_or_throw( m_file );
+
+ UniqueFileDescriptor readDescriptor{};
+ UniqueFileDescriptor writeDescriptor{};
+ create_pipe( readDescriptor, writeDescriptor );
+
+ // Anonymous pipes have a limited buffer and require an active
+ // reader to ensure the writer does not become blocked. Use a
+ // separate thread to ensure the buffer does not get stuck full.
+ m_readThread =
+ std::thread{ [readDescriptor{ CATCH_MOVE( readDescriptor ) },
+ &result]() mutable {
+ read_thread( CATCH_MOVE( readDescriptor ), result );
+ } };
+
+ // Replace the stdout or stderr file descriptor with the write end
+ // of the pipe.
+ dup2_or_throw( writeDescriptor.get(), m_fd );
+ }
+
+ OutputFileRedirector::~OutputFileRedirector() noexcept {
+ fflush_or_throw(
+ m_file ); // std::terminate on failure (due to noexcept)
+
+ // Restore the original stdout or stderr file descriptor.
+ dup2_or_throw(
+ m_previous.get(),
+ m_fd ); // std::terminate on failure (due to noexcept)
+
+ if ( m_readThread.joinable() ) { m_readThread.join(); }
+ }
+
+
+#endif // CATCH_CONFIG_USE_ASYNC
+
+
  } // end namespace
 
  bool isRedirectAvailable( OutputRedirect::Kind kind ) {
@@ -255,6 +501,10 @@ namespace Catch {
 #if defined( CATCH_CONFIG_NEW_CAPTURE )
  case OutputRedirect::FileDescriptors:
  return true;
+#endif
+#if defined(CATCH_CONFIG_USE_ASYNC)
+ case OutputRedirect::Pipes:
+ return true;
 #endif
  default:
  return false;
@@ -267,7 +517,8 @@ namespace Catch {
 #if defined( CATCH_CONFIG_NEW_CAPTURE )
  return Detail::make_unique<FileRedirect>();
 #else
- return Detail::make_unique<StreamRedirect>();
+ //return Detail::make_unique<StreamRedirect>();
+ return Detail::make_unique<PipeRedirectWrapper>();
 #endif
  } else {
  return Detail::make_unique<NoopRedirect>();

src/catch2/internal/catch_output_redirect.hpp

@@ -25,8 +25,10 @@ namespace Catch {
  None,
  //! Redirect std::cout/std::cerr/std::clog streams internally
  Streams,
- //! Redirect the stdout/stderr file descriptors into files
+ //! Redirect the stdout/stderr file descriptors into temp files
  FileDescriptors,
+ //! Redirect the stdout/stderr file descriptors into anonymous pipes
+ Pipes,
  };
 
  virtual ~OutputRedirect(); // = default;