misc

Author: lperron

ortools/algorithms/python/BUILD.bazel

@@ -18,6 +18,8 @@ load("@pybind11_bazel//:build_defs.bzl", "pybind_extension")
 load("@rules_cc//cc:cc_library.bzl", "cc_library")
 load("@rules_python//python:py_test.bzl", "py_test")
 
+package(default_visibility = ["//visibility:public"])
+
 # knapsack_solver
 cc_library(
     name = "knapsack_solver_doc",

ortools/algorithms/samples/knapsack.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 """A simple knapsack problem."""
+
 # [START program]
 # [START import]
 from ortools.algorithms.python import knapsack_solver

ortools/port/BUILD.bazel

@@ -69,3 +69,12 @@ cc_library(
         "@abseil-cpp//absl/log:check",
     ],
 )
+
+cc_test(
+    name = "scoped_std_stream_capture_test",
+    srcs = ["scoped_std_stream_capture_test.cc"],
+    deps = [
+        ":scoped_std_stream_capture",
+        "//ortools/base:gmock_main",
+    ],
+)

ortools/port/scoped_std_stream_capture.cc

@@ -13,51 +13,23 @@
 
 #include "ortools/port/scoped_std_stream_capture.h"
 
-#ifdef OPERATIONS_RESEARCH_OUTPUT_CAPTURE_SUPPORTED
-
 #include <string>
 
 #include "absl/log/check.h"
-#include "testing/base/public/googletest.h"
 
 namespace operations_research {
 
+const bool ScopedStdStreamCapture::kIsSupported = false;
+
 ScopedStdStreamCapture::ScopedStdStreamCapture(const CapturedStream stream)
-    : stream_(stream) {
-  switch (stream) {
-    case CapturedStream::kStdout:
-      CaptureTestStdout();
-      break;
-    case CapturedStream::kStderr:
-      CaptureTestStderr();
-      break;
-  }
-}
+    : stream_(stream) {}
 
-ScopedStdStreamCapture::~ScopedStdStreamCapture() {
-  if (!capture_released_) {
-    switch (stream_) {
-      case CapturedStream::kStdout:
-        GetCapturedTestStdout();
-        break;
-      case CapturedStream::kStderr:
-        GetCapturedTestStderr();
-        break;
-    }
-  }
-}
+ScopedStdStreamCapture::~ScopedStdStreamCapture() {}
 
 std::string ScopedStdStreamCapture::StopCaptureAndReturnContents() && {
   CHECK(!capture_released_) << "Can't call this function twice.";
   capture_released_ = true;
-  switch (stream_) {
-    case CapturedStream::kStdout:
-      return GetCapturedTestStdout();
-    case CapturedStream::kStderr:
-      return GetCapturedTestStderr();
-  }
+  return {};
 }
 
 }  // namespace operations_research
-
-#endif  // OPERATIONS_RESEARCH_OUTPUT_CAPTURE_SUPPORTED

ortools/port/scoped_std_stream_capture.h

@@ -14,4 +14,64 @@
 #ifndef ORTOOLS_PORT_SCOPED_STD_STREAM_CAPTURE_H_
 #define ORTOOLS_PORT_SCOPED_STD_STREAM_CAPTURE_H_
 
+#include <string>
+
+namespace operations_research {
+
+// The stream to capture for
+enum class CapturedStream { kStdout, kStderr };
+
+// RAII class that captures stdout & stderr in tests until either
+// StopCaptureAndReturnContents() is called or it is destroyed.
+//
+// This capture is not available in all configurations, thus the `kIsSupported`
+// constant should be used in tests to disable the checks on the captured
+// result.
+//
+// Usage:
+//
+//   TEST(MyTest, Something) {
+//     ...
+//     ScopedStdStreamCapture stdout_capture(CapturedStream::kStdout);
+//     ... some code that may return ...
+//     if (ScopedStdStreamCapture::kIsSupported) {
+//       EXPECT_THAT(std::move(stdout_capture).StopCaptureAndReturnContents(),
+//                   HasSubstr("..."));
+//     }
+//   }
+class ScopedStdStreamCapture {
+ public:
+  // True if the capture is supported by the configuration.
+  //
+  // When false, no capture occurs and StopCaptureAndReturnContents() returns an
+  // empty string.
+  static const bool kIsSupported;
+
+  // Starts the capture.
+  explicit ScopedStdStreamCapture(CapturedStream stream);
+
+  ScopedStdStreamCapture(const ScopedStdStreamCapture&) = delete;
+  ScopedStdStreamCapture& operator=(const ScopedStdStreamCapture&) = delete;
+  ScopedStdStreamCapture& operator=(ScopedStdStreamCapture&&) = delete;
+  ScopedStdStreamCapture(ScopedStdStreamCapture&& other) = delete;
+
+  // Releases the capture if needed.
+  ~ScopedStdStreamCapture();
+
+  // Stops the capture and returns the captured data.
+  //
+  // Returns an empty string when kIsSupported is false.
+  //
+  // This function can only be called once. This function requires moving *this
+  // so that the user gets a ClangTidy error (bugprone-use-after-move) when they
+  // try to use this function more than once.
+  std::string StopCaptureAndReturnContents() &&;
+
+ private:
+  const CapturedStream stream_;
+  bool capture_released_ = false;
+};
+
+}  // namespace operations_research
+
 #endif  // ORTOOLS_PORT_SCOPED_STD_STREAM_CAPTURE_H_

