Add GoogleTest value printers for ExpressionType and SolverExitCondition

include/sleipnir/autodiff/Expression.hpp

@@ -12,28 +12,9 @@
 #include "sleipnir/IntrusiveSharedPtr.hpp"
 #include "sleipnir/Pool.hpp"
 #include "sleipnir/SymbolExports.hpp"
+#include "sleipnir/autodiff/ExpressionType.hpp"
 
-namespace sleipnir {
-
-/**
- * Expression type.
- *
- * Used for autodiff caching.
- */
-enum class ExpressionType {
-  /// There is no expression.
-  kNone,
-  /// The expression is a constant.
-  kConstant,
-  /// The expression is composed of linear and lower-order operators.
-  kLinear,
-  /// The expression is composed of quadratic and lower-order operators.
-  kQuadratic,
-  /// The expression is composed of nonlinear and lower-order operators.
-  kNonlinear
-};
-
-namespace detail {
+namespace sleipnir::detail {
 
 struct SLEIPNIR_DLLEXPORT Expression;
 
@@ -442,7 +423,9 @@ SLEIPNIR_DLLEXPORT ExpressionPtr tan(  // NOLINT
  */
 SLEIPNIR_DLLEXPORT ExpressionPtr tanh(const ExpressionPtr& x);
 
-}  // namespace detail
+}  // namespace sleipnir::detail
+
+namespace sleipnir {
 
 // FIXME: Doxygen is confused:
 //

include/sleipnir/autodiff/ExpressionType.hpp

@@ -0,0 +1,35 @@
+// Copyright (c) Sleipnir contributors
+
+#pragma once
+
+#include <iosfwd>
+
+namespace sleipnir {
+
+/**
+ * Expression type.
+ *
+ * Used for autodiff caching.
+ */
+enum class ExpressionType {
+  /// There is no expression.
+  kNone,
+  /// The expression is a constant.
+  kConstant,
+  /// The expression is composed of linear and lower-order operators.
+  kLinear,
+  /// The expression is composed of quadratic and lower-order operators.
+  kQuadratic,
+  /// The expression is composed of nonlinear and lower-order operators.
+  kNonlinear
+};
+
+/**
+ * GoogleTest value formatter for ExpressionType.
+ *
+ * @param type ExpressionType to print.
+ * @param os Output stream to which to print.
+ */
+void PrintTo(const ExpressionType& type, std::ostream* os);
+
+}  // namespace sleipnir

include/sleipnir/optimization/SolverExitCondition.hpp

@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <iosfwd>
+
 namespace sleipnir {
 
 /**
@@ -35,4 +37,12 @@ enum class SolverExitCondition {
   kMaxWallClockTimeExceeded = -7
 };
 
+/**
+ * GoogleTest value formatter for SolverExitCondition.
+ *
+ * @param cond SolverExitCondition to print.
+ * @param os Output stream to which to print.
+ */
+void PrintTo(const SolverExitCondition& cond, std::ostream* os);
+
 }  // namespace sleipnir

src/autodiff/Expression.cpp

@@ -5,14 +5,6 @@
 #include <cmath>
 #include <numbers>
 
-namespace sleipnir {
-
-// Instantiate Expression pool in Expression.cpp instead to avoid ODR violation
-template EXPORT_TEMPLATE_DEFINE(SLEIPNIR_DLLEXPORT)
-    PoolAllocator<detail::Expression> GlobalPoolAllocator<detail::Expression>();
-
-}  // namespace sleipnir
-
 namespace sleipnir::detail {
 
 namespace {
@@ -846,3 +838,11 @@ ExpressionPtr tanh(const ExpressionPtr& x) {
 }
 
 }  // namespace sleipnir::detail
+
+namespace sleipnir {
+
+// Instantiate Expression pool in Expression.cpp instead to avoid ODR violation
+template EXPORT_TEMPLATE_DEFINE(SLEIPNIR_DLLEXPORT)
+    PoolAllocator<detail::Expression> GlobalPoolAllocator<detail::Expression>();
+
+}  // namespace sleipnir

src/autodiff/ExpressionType.cpp

@@ -0,0 +1,31 @@
+// Copyright (c) Sleipnir contributors
+
+#include "sleipnir/autodiff/ExpressionType.hpp"
+
+#include <ostream>
+
+namespace sleipnir {
+
+void PrintTo(const ExpressionType& type, std::ostream* os) {
+  using enum sleipnir::ExpressionType;
+
+  switch (type) {
+    case kNone:
+      *os << "ExpressionType::kNone";
+      break;
+    case kConstant:
+      *os << "ExpressionType::kConstant";
+      break;
+    case kLinear:
+      *os << "ExpressionType::kLinear";
+      break;
+    case kQuadratic:
+      *os << "ExpressionType::kQuadratic";
+      break;
+    case kNonlinear:
+      *os << "ExpressionType::kNonlinear";
+      break;
+  }
+}
+
+}  // namespace sleipnir

src/optimization/SolverExitCondition.cpp

@@ -0,0 +1,46 @@
+// Copyright (c) Sleipnir contributors
+
+#include "sleipnir/optimization/SolverExitCondition.hpp"
+
+#include <ostream>
+
+namespace sleipnir {
+
+void PrintTo(const SolverExitCondition& cond, std::ostream* os) {
+  using enum sleipnir::SolverExitCondition;
+
+  switch (cond) {
+    case kSuccess:
+      *os << "SolverExitCondition::kSuccess";
+      break;
+    case kSolvedToAcceptableTolerance:
+      *os << "SolverExitCondition::kSolvedToAcceptableTolerance";
+      break;
+    case kCallbackRequestedStop:
+      *os << "SolverExitCondition::kCallbackRequestedStop";
+      break;
+    case kTooFewDOFs:
+      *os << "SolverExitCondition::kTooFewDOFs";
+      break;
+    case kLocallyInfeasible:
+      *os << "SolverExitCondition::kLocallyInfeasible";
+      break;
+    case kBadSearchDirection:
+      *os << "SolverExitCondition::kBadSearchDirection";
+      break;
+    case kMaxSearchDirectionTooSmall:
+      *os << "SolverExitCondition::kMaxSearchDirectionTooSmall";
+      break;
+    case kDivergingIterates:
+      *os << "SolverExitCondition::kDivergingIterates";
+      break;
+    case kMaxIterationsExceeded:
+      *os << "SolverExitCondition::kMaxIterationsExceeded";
+      break;
+    case kMaxWallClockTimeExceeded:
+      *os << "SolverExitCondition::kMaxWallClockTimeExceeded";
+      break;
+  }
+}
+
+}  // namespace sleipnir