test: Add a mechanism for creating singletons in tests

test/BUILD

@@ -29,6 +29,7 @@ envoy_cc_test_library(
         "//source/common/event:libevent_lib",
         "//test/mocks/access_log:access_log_mocks",
         "//test/test_common:environment_lib",
+        "//test/test_common:global_lib",
         "//test/test_common:printers_lib",
     ] + select({
         "//bazel:disable_signal_trace": [],

test/common/http/conn_manager_impl_test.cc

@@ -55,12 +55,11 @@ using testing::Ref;
 using testing::Return;
 using testing::ReturnRef;
 using testing::Sequence;
-using testing::Test;
 
 namespace Envoy {
 namespace Http {
 
-class HttpConnectionManagerImplTest : public Test, public ConnectionManagerConfig {
+class HttpConnectionManagerImplTest : public testing::Test, public ConnectionManagerConfig {
 public:
   struct RouteConfigProvider : public Router::RouteConfigProvider {
     RouteConfigProvider(TimeSource& time_source) : time_source_(time_source) {}

test/common/network/connection_impl_test.cc

@@ -36,7 +36,6 @@ using testing::Return;
 using testing::SaveArg;
 using testing::Sequence;
 using testing::StrictMock;
-using testing::Test;
 
 namespace Envoy {
 namespace Network {

test/common/tracing/http_tracer_impl_test.cc

@@ -29,7 +29,6 @@ using testing::NiceMock;
 using testing::Return;
 using testing::ReturnPointee;
 using testing::ReturnRef;
-using testing::Test;
 
 namespace Envoy {
 namespace Tracing {
@@ -324,7 +323,7 @@ TEST(HttpNullTracerTest, BasicFunctionality) {
   EXPECT_NE(nullptr, span_ptr->spawnChild(config, "foo", SystemTime()));
 }
 
-class HttpTracerImplTest : public Test {
+class HttpTracerImplTest : public testing::Test {
 public:
   HttpTracerImplTest() {
     driver_ = new MockDriver();

test/extensions/filters/network/thrift_proxy/decoder_test.cc

@@ -26,7 +26,6 @@ using testing::Return;
 using testing::ReturnRef;
 using testing::SetArgReferee;
 using testing::StrictMock;
-using testing::Test;
 using testing::TestParamInfo;
 using testing::TestWithParam;
 using testing::Values;
@@ -206,7 +205,7 @@ INSTANTIATE_TEST_CASE_P(NonValueProtocolStates, DecoderStateMachineNonValueTest,
                                ProtocolState::SetBegin, ProtocolState::SetEnd),
                         protoStateParamToString);
 
-class DecoderStateMachineTest : public DecoderStateMachineTestBase, public Test {};
+class DecoderStateMachineTest : public DecoderStateMachineTestBase, public testing::Test {};
 
 class DecoderStateMachineValueTest : public DecoderStateMachineTestBase,
                                      public TestWithParam<FieldType> {};

test/extensions/filters/network/thrift_proxy/route_matcher_test.cc

@@ -10,7 +10,6 @@
 #include "gtest/gtest.h"
 
 using testing::_;
-using testing::Test;
 
 namespace Envoy {
 namespace Extensions {

test/extensions/filters/network/thrift_proxy/router_test.cc

@@ -29,7 +29,6 @@ using testing::NiceMock;
 using testing::Ref;
 using testing::Return;
 using testing::ReturnRef;
-using testing::Test;
 using testing::TestWithParam;
 using testing::Values;
 
@@ -330,7 +329,7 @@ class ThriftRouterTestBase {
   NiceMock<Network::MockClientConnection> upstream_connection_;
 };
 
-class ThriftRouterTest : public ThriftRouterTestBase, public Test {
+class ThriftRouterTest : public ThriftRouterTestBase, public testing::Test {
 public:
   ThriftRouterTest() {}
 };

test/extensions/filters/network/thrift_proxy/thrift_object_impl_test.cc

@@ -18,7 +18,6 @@ using testing::NiceMock;
 using testing::Ref;
 using testing::Return;
 using testing::ReturnRef;
-using testing::Test;
 using testing::TestWithParam;
 using testing::Values;
 
@@ -144,7 +143,7 @@ class ThriftObjectImplTestBase {
   Buffer::OwnedImpl buffer_;
 };
 
-class ThriftObjectImplTest : public ThriftObjectImplTestBase, public Test {};
+class ThriftObjectImplTest : public ThriftObjectImplTestBase, public testing::Test {};
 
 // Test parsing an empty struct (just a stop field).
 TEST_F(ThriftObjectImplTest, ParseEmptyStruct) {

test/extensions/tracers/common/ot/opentracing_driver_impl_test.cc

@@ -11,8 +11,6 @@
 #include "opentracing/mocktracer/in_memory_recorder.h"
 #include "opentracing/mocktracer/tracer.h"
 
-using testing::Test;
-
 namespace Envoy {
 namespace Extensions {
 namespace Tracers {
@@ -46,7 +44,7 @@ class TestDriver : public OpenTracingDriver {
   std::shared_ptr<opentracing::mocktracer::MockTracer> tracer_;
 };
 
-class OpenTracingDriverTest : public Test {
+class OpenTracingDriverTest : public testing::Test {
 public:
   void
   setupValidDriver(OpenTracingDriver::PropagationMode propagation_mode =

test/extensions/tracers/datadog/datadog_tracer_impl_test.cc

@@ -32,14 +32,13 @@ using testing::Invoke;
 using testing::NiceMock;
 using testing::Return;
 using testing::ReturnRef;
-using testing::Test;
 
 namespace Envoy {
 namespace Extensions {
 namespace Tracers {
 namespace Datadog {
 
-class DatadogDriverTest : public Test {
+class DatadogDriverTest : public testing::Test {
 public:
   void setup(envoy::config::trace::v2::DatadogConfig& datadog_config, bool init_timer) {
     ON_CALL(cm_, httpAsyncClientForCluster("fake_cluster"))

test/extensions/tracers/dynamic_ot/dynamic_opentracing_driver_impl_test.cc

@@ -13,14 +13,12 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using testing::Test;
-
 namespace Envoy {
 namespace Extensions {
 namespace Tracers {
 namespace DynamicOt {
 
-class DynamicOpenTracingDriverTest : public Test {
+class DynamicOpenTracingDriverTest : public testing::Test {
 public:
   void setup(const std::string& library, const std::string& tracer_config) {
     driver_ = std::make_unique<DynamicOpenTracingDriver>(stats_, library, tracer_config);

test/extensions/tracers/lightstep/lightstep_tracer_impl_test.cc

@@ -33,14 +33,13 @@ using testing::Invoke;
 using testing::NiceMock;
 using testing::Return;
 using testing::ReturnRef;
-using testing::Test;
 
 namespace Envoy {
 namespace Extensions {
 namespace Tracers {
 namespace Lightstep {
 
-class LightStepDriverTest : public Test {
+class LightStepDriverTest : public testing::Test {
 public:
   void setup(envoy::config::trace::v2::LightstepConfig& lightstep_config, bool init_timer,
              Common::Ot::OpenTracingDriver::PropagationMode propagation_mode =

test/extensions/tracers/zipkin/zipkin_tracer_impl_test.cc

@@ -31,14 +31,13 @@ using testing::Invoke;
 using testing::NiceMock;
 using testing::Return;
 using testing::ReturnRef;
-using testing::Test;
 
 namespace Envoy {
 namespace Extensions {
 namespace Tracers {
 namespace Zipkin {
 
-class ZipkinDriverTest : public Test {
+class ZipkinDriverTest : public testing::Test {
 public:
   ZipkinDriverTest() : time_source_(test_time_.timeSystem()) {}
 

test/extensions/transport_sockets/alts/tsi_frame_protector_test.cc

@@ -16,14 +16,13 @@ using testing::InSequence;
 using testing::Invoke;
 using testing::NiceMock;
 using testing::SaveArg;
-using testing::Test;
 using namespace std::string_literals;
 
 /**
  * Test with fake frame protector. The protected frame header is 4 byte length (little endian,
  * include header itself) and following the body.
  */
-class TsiFrameProtectorTest : public Test {
+class TsiFrameProtectorTest : public testing::Test {
 public:
   TsiFrameProtectorTest()
       : raw_frame_protector_(tsi_create_fake_frame_protector(nullptr)),

test/extensions/transport_sockets/alts/tsi_handshaker_test.cc

@@ -16,7 +16,6 @@ using testing::InSequence;
 using testing::Invoke;
 using testing::NiceMock;
 using testing::SaveArg;
-using testing::Test;
 
 class MockTsiHandshakerCallbacks : public TsiHandshakerCallbacks {
 public:
@@ -33,7 +32,7 @@ class MockTsiHandshakerCallbacks : public TsiHandshakerCallbacks {
   }
 };
 
-class TsiHandshakerTest : public Test {
+class TsiHandshakerTest : public testing::Test {
 public:
   TsiHandshakerTest()
       : server_handshaker_({tsi_create_fake_handshaker(0)}, dispatcher_),

test/test_common/BUILD

@@ -131,6 +131,24 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_test_library(
+    name = "global_lib",
+    srcs = ["global.cc"],
+    hdrs = ["global.h"],
+    deps = [
+        "//source/common/common:assert_lib",
+        "//source/common/common:thread_lib",
+    ],
+)
+
+envoy_cc_test(
+    name = "global_test",
+    srcs = ["global_test.cc"],
+    deps = [
+        ":global_lib",
+    ],
+)
+
 envoy_cc_test_library(
     name = "test_time_lib",
     srcs = ["test_time.cc"],

test/test_common/global.cc

@@ -0,0 +1,70 @@
+#include "test/test_common/global.h"
+
+#include "common/common/assert.h"
+
+namespace Envoy {
+namespace Test {
+
+Globals& Globals::instance() {
+  static Globals* h = new Globals;
+  return *h;
+}
+
+std::string Globals::describeActiveSingletonsHelper() {
+  std::string ret;
+  Thread::ReleasableLockGuard map_lock(map_mutex_);
+  for (auto& p : singleton_map_) {
+    std::unique_ptr<Singleton>& singleton = p.second;
+    ASSERT(singleton != nullptr);
+    if (singleton->ptr_ != nullptr) {
+      absl::StrAppend(&ret, "Unexpected active singleton: ", p.first, "\n");
+    }
+  }
+  return ret;
+}
+
+Globals::Singleton& Globals::get(const std::string& type_name, MakeObjectFn make_object) {
+  Thread::ReleasableLockGuard map_lock(map_mutex_);
+  std::unique_ptr<Singleton>& singleton = singleton_map_[type_name];
+
+  if (singleton == nullptr) {
+    // The first time constructing this object, we'll be constructing the
+    // Singleton for the first time, populating it with a fresh instance,
+    // so no need to take the singleton's mutex. But we do need to hold
+    // the map mutex as we are installing the singleton object in the
+    // singleton_map.
+    singleton = std::make_unique<Singleton>(make_object());
+    map_lock.release();
+    return *singleton;
+  }
+
+  // Subsequent accesses will must lock the singleton's mutex to safely populate
+  // .second. However, we can relinquish map_mutex_ as we are no longer
+  // modifying the map; just the .second of the MutexSingleton pointed to by the
+  // map.
+  Thread::LockGuard singleton_lock(singleton->mutex_);
+  if (singleton->ptr_ == nullptr) {
+    ASSERT(singleton->ref_count_ == 0);
+    singleton->ptr_ = make_object();
+  }
+  ++singleton->ref_count_;
+  return *singleton;
+}
+
+void Globals::Singleton::releaseHelper(DeleteObjectFn delete_object) {
+  void* obj_to_delete = nullptr;
+  {
+    Thread::LockGuard singleton_lock(mutex_);
+    ASSERT(ptr_ != nullptr);
+    if (--ref_count_ == 0) {
+      obj_to_delete = ptr_;
+      ptr_ = nullptr;
+    }
+  }
+  if (obj_to_delete != nullptr) {
+    delete_object(obj_to_delete);
+  }
+}
+
+} // namespace Test
+} // namespace Envoy