ortools/port/scoped_std_stream_capture_test.cc

@@ -21,18 +21,24 @@
 namespace operations_research {
 namespace {
 
-#ifdef OPERATIONS_RESEARCH_OUTPUT_CAPTURE_SUPPORTED
-
 TEST(ScopedStdStreamCaptureTest, CaptureStdout) {
   ScopedStdStreamCapture capture(CapturedStream::kStdout);
   std::cout << "something";
-  EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(), "something");
+  if (ScopedStdStreamCapture::kIsSupported) {
+    EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(), "something");
+  } else {
+    EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(), "");
+  }
 }
 
 TEST(ScopedStdStreamCaptureTest, CaptureStderr) {
   ScopedStdStreamCapture capture(CapturedStream::kStderr);
   std::cerr << "something";
-  EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(), "something");
+  if (ScopedStdStreamCapture::kIsSupported) {
+    EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(), "something");
+  } else {
+    EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(), "");
+  }
 }
 
 TEST(ScopedStdStreamCaptureTest, EarlyExitThenCaptureStdout) {
@@ -43,8 +49,10 @@ TEST(ScopedStdStreamCaptureTest, EarlyExitThenCaptureStdout) {
   {
     ScopedStdStreamCapture capture(CapturedStream::kStdout);
     std::cout << "another thing";
-    EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(),
-              "another thing");
+    if (ScopedStdStreamCapture::kIsSupported) {
+      EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(),
+                "another thing");
+    }
   }
 }
 
@@ -56,8 +64,10 @@ TEST(ScopedStdStreamCaptureTest, EarlyExitThenCaptureStderr) {
   {
     ScopedStdStreamCapture capture(CapturedStream::kStderr);
     std::cerr << "another thing";
-    EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(),
-              "another thing");
+    if (ScopedStdStreamCapture::kIsSupported) {
+      EXPECT_EQ(std::move(capture).StopCaptureAndReturnContents(),
+                "another thing");
+    }
   }
 }
 
@@ -68,8 +78,12 @@ TEST(ScopedStdStreamCaptureTest, CaptureStdoutAndStderr) {
   std::cout << "stdout";
   std::cerr << "stderr";
 
-  EXPECT_EQ(std::move(stdout_capture).StopCaptureAndReturnContents(), "stdout");
-  EXPECT_EQ(std::move(stderr_capture).StopCaptureAndReturnContents(), "stderr");
+  if (ScopedStdStreamCapture::kIsSupported) {
+    EXPECT_EQ(std::move(stdout_capture).StopCaptureAndReturnContents(),
+              "stdout");
+    EXPECT_EQ(std::move(stderr_capture).StopCaptureAndReturnContents(),
+              "stderr");
+  }
 }
 
 TEST(ScopedStdStreamCaptureDeathTest, TwoCalls) {
@@ -89,14 +103,5 @@ TEST(ScopedStdStreamCaptureDeathTest, TwoCalls) {
       "twice");
 }
 
-#else  // OPERATIONS_RESEARCH_OUTPUT_CAPTURE_SUPPORTED
-
-TEST(ScopedStdStreamCaptureTest, NotSupported) {
-  // This unit test is intentionally empty since iOS test fails when zero tests
-  // are executed.
-}
-
-#endif  // OPERATIONS_RESEARCH_OUTPUT_CAPTURE_SUPPORTED
-
 }  // namespace
 }  // namespace operations_research