Add testvalue test facility for velox (#2101)

Summary:
Add testvalue test facility for velox which can help to capture and manipulate the production internal state for unit test purpose.

Pull Request resolved: #2101

Reviewed By: mbasmanova

Differential Revision: D38118388

Pulled By: xiaoxmeng

fbshipit-source-id: 40409af4f0b627ba30ed5aab96914a247ab94db3

Author: xiaoxmeng

velox/common/CMakeLists.txt

@@ -19,3 +19,4 @@ add_subdirectory(memory)
 add_subdirectory(process)
 add_subdirectory(serialization)
 add_subdirectory(time)
+add_subdirectory(testutil)

velox/common/testutil/CMakeLists.txt

@@ -0,0 +1,20 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_test_util TestValue.cpp)
+target_link_libraries(velox_test_util velox_common_base)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()

velox/common/testutil/TestValue.cpp

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/common/testutil/TestValue.h"
+
+namespace facebook::velox::common::testutil {
+
+std::mutex TestValue::mutex_;
+bool TestValue::enabled_ = false;
+std::unordered_map<std::string, TestValue::Callback> TestValue::injectionMap_;
+
+#ifndef NDEBUG
+void TestValue::enable() {
+  std::lock_guard<std::mutex> l(mutex_);
+  enabled_ = true;
+}
+
+void TestValue::disable() {
+  std::lock_guard<std::mutex> l(mutex_);
+  enabled_ = false;
+}
+
+bool TestValue::enabled() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return enabled_;
+}
+
+void TestValue::clear(const std::string& injectionPoint) {
+  std::lock_guard<std::mutex> l(mutex_);
+  injectionMap_.erase(injectionPoint);
+}
+
+void TestValue::adjust(const std::string& injectionPoint, void* testData) {
+  Callback injectionCb;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    if (!enabled_ || injectionMap_.count(injectionPoint) == 0) {
+      return;
+    }
+    injectionCb = injectionMap_[injectionPoint];
+  }
+  injectionCb(testData);
+}
+#else
+void TestValue::enable() {}
+void TestValue::disable() {}
+bool TestValue::enabled() {
+  return false;
+}
+void TestValue::clear(const std::string& injectionPoint) {}
+void TestValue::adjust(const std::string& injectionPoint, void* testData) {}
+#endif
+
+} // namespace facebook::velox::common::testutil

velox/common/testutil/TestValue.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::common::testutil {
+
+/// The test facility used to inject callback hook in production execution point
+/// to get, change and verify various internal execution state for unit test.
+/// The hook injected in production code path will be opt out in release build
+/// and only be executed in debug build. Please follow the example in
+/// TestValueTest.cpp for use.
+class TestValue {
+ public:
+  /// Enable the test value injection.
+  static void enable();
+  /// Disable the test value injection.
+  static void disable();
+  /// Check if the test value injection is enabled or not.
+  static bool enabled();
+
+  /// Invoked by the test code to register a callback hook at the specified
+  /// execution point. 'injectionPoint' is a string to identify the execution
+  /// point which could be formed by concatenating namespace, class name, method
+  /// name plus optional actual action within a method. 'injectionCb' is the
+  /// injected callback hook.
+  template <typename T>
+  static void set(
+      const std::string& injectionPoint,
+      std::function<void(T*)> injectionCb);
+
+  /// Invoked by the test code to unregister a callback hook at the specified
+  /// execution point.
+  static void clear(const std::string& injectionPoint);
+
+  /// Invoked by the production code to try to invoke the test callback hook
+  /// with 'testData' if there is one registered at the specified execution
+  /// point. 'testData' can capture the production execution state.
+  static void adjust(const std::string& injectionPoint, void* testData);
+
+ private:
+  using Callback = std::function<void(void*)>;
+
+  static std::mutex mutex_;
+  static bool enabled_;
+  static std::unordered_map<std::string, Callback> injectionMap_;
+};
+
+class ScopedTestValue {
+ public:
+  template <typename T>
+  ScopedTestValue(const std::string& point, std::function<void(T*)> callback)
+      : point_(point) {
+    VELOX_CHECK_NOT_NULL(callback);
+    VELOX_CHECK(!point_.empty());
+    TestValue::set<T>(point_, std::move(callback));
+  }
+  ~ScopedTestValue() {
+    TestValue::clear(point_);
+  }
+
+ private:
+  const std::string point_;
+};
+
+#ifndef NDEBUG
+template <typename T>
+void TestValue::set(
+    const std::string& injectionPoint,
+    std::function<void(T*)> injectionCb) {
+  std::lock_guard<std::mutex> l(mutex_);
+  if (!enabled_) {
+    return;
+  }
+  injectionMap_[injectionPoint] = [injectionCb](void* testData) {
+    T* typedData = static_cast<T*>(testData);
+    injectionCb(typedData);
+  };
+}
+#else
+template <typename T>
+void TestValue::set(
+    const std::string& injectionPoint,
+    std::function<void(T*)> injectionCb) {}
+#endif
+
+#define VELOX_CONCAT(x, y) __##x##y
+#define VELOX_VARNAME(x) VELOX_CONCAT(x, Obj)
+
+#define SCOPED_TESTVALUE_SET(point, ...) \
+  ScopedTestValue VELOX_VARNAME(__LINE__)(point, ##__VA_ARGS__)
+
+} // namespace facebook::velox::common::testutil

velox/common/testutil/tests/CMakeLists.txt

@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+include(GoogleTest)
+add_executable(velox_test_util_test TestValueTest.cpp)
+gtest_add_tests(velox_test_util_test "" AUTO)
+
+target_link_libraries(velox_test_util_test velox_test_util velox_exception
+                      gtest gtest_main)