*/
#include <folly/experimental/bser/Bser.h>
#include <folly/String.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::dynamic;
#include <condition_variable>
#include <sstream>
-#include <gtest/gtest.h>
-
#include <folly/experimental/exception_tracer/ExceptionCounterLib.h>
+#include <folly/portability/GTest.h>
struct MyException {};
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/experimental/io/FsUtil.h>
#include <folly/ScopeGuard.h>
#include <folly/String.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
namespace fs = folly::fs;
#include <folly/experimental/io/FsUtil.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::fs;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <thread>
#include <folly/Baton.h>
#include <folly/experimental/observer/SimpleObservable.h>
+#include <folly/portability/GTest.h>
using namespace folly::observer;
#include <folly/experimental/symbolizer/Dwarf.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::symbolizer::Dwarf;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/experimental/symbolizer/Elf.h>
+#include <folly/portability/GTest.h>
using folly::symbolizer::ElfFile;
#include <folly/experimental/symbolizer/LineReader.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/FileUtil.h>
#include <folly/experimental/TestUtil.h>
+#include <folly/portability/GTest.h>
namespace folly { namespace symbolizer { namespace test {
#include <folly/experimental/symbolizer/test/SignalHandlerTest.h>
#include <folly/experimental/symbolizer/SignalHandler.h>
-#include <gtest/gtest.h>
-
#include <folly/FileUtil.h>
#include <folly/Range.h>
#include <folly/CPortability.h>
+#include <folly/portability/GTest.h>
namespace folly { namespace symbolizer { namespace test {
#include <folly/experimental/symbolizer/Symbolizer.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::symbolizer;
#include <cstdlib>
-#include <gtest/gtest.h>
-
#include <folly/Range.h>
#include <folly/String.h>
+#include <folly/portability/GTest.h>
namespace folly { namespace symbolizer { namespace test {
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <folly/experimental/AutoTimer.h>
+#include <folly/portability/GTest.h>
+
using namespace folly;
using namespace std;
#include <folly/experimental/Bits.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
using namespace folly;
#include <vector>
#include <unordered_set>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
namespace folly { namespace compression {
#include <folly/Optional.h>
#include <folly/experimental/DynamicParser.h>
#include <folly/experimental/TestUtil.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using dynamic = folly::dynamic;
#include <thread>
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Random.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <cassert>
#include <random>
#include <folly/Random.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
using namespace folly;
using std::chrono::milliseconds;
*/
#include <boost/thread/barrier.hpp>
#include <folly/experimental/FutureDAG.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/experimental/JSONSchema.h>
#include <folly/json.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::dynamic;
using folly::parseJson;
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <iostream>
#include <thread>
#include <folly/detail/Futex.h>
#include <folly/experimental/LockFreeRingBuffer.h>
#include <folly/test/DeterministicSchedule.h>
+#include <folly/portability/GTest.h>
namespace folly {
#include <folly/Subprocess.h>
#include <folly/experimental/io/FsUtil.h>
+#include <folly/portability/GTest.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
namespace folly { namespace test {
#include <folly/FileUtil.h>
#include <folly/Subprocess.h>
#include <folly/experimental/io/FsUtil.h>
+#include <folly/portability/GTest.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
namespace folly { namespace test {
#include <mutex>
#include <folly/Memory.h>
#include <condition_variable>
-#include <gtest/gtest.h>
#include <folly/Baton.h>
#include <folly/experimental/RCURefCount.h>
#include <folly/experimental/ReadMostlySharedPtr.h>
+#include <folly/portability/GTest.h>
using folly::ReadMostlyMainPtr;
using folly::ReadMostlyWeakPtr;
#include <folly/Baton.h>
#include <folly/experimental/RCURefCount.h>
#include <folly/experimental/TLRefCount.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
namespace folly {
#include <string>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Range.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
using folly::StringKeyedMap;
using folly::StringKeyedSetBase;
#include <boost/algorithm/string.hpp>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Memory.h>
#include <folly/portability/Environment.h>
#include <folly/portability/Fcntl.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::test;
#include <folly/experimental/TupleOps.h>
#include <folly/Conv.h>
+#include <folly/portability/GTest.h>
+
#include <glog/logging.h>
-#include <gtest/gtest.h>
namespace folly { namespace test {
#include <thread>
#include <vector>
-#include <gtest/gtest.h>
-
#include <folly/Memory.h>
#include <folly/futures/Future.h>
#include <folly/fibers/Semaphore.h>
#include <folly/fibers/SimpleLoopController.h>
#include <folly/fibers/WhenN.h>
+#include <folly/portability/GTest.h>
using namespace folly::fibers;
#include <mutex>
#include <folly/Random.h>
+#include <folly/portability/GTest.h>
+
#include <glog/logging.h>
-#include <gtest/gtest.h>
namespace folly { namespace futures { namespace test {
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <numeric>
#include <boost/thread/barrier.hpp>
#include <folly/futures/Future.h>
#include <folly/Random.h>
#include <folly/small_vector.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
+
#include <type_traits>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
#include <folly/futures/detail/Core.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <memory>
#include <unordered_set>
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
#include <folly/futures/InlineExecutor.h>
#include <folly/futures/ManualExecutor.h>
#include <folly/futures/QueuedImmediateExecutor.h>
#include <folly/Baton.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/detail/FSM.h>
+#include <folly/portability/GTest.h>
using namespace folly::detail;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
#include <folly/Unit.h>
#include <folly/Memory.h>
#include <folly/Executor.h>
#include <folly/dynamic.h>
#include <folly/Baton.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
#include <algorithm>
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
// amazing what things can go wrong if you include things in an unexpected
// order.
#include <folly/Try.h>
#include <folly/futures/Promise.h>
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
TEST(Basic, compiles) {
EXPECT_TRUE(true);
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
#include <folly/futures/Promise.h>
#include <folly/Baton.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using std::unique_ptr;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <atomic>
#include <exception>
#include <vector>
+
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
-#include <gtest/gtest.h>
using namespace std;
using namespace std::chrono;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
#include <folly/futures/InlineExecutor.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/SharedPromise.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#pragma once
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
#include <memory>
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
#include <thread>
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Timekeeper.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
using namespace folly;
#include <mutex>
#include <queue>
-#include <gtest/gtest.h>
#include <glog/logging.h>
#include <folly/futures/Future.h>
#include <folly/futures/Promise.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
#include <folly/futures/InlineExecutor.h>
#include <folly/futures/ManualExecutor.h>
#include <folly/futures/DrivableExecutor.h>
#include <folly/Baton.h>
#include <folly/MPMCQueue.h>
+#include <folly/portability/GTest.h>
#include <thread>
#include <queue>
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
#include <folly/io/async/EventBase.h>
#include <folly/Baton.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using std::vector;
#include <memory>
#include <mutex>
-#include <gtest/gtest.h>
#include <glog/logging.h>
#include <folly/futures/Future.h>
#include <folly/futures/Promise.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <mutex>
#include <queue>
-#include <gtest/gtest.h>
#include <glog/logging.h>
#include <folly/futures/Future.h>
#include <folly/futures/Promise.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <boost/thread/barrier.hpp>
#include <folly/Conv.h>
#include <folly/futures/Future.h>
+#include <folly/portability/GTest.h>
#include <vector>
*/
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
#include <iosfwd>
#include <random>
#include <set>
#include <folly/dynamic.h>
#include <folly/experimental/TestUtil.h>
#include <folly/gen/Base.h>
+#include <folly/portability/GTest.h>
using namespace folly::gen;
using namespace folly;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <string>
#include <vector>
#include <tuple>
#include <folly/experimental/TestUtil.h>
#include <folly/gen/Base.h>
#include <folly/gen/Combine.h>
+#include <folly/portability/GTest.h>
using namespace folly::gen;
using namespace folly;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <string>
#include <vector>
#include <folly/experimental/TestUtil.h>
#include <folly/gen/Base.h>
#include <folly/gen/File.h>
+#include <folly/portability/GTest.h>
using namespace folly::gen;
using namespace folly;
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Memory.h>
#include <folly/gen/Base.h>
#include <folly/gen/ParallelMap.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::gen;
*/
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
#include <iostream>
#include <array>
#include <vector>
+
#include <folly/gen/Base.h>
#include <folly/gen/Parallel.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::gen;
*/
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
#include <iosfwd>
#include <map>
#include <vector>
#include <folly/gen/String.h>
+#include <folly/portability/GTest.h>
using namespace folly::gen;
using namespace folly;
#include <folly/io/async/ssl/SSLErrors.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
+
#include <openssl/err.h>
#include <openssl/x509.h>
#include <folly/io/async/AsyncPipe.h>
#include <folly/io/async/EventBase.h>
#include <folly/Memory.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <fcntl.h>
#include <folly/io/async/AsyncSSLSocket.h>
#include <folly/io/async/EventBase.h>
#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
#include <folly/portability/Unistd.h>
#include <fcntl.h>
#include <folly/io/Cursor.h>
-#include <gtest/gtest.h>
#include <openssl/bio.h>
#include <sys/types.h>
#include <fstream>
#include <folly/io/async/AsyncTransport.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/ssl/SSLErrors.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
#include <folly/portability/Unistd.h>
#include <fcntl.h>
-#include <gtest/gtest.h>
#include <sys/types.h>
#include <condition_variable>
#include <iostream>
*/
#include <folly/io/async/test/AsyncSSLSocketTest.h>
-#include <gtest/gtest.h>
#include <pthread.h>
#include <folly/io/async/AsyncSSLSocket.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/SSLContext.h>
+#include <folly/portability/GTest.h>
using std::string;
using std::vector;
#include <folly/io/async/AsyncSocket.h>
#include <folly/io/async/EventBase.h>
#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
-#include <gtest/gtest.h>
#include <string>
#include <vector>
#include <folly/io/async/AsyncSocketException.h>
#include <folly/io/async/ssl/SSLErrors.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
+
#include <openssl/ssl.h>
using namespace testing;
#include <folly/io/async/AsyncSocket.h>
#include <folly/io/async/AsyncServerSocket.h>
#include <folly/io/async/EventBase.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
namespace folly {
#include <folly/io/async/test/AsyncSocketTest.h>
#include <folly/io/async/test/Util.h>
#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
#include <folly/portability/Unistd.h>
#include <folly/test/SocketAddressTestHelper.h>
#include <boost/scoped_array.hpp>
#include <fcntl.h>
-#include <gtest/gtest.h>
#include <sys/types.h>
#include <iostream>
#include <thread>
#include <folly/io/async/AsyncTimeout.h>
#include <folly/io/async/EventBase.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
namespace folly {
#include <folly/io/async/AsyncSocket.h>
#include <folly/io/async/test/MockAsyncTransport.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace testing;
#include <boost/thread/barrier.hpp>
#include <folly/io/IOBuf.h>
+#include <folly/portability/GTest.h>
#include <thread>
-#include <gtest/gtest.h>
-
using folly::AsyncUDPSocket;
using folly::AsyncUDPServerSocket;
using folly::AsyncTimeout;
#include <folly/io/async/DelayedDestructionBase.h>
#include <functional>
-#include <gtest/gtest.h>
#include <list>
#include <vector>
+#include <folly/portability/GTest.h>
+
using namespace folly;
class DestructionOnCallback : public DelayedDestructionBase {
*/
#include <folly/io/async/DelayedDestruction.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/io/async/EventBaseLocal.h>
#include <folly/io/async/test/Util.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
struct Foo {
Foo(int n, std::function<void()> dtorFn):
#include <folly/io/async/EventBase.h>
#include <folly/io/async/EventHandler.h>
#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
-#include <gtest/gtest.h>
#include <sys/eventfd.h>
using namespace std;
#include <folly/io/async/HHWheelTimer.h>
#include <folly/io/async/test/UndelayedDestruction.h>
#include <folly/io/async/test/Util.h>
+#include <folly/portability/GTest.h>
-#include <gtest/gtest.h>
#include <thread>
#include <vector>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/test/UndelayedDestruction.h>
#include <folly/io/async/test/Util.h>
+#include <folly/portability/GTest.h>
-#include <gtest/gtest.h>
#include <vector>
using namespace folly;
#include <folly/io/async/ScopedEventBaseThread.h>
#include <folly/Baton.h>
+#include <folly/portability/GTest.h>
+
#include <list>
#include <iostream>
#include <thread>
#include <sys/wait.h>
#endif
-#include <gtest/gtest.h>
-
using namespace std;
using namespace folly;
* specific language governing permissions and limitations
* under the License.
*/
-#include <gtest/gtest.h>
#include <thread>
#include <folly/Memory.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/Request.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <chrono>
#include <folly/Baton.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace std::chrono;
#include <folly/io/async/test/TimeUtil.h>
#include <folly/test/TestUtils.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
/**
* Check how long a timeout took to fire.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <folly/io/async/AsyncTransport.h>
#include <folly/io/async/WriteChainAsyncTransportWrapper.h>
#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
using namespace testing;
using testing::_;
#include <boost/noncopyable.hpp>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Benchmark.h>
#include <folly/Hash.h>
#include <folly/Random.h>
#include <folly/Varint.h>
#include <folly/io/IOBufQueue.h>
+#include <folly/portability/GTest.h>
namespace folly { namespace io { namespace test {
#include <folly/Format.h>
#include <folly/Range.h>
#include <folly/io/Cursor.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::ByteRange;
using folly::format;
#include <stdexcept>
#include <string.h>
-#include <gtest/gtest.h>
-
#include <folly/Range.h>
+#include <folly/portability/GTest.h>
using folly::IOBuf;
using folly::IOBufQueue;
#include <cstddef>
#include <boost/random.hpp>
-#include <gtest/gtest.h>
#include <folly/Malloc.h>
#include <folly/Range.h>
+#include <folly/portability/GTest.h>
using folly::fbstring;
using folly::fbvector;
#include <random>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Conv.h>
#include <folly/FBString.h>
#include <folly/experimental/TestUtil.h>
#include <folly/io/IOBufQueue.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
DEFINE_int32(random_seed, folly::randomNumberSeed(), "random seed");
#include <thread>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
using folly::ShutdownSocketSet;
#include <folly/portability/Constexpr.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
namespace {
#include <string>
-#include <gtest/gtest.h>
-
+#include <folly/portability/GTest.h>
#include <folly/portability/Libgen.h>
TEST(Libgen, dirname) {
#include <folly/portability/Time.h>
#include <folly/test/TestUtils.h>
+#include <folly/portability/GTest.h>
#include <chrono>
-#include <gtest/gtest.h>
-
static constexpr auto kAcceptableDeltaSecs = std::chrono::seconds(120);
using folly::test::AreWithinSecs;
#include <folly/ssl/OpenSSLHash.h>
-#include <gtest/gtest.h>
-
#include <folly/io/IOBufQueue.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <thread>
#include <memory>
#include <mutex>
#include <folly/AtomicHashMap.h>
#include <folly/ScopeGuard.h>
#include <folly/Memory.h>
+#include <folly/portability/GTest.h>
namespace {
#include <iostream>
#include <folly/ApplyTuple.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <array>
#include <memory>
#include <folly/Memory.h>
#include <folly/Arena.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Arena.h>
#include <folly/Memory.h>
+#include <folly/portability/GTest.h>
#include <set>
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
using namespace folly;
* limitations under the License.
*/
#include <folly/Array.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <string>
using namespace std;
#include <folly/Range.h>
#include <folly/portability/GFlags.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <algorithm>
using namespace std;
#include <folly/AtomicBitSet.h>
+#include <folly/portability/GTest.h>
+
#include <glog/logging.h>
-#include <gtest/gtest.h>
namespace folly { namespace test {
#include <folly/Hash.h>
#include <folly/Memory.h>
#include <folly/portability/SysMman.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
#include <folly/AtomicHashMap.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <thread>
#include <atomic>
#include <memory>
#include <folly/Benchmark.h>
#include <folly/Conv.h>
#include <folly/portability/Atomic.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/SysTime.h>
using std::vector;
#include <algorithm>
#include <thread>
-#include <gtest/gtest.h>
-
#include <folly/AtomicLinkedList.h>
+#include <folly/portability/GTest.h>
class TestIntrusiveObject {
public:
#include <folly/AtomicStruct.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <thread>
#include <unordered_map>
-#include <gtest/gtest.h>
-
#include <folly/Benchmark.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
#include <folly/test/DeterministicSchedule.h>
using namespace folly;
#include <semaphore.h>
#include <thread>
-#include <gtest/gtest.h>
-
#include <folly/Benchmark.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
#include <folly/test/BatonTestHelpers.h>
#include <folly/test/DeterministicSchedule.h>
#include <folly/Baton.h>
#include <folly/test/BatonTestHelpers.h>
#include <folly/test/DeterministicSchedule.h>
+#include <folly/portability/GTest.h>
+
#include <thread>
#include <semaphore.h>
-#include <gtest/gtest.h>
using namespace folly;
using namespace folly::test;
#include <folly/Baton.h>
#include <folly/test/DeterministicSchedule.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
namespace folly {
namespace test {
#include <limits>
#include <vector>
-#include <gtest/gtest.h>
-
#include <folly/Benchmark.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::bititerator_detail;
#include <folly/Bits.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/detail/CacheLocality.h>
+#include <folly/portability/GTest.h>
+
#include <sched.h>
#include <memory>
#include <thread>
#include <type_traits>
#include <unordered_map>
#include <glog/logging.h>
-#include <gtest/gtest.h>
using namespace folly::detail;
#include <type_traits>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::CachelinePadded;
#include <folly/CallOnce.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
DEFINE_int32(threads, 16, "benchmark concurrency");
#include <folly/Checksum.h>
-#include <gtest/gtest.h>
#include <folly/Benchmark.h>
#include <folly/Hash.h>
#include <folly/detail/ChecksumDetail.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
namespace {
const unsigned int BUFFER_SIZE = 512 * 1024 * sizeof(uint64_t);
#include <folly/ClockGettimeWrappers.h>
#include <folly/test/TestUtils.h>
+#include <folly/portability/GTest.h>
#include <chrono>
-#include <gtest/gtest.h>
-
static constexpr auto kAcceptableDeltaSecs = std::chrono::seconds(120);
using folly::test::AreWithinSecs;
#include <system_error>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Arena.h>
#include <folly/Foreach.h>
#include <folly/Memory.h>
#include <folly/String.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
DEFINE_int32(num_threads, 12, "num concurrent threads to test");
#include <folly/ContainerTraits.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
#endif
#include <boost/lexical_cast.hpp>
+
#include <folly/Conv.h>
#include <folly/Foreach.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
+
#include <algorithm>
#include <cinttypes>
#include <limits>
#include <folly/CpuId.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Demangle.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::demangle;
#include <folly/test/DeterministicSchedule.h>
-#include <gtest/gtest.h>
-
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
using namespace folly::test;
#include <folly/DiscriminatedPtr.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/DynamicConverter.h>
+#include <folly/portability/GTest.h>
+
#include <algorithm>
-#include <gtest/gtest.h>
#include <map>
#include <vector>
#include <folly/gen/Base.h>
#include <folly/json.h>
#include <folly/portability/GFlags.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <iostream>
#include <folly/dynamic.h>
+#include <folly/portability/GTest.h>
+
#include <boost/next_prior.hpp>
-#include <gtest/gtest.h>
using folly::dynamic;
#include <folly/Bits.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Enumerate.h>
#include <folly/Range.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
TEST(Enumerate, Basic) {
std::vector<std::string> v = {"abc", "a", "ab"};
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <set>
#include <folly/EvictingCacheMap.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Exception.h>
#include <folly/experimental/TestUtil.h>
+#include <folly/portability/GTest.h>
#include <cstdio>
#include <memory>
#include <glog/logging.h>
-#include <gtest/gtest.h>
namespace folly { namespace test {
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <stdexcept>
+
#include <folly/ExceptionWrapper.h>
#include <folly/Conv.h>
#include <folly/Portability.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Expected.h>
#include <folly/Portability.h>
+#include <folly/portability/GTest.h>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
using std::unique_ptr;
using std::shared_ptr;
#include <sstream>
#include <boost/algorithm/string.hpp>
#include <boost/random.hpp>
-#include <gtest/gtest.h>
#include <folly/Foreach.h>
#include <folly/Portability.h>
#include <folly/Random.h>
#include <folly/Conv.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
#include <folly/Random.h>
#include <folly/Traits.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
-#include <gtest/gtest.h>
#include <list>
#include <memory>
#include <boost/random.hpp>
#include <folly/Random.h>
#include <folly/FBString.h>
#include <folly/FBVector.h>
+#include <folly/portability/GTest.h>
-#include <gtest/gtest.h>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <boost/thread/locks.hpp>
#include <folly/String.h>
#include <folly/experimental/TestUtil.h>
#include <folly/experimental/io/FsUtil.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::test;
#include <folly/String.h>
#include <folly/portability/Fcntl.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <deque>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/File.h>
#include <folly/Range.h>
#include <folly/String.h>
+#include <folly/portability/GTest.h>
namespace folly { namespace test {
#include <folly/Fingerprint.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/detail/SlowFingerprint.h>
#include <folly/Benchmark.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::detail;
#include <folly/Foreach.h>
#include <folly/Benchmark.h>
+#include <folly/portability/GTest.h>
-#include <gtest/gtest.h>
#include <map>
using namespace folly;
#include <folly/Foreach.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
+
#include <map>
#include <string>
#include <vector>
#include <folly/Format.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/FBVector.h>
#include <folly/FileUtil.h>
#include <folly/dynamic.h>
#include <folly/json.h>
#include <folly/small_vector.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Format.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <string>
* limitations under the License.
*/
#include <atomic>
-#include <gtest/gtest.h>
#include <folly/experimental/FunctionScheduler.h>
+#include <folly/portability/GTest.h>
namespace folly {
#include <folly/Function.h>
#include <folly/Memory.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::Function;
#include <thread>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/portability/Time.h>
+#include <folly/portability/GTest.h>
using namespace folly::detail;
using namespace folly::test;
// On platforms where it's not supported, GroupVarint will be compiled out.
#if HAVE_GROUP_VARINT
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Traits.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
+
#include <glog/logging.h>
#include <string>
#include <folly/Hash.h>
#include <folly/MapUtil.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <stdint.h>
#include <unordered_map>
#include <utility>
#include <folly/stats/Histogram.h>
#include <folly/stats/Histogram-defs.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::Histogram;
#include <folly/test/IPAddressTest.h>
-#include <gtest/gtest.h>
-
#include <folly/Bits.h>
#include <folly/Format.h>
#include <folly/MacAddress.h>
#include <folly/String.h>
#include <folly/detail/IPAddressSource.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace std;
#include <string>
-#include <gtest/gtest.h>
-
#include <sys/types.h>
#include <folly/IPAddress.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
namespace folly {
#include <map>
#include <memory>
#include <string>
-#include <gtest/gtest.h>
+
#include <folly/Memory.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
#include <folly/IndexedMemPool.h>
#include <folly/test/DeterministicSchedule.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
+
#include <string>
#include <thread>
#include <semaphore.h>
-#include <gtest/gtest.h>
using namespace folly;
using namespace folly::test;
#include <folly/Benchmark.h>
#include <folly/FileUtil.h>
#include <folly/portability/GFlags.h>
-
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::dynamic;
using folly::parseJson;
#include <limits>
#include <boost/next_prior.hpp>
+
#include <folly/json.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using folly::dynamic;
using folly::parseJson;
#include <functional>
#include <iostream>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
namespace folly {
#include <semaphore.h>
#include <thread>
-#include <gtest/gtest.h>
-
#include <folly/Benchmark.h>
#include <folly/Random.h>
#include <folly/portability/Asm.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
#include <folly/test/DeterministicSchedule.h>
using namespace folly;
#include <folly/LockTraits.h>
#include <folly/LockTraitsBoost.h>
-#include <gtest/gtest.h>
#include <mutex>
#include <folly/RWSpinLock.h>
#include <folly/SharedMutex.h>
#include <folly/SpinLock.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/Logging.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
#include <vector>
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Conv.h>
+#include <folly/portability/GTest.h>
namespace folly { namespace test {
#include <folly/MPMCQueue.h>
#include <folly/Format.h>
#include <folly/Memory.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/SysResource.h>
#include <folly/portability/SysTime.h>
#include <folly/portability/Unistd.h>
#include <thread>
#include <utility>
-#include <gtest/gtest.h>
-
FOLLY_ASSUME_FBVECTOR_COMPATIBLE_1(boost::intrusive_ptr);
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/Conv.h>
#include <folly/IPAddressV6.h>
#include <folly/MacAddress.h>
+#include <folly/portability/GTest.h>
using folly::MacAddress;
using folly::IPAddressV6;
#include <folly/MallctlHelper.h>
#include <folly/Malloc.h>
#include <folly/init/Init.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/MapUtil.h>
#include <map>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
using namespace folly;
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Portability.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace folly::detail;
#include <folly/Portability.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
namespace {
#include <folly/Baton.h>
#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Windows.h>
#include <memory>
#include <assert.h>
#include <semaphore.h>
-#include <gtest/gtest.h>
-
using namespace folly;
using namespace folly::detail;
using namespace testing;
#include <folly/FileUtil.h>
#include <folly/MemoryMapping.h>
#include <folly/Random.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/SysMman.h>
-#include <gtest/gtest.h>
-
static constexpr double kSomeDouble = 3.14;
namespace folly {
#include <folly/Memory.h>
#include <folly/Arena.h>
#include <folly/String.h>
+#include <folly/portability/GTest.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <type_traits>
*/
#include <folly/Merge.h>
-#include <gtest/gtest.h>
+
#include <map>
#include <vector>
+#include <folly/portability/GTest.h>
+
TEST(MergeTest, NonOverlapping) {
std::vector<int> a = {0, 2, 4, 6};
std::vector<int> b = {1, 3, 5, 7};
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/MoveWrapper.h>
+
#include <memory>
+#include <folly/portability/GTest.h>
+
namespace folly {
TEST(makeMoveWrapper, Empty) {
#include <folly/Optional.h>
#include <folly/Portability.h>
+#include <folly/portability/GTest.h>
#include <memory>
#include <vector>
#include <type_traits>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <boost/optional.hpp>
using std::unique_ptr;
#include <folly/PackedSyncPtr.h>
#include <cinttypes>
-#include <gtest/gtest.h>
#include <thread>
#include <unordered_map>
#include <utility>
+#include <folly/portability/GTest.h>
+
using folly::PackedSyncPtr;
namespace {
#include <folly/Padded.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
using namespace folly;
#include <memory>
#include <folly/Partial.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
using folly::partial;
#include <memory>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
class Base {
public:
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
//////////////////////////////////////////////////////////////////////
#include <thread>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
DEFINE_int32(num_threads, 8, "num threads");
#include <folly/Random.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <algorithm>
#include <thread>
#include <vector>
#include <random>
+#include <folly/portability/GTest.h>
+
using namespace folly;
TEST(Random, StateSize) {
#include <folly/Range.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Memory.h>
#include <folly/portability/SysMman.h>
#include <vector>
#include <boost/range/concepts.hpp>
#include <boost/algorithm/string/trim.hpp>
-#include <gtest/gtest.h>
using namespace folly;
using namespace folly::detail;
#include <folly/SafeAssert.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Benchmark.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <folly/ScopeGuard.h>
#include <folly/Portability.h>
-#include <gtest/gtest.h>
#include <glog/logging.h>
#include <functional>
#include <stdexcept>
+#include <folly/portability/GTest.h>
+
using folly::ScopeGuard;
using folly::makeGuard;
using std::vector;
#include <thread>
#include <vector>
-#include <gtest/gtest.h>
#include <boost/optional.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <folly/RWSpinLock.h>
#include <folly/Random.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
#include <folly/test/DeterministicSchedule.h>
using namespace folly;
#include <folly/experimental/io/FsUtil.h>
#include <folly/io/async/EventBase.h>
#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
#include <folly/test/SingletonTestStructs.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <boost/thread/barrier.hpp>
using namespace folly;
#include <folly/Singleton.h>
#include <folly/Benchmark.h>
#include <folly/test/SingletonTestStructs.h>
+#include <folly/portability/GTest.h>
#include <glog/logging.h>
-#include <gtest/gtest.h>
/*
* This test needs to be in its own file, as a standalone program.
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
+
+#include <folly/portability/GTest.h>
// A simple class that tracks how often instances of the class and
// subclasses are created, and the ordering. Also tracks a global
#include <folly/Singleton.h>
#include <folly/SingletonVault_c.h>
-#include <gtest/gtest.h>
-
#include <thread>
+#include <folly/portability/GTest.h>
+
FOLLY_TLS long instance_counter_instances = 0;
class InstanceCounter {
#include <thread>
-#include <gtest/gtest.h>
-
#include <folly/portability/Asm.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
using folly::MSLGuard;
#include <folly/SocketAddress.h>
-#include <gtest/gtest.h>
#include <iostream>
#include <sstream>
#include <system_error>
+#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
#include <folly/portability/Stdlib.h>
#include <folly/test/SocketAddressTestHelper.h>
#include <random>
#include <set>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
#include <folly/Random.h>
-#include <gtest/gtest.h>
#include <thread>
#include <folly/portability/Asm.h>
+#include <folly/portability/GTest.h>
using folly::SpinLockGuardImpl;
#include <folly/SpookyHashV1.h>
#include <folly/Benchmark.h>
+#include <folly/portability/GTest.h>
#include <cinttypes>
#include <cstdio>
#include <cstdlib>
#include <ctime>
-#include <gtest/gtest.h>
-
using namespace ::folly::hash;
static bool failed = false;
#include <folly/SpookyHashV2.h>
#include <folly/Benchmark.h>
+#include <folly/portability/GTest.h>
#include <cinttypes>
#include <cstdio>
#include <cstdlib>
#include <ctime>
-#include <gtest/gtest.h>
-
using namespace ::folly::hash;
static bool failed = false;
#include <cinttypes>
#include <boost/regex.hpp>
-#include <gtest/gtest.h>
#include <folly/Array.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace std;
#include <boost/container/flat_set.hpp>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Exception.h>
#include <folly/Format.h>
#include <folly/gen/String.h>
#include <folly/experimental/TestUtil.h>
#include <folly/experimental/io/FsUtil.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
using namespace folly;
#include <folly/SpinLock.h>
#include <folly/Synchronized.h>
#include <folly/test/SynchronizedTestLib.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly::sync_tests;
#pragma once
-#include <gtest/gtest.h>
-
#include <folly/Foreach.h>
#include <folly/Random.h>
#include <folly/Synchronized.h>
+#include <folly/portability/GTest.h>
#include <glog/logging.h>
#include <algorithm>
#include <condition_variable>
#include <chrono>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
// We use this to indicate that tests have failed because of timing
// or dependencies that may be flakey. Internally this is used by
#include <unordered_map>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Range.h>
#include <folly/Benchmark.h>
#include <folly/Portability.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <thread>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Benchmark.h>
#include <folly/Hash.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#include <unordered_map>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Baton.h>
#include <folly/Memory.h>
#include <folly/experimental/io/FsUtil.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
using namespace folly;
#include <folly/Baton.h>
#include <folly/ScopeGuard.h>
#include <folly/ThreadName.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
#include <folly/TimeoutQueue.h>
+#include <folly/portability/GTest.h>
+
using namespace folly;
TEST(TimeoutQueue, Simple) {
#include <random>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;
#include <array>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Foreach.h>
+#include <folly/portability/GTest.h>
using std::chrono::seconds;
using std::string;
#include <folly/test/TokenBucketTest.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
#pragma once
-#include <gtest/gtest.h>
-
#include <folly/TokenBucket.h>
+#include <folly/portability/GTest.h>
namespace folly {
#include <utility>
#include <folly/ScopeGuard.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
using namespace folly;
using namespace std;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/Memory.h>
#include <folly/Try.h>
+#include <folly/portability/GTest.h>
using namespace folly;
* limitations under the License.
*/
-#include <gtest/gtest.h>
-
#include <folly/Unit.h>
+#include <folly/portability/GTest.h>
+
using namespace folly;
TEST(Unit, operatorEq) {
#include <folly/Uri.h>
#include <folly/Benchmark.h>
+#include <folly/portability/GTest.h>
#include <boost/algorithm/string.hpp>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <map>
using namespace folly;
#include <vector>
#include <glog/logging.h>
-#include <gtest/gtest.h>
#include <folly/Benchmark.h>
#include <folly/Random.h>
+#include <folly/portability/GTest.h>
DEFINE_int32(random_seed, folly::randomNumberSeed(), "random seed");
#include <folly/init/Init.h>
-#include <gtest/gtest.h>
+#include <folly/portability/GTest.h>
/*
* This is the recommended main function for all tests.
#include <vector>
#include <boost/algorithm/string.hpp>
-#include <gtest/gtest.h>
#include <folly/Conv.h>
+#include <folly/portability/GTest.h>
#include <folly/portability/TypeTraits.h>
using folly::small_vector;
*/
#include <folly/sorted_vector_types.h>
-#include <gtest/gtest.h>
+
#include <list>
#include <memory>
+#include <folly/portability/GTest.h>
+
using folly::sorted_vector_set;
using folly::sorted_vector_map;
#include <cstddef>
#include <iomanip>
-#include <gtest/gtest.h>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/preprocessor.hpp>
#include <folly/Conv.h>
#include <folly/ScopeGuard.h>
#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
using namespace std;
using namespace folly;