proxygen: folly::test Namespace Reference

Namespaces
	detail

Classes
struct	Barrier

class	CaptureFD

class	ChangeToTempDir

struct	DeterministicAtomicImpl

struct	DeterministicMutex

class	DeterministicSchedule

struct	EnvVarSaver

class	FileUtilTest

class	IovecBuffers

class	ManualSchedule

class	MockAsyncServerSocket

class	MockAsyncSocket

class	MockAsyncSSLSocket

class	MockAsyncTransport

struct	MockAsyncUDPSocket

class	MockReadCallback

class	MockReplaySafetyCallback

class	MockTimeoutManager

class	MockWriteCallback

class	MovableInt

struct	One

class	ReadFileFd

class	Server

class	TemporaryDirectory

class	TemporaryFile

class	TestAcceptCallback

class	TestAdlIterable

class	TestBothIndexingAndIter

class	TestConnectionEventCallback

class	TestRValueConstruct

class	TestWriteChainAsyncTransportWrapper

struct	TupleTo

struct	TupleTo2

struct	TupleTo2< TemplateSeq< std::size_t, Ns... > >

struct	TupleTo< std::tuple< U, Us... >, T >

struct	TupleTo< std::tuple<>, std::tuple<> >

struct	Two

struct	UniformSubset

class	WriteFileAtomic

Typedefs
typedef DeterministicSchedule	DSched

template<typename T >
using	ManualAtomic = test::DeterministicAtomicImpl< T, ManualSchedule >

template<template< typename > class Atomic>
using	TestDistributedMutex = detail::distributed_mutex::DistributedMutex< Atomic, false >

using	AuxAct = std::function< void(bool)>

using	AuxChk = std::function< void(uint64_t)>

template<typename T >
using	DeterministicAtomic = DeterministicAtomicImpl< T, DeterministicSchedule >

using	OneOrTwo = boost::variant< One, Two >

Functions
auto	begin (TestAdlIterable &instance)

auto	begin (const TestAdlIterable &instance)

auto	end (TestAdlIterable &instance)

auto	end (const TestAdlIterable &instance)

void	doWork (int work)

template<typename Example , typename Req = bool, typename Mutex = std::mutex, template< typename > class Atom = std::atomic>
uint64_t	fc_test (int nthreads, int lines, int numRecs, int work, int ops, bool combining, bool dedicated, bool tc, bool syncops, bool excl=false, bool allocAll=false)

uint64_t	run_test (int nthreads, int lines, int numRecs, int work, int ops, bool combining, bool simple, bool dedicated, bool tc, bool syncops, bool excl=false, bool allocAll=false)

	TEST (ProgramOptionsTest, Errors)

	TEST (ProgramOptionsTest, Help)

	TEST (ProgramOptionsTest, DevFull)

	TEST (ProgramOptionsTest, CutArguments)

	TEST (ProgramOptionsTest, Success)

	TEST (ProgramOptionsTest, Aliases)

	TEST (ProgramOptionsTest, BuiltinCommand)

	TEST (ProgramOptionsTest, GFlagsStyleDefaultValues)

	TEST (ProgramOptionsTest, GFlagsStyleFlagsSet)

	TEST (ProgramOptionsTest, GFlagsStyleBoolFlagsNegation)

	TEST (ProgramOptionsTest, GNUStyleDefaultValues)

	TEST (ProgramOptionsTest, GNUStyleFlagsSet)

	TEST (ProgramOptionsTest, GNUStyleBoolFlagsNegation)

	TEST (ProgramOptionsTest, GNUStyleSubCommand)

	TEST (ProgramOptionsTest, GNUStyleSubCommandUnrecognizedOptionFirst)

	TEST (TupleOps, Copiable)

bool	operator== (const MovableInt &a, const MovableInt &b)

	TEST (TupleOps, Movable)

template<class U , class T >
U	tupleTo (const T &input)

template<class U , class T , class Seq = typename TemplateTupleRange<U>::type, class Enable = typename std::enable_if< (std::tuple_size<U>::value == std::tuple_size<T>::value)>::type>
U	tupleTo2 (const T &input)

	TEST (TupleOps, TupleTo)

	TEST (TupleOps, TupleTo2)

template<typename Func >
auto	msvcSuppressAbortOnInvalidParams (Func func) -> decltype(func())

std::string	glogErrorPattern ()

std::string	glogWarningPattern ()

std::string	glogErrOrWarnPattern ()

	MATCHER_P (BufMatches, expected,"")

	TEST (WriteChainAsyncTransportWrapperTest, TestSimpleIov)

	TEST (WriteChainAsyncTransportWrapperTest, TestChainedIov)

	TEST (WriteChainAsyncTransportWrapperTest, TestSimpleBuf)

	TEST (RecordIOTest, Simple)

	TEST (RecordIOTest, SmallRecords)

	TEST (RecordIOTest, MultipleFileIds)

	TEST (RecordIOTest, ExtraMagic)

	TEST (RecordIOTest, Randomized)

int	createConnectedSocket (int port)

void	runCloseTest (bool abortive)

	TEST (ShutdownSocketSetTest, OrderlyClose)

	TEST (ShutdownSocketSetTest, AbortiveClose)

void	runKillTest (bool abortive)

	TEST (ShutdownSocketSetTest, OrderlyKill)

	TEST (ShutdownSocketSetTest, AbortiveKill)

template<bool MayBlock, template< typename > class Atom>
void	run_basic_test ()

template<bool MayBlock, template< typename > class Atom>
void	run_pingpong_test (int numRounds)

template<bool MayBlock, template< typename > class Atom, typename Clock >
void	run_basic_timed_wait_tests ()

template<bool MayBlock, template< typename > class Atom, typename Clock >
void	run_timed_wait_tmo_tests ()

template<bool MayBlock, template< typename > class Atom, typename Clock >
void	run_timed_wait_regular_test ()

template<bool MayBlock, template< typename > class Atom>
void	run_try_wait_tests ()

int	futexWakeImpl (const detail::Futex< ManualAtomic > *, int, uint32_t)

detail::FutexResult	futexWaitImpl (const detail::Futex< ManualAtomic > , uint32_t, std::chrono::system_clock::time_point const , std::chrono::steady_clock::time_point const *, uint32_t)

template<typename Clock , typename Duration >
std::cv_status	atomic_wait_until (const ManualAtomic< std::uintptr_t > *, std::uintptr_t, const std::chrono::time_point< Clock, Duration > &)

void	atomic_notify_one (const ManualAtomic< std::uintptr_t > *)

	TEST (AtomicBitSet, Simple)

detail::FutexResult	futexWaitImpl (const detail::Futex< DeterministicAtomic > futex, uint32_t expected, std::chrono::system_clock::time_point const absSystemTimeout, std::chrono::steady_clock::time_point const *absSteadyTimeout, uint32_t waitMask)

int	futexWakeImpl (const detail::Futex< test::DeterministicAtomic > *futex, int count, uint32_t wakeMask)

detail::FutexResult	futexWaitImpl (const detail::Futex< test::DeterministicAtomic > futex, uint32_t expected, std::chrono::system_clock::time_point const absSystemTime, std::chrono::steady_clock::time_point const *absSteadyTime, uint32_t waitMask)

template<typename Integer >
void	atomic_wait (const DeterministicAtomic< Integer > *, Integer)

template<typename Integer , typename Clock , typename Duration >
std::cv_status	atomic_wait_until (const DeterministicAtomic< Integer > *, Integer, const std::chrono::time_point< Clock, Duration > &)

template<typename Integer >
void	atomic_notify_one (const DeterministicAtomic< Integer > *)

template<typename Integer >
void	atomic_notify_all (const DeterministicAtomic< Integer > *)

	TEST (ExceptionTest, Simple)

	TEST (ExceptionTest, makeSystemError)

	TEST_F (FileUtilTest, read)

	TEST_F (FileUtilTest, pread)

	TEST_F (FileUtilTest, readv)

	TEST (FileUtilTest2, wrapv)

	TEST_F (FileUtilTest, preadv)

	TEST (String, readFile)

	TEST_F (ReadFileFd, ReadZeroBytes)

	TEST_F (ReadFileFd, ReadPartial)

	TEST_F (ReadFileFd, ReadFull)

	TEST_F (ReadFileFd, WriteOnlyFd)

	TEST_F (ReadFileFd, InvalidFd)

	TEST_F (WriteFileAtomic, writeNew)

	TEST_F (WriteFileAtomic, overwrite)

	TEST_F (WriteFileAtomic, directoryPermissions)

	TEST_F (WriteFileAtomic, multipleFiles)

	TEST (MPMCPipeline, Trivial)

	TEST (MPMCPipeline, TrivialAmplification)

	TEST (MPMCPipeline, MultiThreaded)

	TEST (Overload, BoostVariant)

	TEST (Overload, DiscriminatedPtr)

	TEST (Overload, Pattern)

template<typename T1 , typename T2 >
::testing::AssertionResult	AreWithinSecs (T1 val1, T2 val2, std::chrono::seconds acceptableDeltaSecs)

void	testVarint (uint64_t val, std::initializer_list< uint8_t > bytes)

	TEST (Varint, Interface)

	TEST (Varint, Simple)

void	testVarintFail (std::initializer_list< uint8_t > bytes)

	TEST (Varint, Fail)

	TEST (ZigZag, Simple)

unsigned	staticTracepointTestFunc (unsigned v)

Variables
ShutdownSocketSet	shutdownSocketSet

static std::unordered_map< const detail::Futex< DeterministicAtomic > , std::list< std::pair< uint32_t, bool > > >	futexQueues

static std::mutex	futexLock

Typedef Documentation

using folly::test::AuxAct = typedef std::function<void(bool)>

Definition at line 51 of file DeterministicSchedule.h.

using folly::test::AuxChk = typedef std::function<void(uint64_t)>

Definition at line 52 of file DeterministicSchedule.h.

template<typename T >

using folly::test::DeterministicAtomic = typedef DeterministicAtomicImpl<T, DeterministicSchedule>

Definition at line 458 of file DeterministicSchedule.h.

typedef DeterministicSchedule folly::test::DSched

Definition at line 26 of file BatonTestHelpers.h.

template<typename T >

using folly::test::ManualAtomic = typedef test::DeterministicAtomicImpl<T, ManualSchedule>

Definition at line 148 of file DistributedMutexTest.cpp.

using folly::test::OneOrTwo = typedef boost::variant<One, Two>

Definition at line 34 of file OverloadTest.cpp.

template<template< typename > class Atomic>

using folly::test::TestDistributedMutex = typedef detail::distributed_mutex::DistributedMutex<Atomic, false>

Definition at line 151 of file DistributedMutexTest.cpp.

Function Documentation

template<typename T1 , typename T2 >

::testing::AssertionResult folly::test::AreWithinSecs	(	T1	val1,
		T2	val2,
		std::chrono::seconds	acceptableDeltaSecs
	)

Definition at line 129 of file TestUtils.h.

References testing::AssertionFailure(), and testing::AssertionSuccess().

                                                                       {
   auto deltaSecs =
       std::chrono::duration_cast<std::chrono::seconds>(val1 - val2);
   if (deltaSecs <= acceptableDeltaSecs &&
       deltaSecs >= -1 * acceptableDeltaSecs) {
     return ::testing::AssertionSuccess();
   } else {
     return ::testing::AssertionFailure()
         << val1.count() << " and " << val2.count() << " are not within "
         << acceptableDeltaSecs.count() << " secs of each other";
   }
 }

template<typename Integer >

void folly::test::atomic_notify_all ( const DeterministicAtomic< Integer > * )

Definition at line 490 of file DeterministicSchedule.h.

490 {}

void folly::test::atomic_notify_one ( const ManualAtomic< std::uintptr_t > * )

Definition at line 182 of file DistributedMutexTest.cpp.

References Atom, DEFINE_int32, EXPECT_EQ, h, i, folly::test::DeterministicSchedule::join(), folly::gen::move, mutex, sum(), folly::test::DeterministicSchedule::thread(), threads, and value.

                                                           {
   ManualSchedule::beforeSharedAccess();
 }

template<typename Integer >

void folly::test::atomic_notify_one ( const DeterministicAtomic< Integer > * )

Definition at line 488 of file DeterministicSchedule.h.

488 {}

template<typename Integer >

void folly::test::atomic_wait	(	const DeterministicAtomic< Integer > *	,
		Integer
	)

Implementations of the atomic_wait API for DeterministicAtomic, these are no-ops here. Which for a correct implementation should not make a difference because threads are required to have atomic operations around waits and wakes

Definition at line 479 of file DeterministicSchedule.h.

479 {}

template<typename Clock , typename Duration >

std::cv_status folly::test::atomic_wait_until	(	const ManualAtomic< std::uintptr_t > *	,
		std::uintptr_t	,
		const std::chrono::time_point< Clock, Duration > &
	)

Definition at line 174 of file DistributedMutexTest.cpp.

                                                  {
   ManualSchedule::beforeSharedAccess();
   return std::cv_status::no_timeout;
 }

template<typename Integer , typename Clock , typename Duration >

std::cv_status folly::test::atomic_wait_until	(	const DeterministicAtomic< Integer > *	,
		Integer	,
		const std::chrono::time_point< Clock, Duration > &
	)

Definition at line 481 of file DeterministicSchedule.h.

                                                  {
   return std::cv_status::no_timeout;
 }

auto folly::test::begin ( TestAdlIterable & instance )

Definition at line 56 of file ForeachTest.cpp.

References folly::test::TestAdlIterable::vec.

                                       {
   return instance.vec.begin();
 }

auto folly::test::begin ( const TestAdlIterable & instance )

Definition at line 59 of file ForeachTest.cpp.

References folly::test::TestAdlIterable::vec.

                                             {
   return instance.vec.begin();
 }

int folly::test::createConnectedSocket ( int port )

Definition at line 127 of file ShutdownSocketSetTest.cpp.

References addr, folly::netops::connect(), and folly::netops::socket().

Referenced by runCloseTest(), and runKillTest().

                                     {
   int sock = fsp::socket(PF_INET, SOCK_STREAM, 0);
   CHECK_ERR(sock);
   sockaddr_in addr;
   addr.sin_family = AF_INET;
   addr.sin_port = htons(port);
   addr.sin_addr.s_addr = htonl((127 << 24) | 1); // XXX
   CHECK_ERR(
       connect(sock, reinterpret_cast<const sockaddr*>(&addr), sizeof(addr)));
   return sock;
 }

void folly::test::doWork ( int work )

Definition at line 31 of file FlatCombiningTestHelpers.h.

References a, Atom, folly::doNotOptimizeAway(), i, mutex, Mutex, and uint64_t.

Referenced by fc_test().

                       {
   uint64_t a = 0;
   for (int i = work; i > 0; --i) {
     a += i;
   }
   folly::doNotOptimizeAway(a);
 }

auto folly::test::end ( TestAdlIterable & instance )

Definition at line 62 of file ForeachTest.cpp.

References folly::test::TestAdlIterable::vec.

                                     {
   return instance.vec.end();
 }

auto folly::test::end ( const TestAdlIterable & instance )

Definition at line 65 of file ForeachTest.cpp.

References folly::test::TestAdlIterable::vec.

                                           {
   return instance.vec.end();
 }

template<typename Example , typename Req = bool, typename Mutex = std::mutex, template< typename > class Atom = std::atomic>

uint64_t folly::test::fc_test	(	int	nthreads,
		int	lines,
		int	numRecs,
		int	work,
		int	ops,
		bool	combining,
		bool	dedicated,
		bool	tc,
		bool	syncops,
		bool	excl = `false`,
		bool	allocAll = `false`
	)

Definition at line 44 of file FlatCombiningTestHelpers.h.

References BENCHMARK_SUSPEND, count, folly::BenchmarkSuspender::dismiss(), doWork(), i, mutex, now(), nthreads, ops, start, sum(), folly::pushmi::detail::t, tc, threads, uint64_t, and v.

                            {
   using FC = FlatCombining<Example, Mutex, Atom, Req>;
   using Rec = typename FC::Rec;
 
   folly::BenchmarkSuspender susp;
 
   std::atomic<bool> start{false};
   std::atomic<int> started{0};
   Example ex(lines, dedicated, numRecs);
   std::atomic<uint64_t> total{0};
   bool mutex = false;
 
   if (allocAll) {
     std::vector<Rec*> v(numRecs);
     for (int i = 0; i < numRecs; ++i) {
       v[i] = ex.allocRec();
     }
     for (int i = numRecs; i > 0; --i) {
       ex.freeRec(v[i - 1]);
     }
   }
 
   std::vector<std::thread> threads(nthreads);
   for (int tid = 0; tid < nthreads; ++tid) {
     threads[tid] = std::thread([&, tid] {
       started.fetch_add(1);
       Rec* myrec = (combining && tc) ? ex.allocRec() : nullptr;
       uint64_t sum = 0;
       while (!start.load()) {
         ;
       }
 
       if (!combining) {
         // no combining
         for (int i = tid; i < ops; i += nthreads) {
           sum += ex.fetchAddNoFC(1);
           doWork(work); // unrelated work
         }
       } else if (syncops) {
         // sync combining
         for (int i = tid; i < ops; i += nthreads) {
           sum += ex.fetchAdd(1, myrec);
           doWork(work); // unrelated work
         }
       } else {
         // async combining
         for (int i = tid; i < ops; i += nthreads) {
           ex.add(1, myrec);
           doWork(work); // unrelated work
         }
       }
 
       if (excl) {
         // test of exclusive access through a lock holder
         {
           std::unique_lock<Mutex> l;
           ex.holdLock(l);
           CHECK(!mutex);
           mutex = true;
           VLOG(2) << tid << " " << ex.getVal() << " ...........";
           using namespace std::chrono_literals;
           /* sleep override */ // for coverage
           std::this_thread::sleep_for(10ms);
           VLOG(2) << tid << " " << ex.getVal() << " ===========";
           CHECK(mutex);
           mutex = false;
         }
         // test of explicit acquisition and release of exclusive access
         ex.acquireExclusive();
         {
           CHECK(!mutex);
           mutex = true;
           VLOG(2) << tid << " " << ex.getVal() << " ...........";
           using namespace std::chrono_literals;
           /* sleep override */ // for coverage
           std::this_thread::sleep_for(10ms);
           VLOG(2) << tid << " " << ex.getVal() << " ===========";
           CHECK(mutex);
           mutex = false;
         }
         ex.releaseExclusive();
       }
 
       total.fetch_add(sum);
       if (combining && tc) {
         ex.freeRec(myrec);
       }
     });
   }
 
   while (started.load() < nthreads) {
     ;
   }
   auto tbegin = std::chrono::steady_clock::now();
 
   // begin time measurement
   susp.dismiss();
   start.store(true);
 
   for (auto& t : threads) {
     t.join();
   }
 
   if (!syncops) {
     // complete any pending asynch ops
     ex.drainAll();
   }
 
   // end time measurement
   uint64_t duration = 0;
   BENCHMARK_SUSPEND {
     auto tend = std::chrono::steady_clock::now();
     CHECK_EQ(ops, ex.getVal());
     if (syncops) {
       uint64_t n = (uint64_t)ops;
       uint64_t expected = n * (n - 1) / 2;
       CHECK_EQ(expected, total);
     }
     duration =
         std::chrono::duration_cast<std::chrono::nanoseconds>(tend - tbegin)
             .count();
   }
   return duration;
 }

detail::FutexResult folly::test::futexWaitImpl	(	const detail::Futex< ManualAtomic > *	,
		uint32_t	,
		std::chrono::system_clock::time_point const *	,
		std::chrono::steady_clock::time_point const *	,
		uint32_t
	)

Definition at line 163 of file DistributedMutexTest.cpp.

               {
   ManualSchedule::beforeSharedAccess();
   return detail::FutexResult::AWOKEN;
 }

detail::FutexResult folly::test::futexWaitImpl	(	const detail::Futex< DeterministicAtomic > *	futex,
		uint32_t	expected,
		std::chrono::system_clock::time_point const *	absSystemTimeout,
		std::chrono::steady_clock::time_point const *	absSteadyTimeout,
		uint32_t	waitMask
	)

Definition at line 310 of file DeterministicSchedule.cpp.

References folly::test::DeterministicSchedule::afterSharedAccess(), folly::test::DeterministicSchedule::beforeSharedAccess(), FOLLY_TEST_DSCHED_VLOG, futexQueues, folly::test::DeterministicSchedule::getRandNumber(), folly::detail::INTERRUPTED, and folly::detail::TIMEDOUT.

                        {
   using namespace test;
   using namespace std::chrono;
   using namespace folly::detail;
 
   bool hasTimeout = absSystemTimeout != nullptr || absSteadyTimeout != nullptr;
   bool awoken = false;
   FutexResult result = FutexResult::AWOKEN;
 
   DeterministicSchedule::beforeSharedAccess();
   FOLLY_TEST_DSCHED_VLOG(
       "futexWait(" << futex << ", " << std::hex << expected << ", .., "
                    << std::hex << waitMask << ") beginning..");
   futexLock.lock();
   if (futex->load_direct() == expected) {
     auto& queue = futexQueues[futex];
     queue.emplace_back(waitMask, &awoken);
     auto ours = queue.end();
     ours--;
     while (!awoken) {
       futexLock.unlock();
       DeterministicSchedule::afterSharedAccess();
       DeterministicSchedule::beforeSharedAccess();
       futexLock.lock();
 
       // Simulate spurious wake-ups, timeouts each time with
       // a 10% probability if we haven't been woken up already
       if (!awoken && hasTimeout &&
           DeterministicSchedule::getRandNumber(100) < 10) {
         assert(futexQueues.count(futex) != 0 && &futexQueues[futex] == &queue);
         queue.erase(ours);
         if (queue.empty()) {
           futexQueues.erase(futex);
         }
         // Simulate ETIMEDOUT 90% of the time and other failures
         // remaining time
         result = DeterministicSchedule::getRandNumber(100) >= 10
             ? FutexResult::TIMEDOUT
             : FutexResult::INTERRUPTED;
         break;
       }
     }
   } else {
     result = FutexResult::VALUE_CHANGED;
   }
   futexLock.unlock();
 
   char const* resultStr = "?";
   switch (result) {
     case FutexResult::AWOKEN:
       resultStr = "AWOKEN";
       break;
     case FutexResult::TIMEDOUT:
       resultStr = "TIMEDOUT";
       break;
     case FutexResult::INTERRUPTED:
       resultStr = "INTERRUPTED";
       break;
     case FutexResult::VALUE_CHANGED:
       resultStr = "VALUE_CHANGED";
       break;
   }
   FOLLY_TEST_DSCHED_VLOG(
       "futexWait(" << futex << ", " << std::hex << expected << ", .., "
                    << std::hex << waitMask << ") -> " << resultStr);
   DeterministicSchedule::afterSharedAccess();
   return result;
 }

detail::FutexResult folly::test::futexWaitImpl	(	const detail::Futex< test::DeterministicAtomic > *	futex,
		uint32_t	expected,
		std::chrono::system_clock::time_point const *	absSystemTime,
		std::chrono::steady_clock::time_point const *	absSteadyTime,
		uint32_t	waitMask
	)

int folly::test::futexWakeImpl	(	const detail::Futex< ManualAtomic > *	,
		int	,
		uint32_t
	)

Futex extensions for ManualAtomic

Note that doing nothing in these should still result in a program that is well defined, since futex wait calls should be tolerant to spurious wakeups

Definition at line 159 of file DistributedMutexTest.cpp.

                                                                    {
   ManualSchedule::beforeSharedAccess();
   return 1;
 }

int folly::test::futexWakeImpl	(	const detail::Futex< test::DeterministicAtomic > *	futex,
		int	count,
		uint32_t	wakeMask
	)

Definition at line 384 of file DeterministicSchedule.cpp.

References folly::test::DeterministicSchedule::afterSharedAccess(), folly::test::DeterministicSchedule::beforeSharedAccess(), count, FOLLY_TEST_DSCHED_VLOG, and futexQueues.

                        {
   using namespace test;
   using namespace std::chrono;
 
   int rv = 0;
   DeterministicSchedule::beforeSharedAccess();
   futexLock.lock();
   if (futexQueues.count(futex) > 0) {
     auto& queue = futexQueues[futex];
     auto iter = queue.begin();
     while (iter != queue.end() && rv < count) {
       auto cur = iter++;
       if ((cur->first & wakeMask) != 0) {
         *(cur->second) = true;
         rv++;
         queue.erase(cur);
       }
     }
     if (queue.empty()) {
       futexQueues.erase(futex);
     }
   }
   futexLock.unlock();
   FOLLY_TEST_DSCHED_VLOG(
       "futexWake(" << futex << ", " << count << ", " << std::hex << wakeMask
                    << ") -> " << rv);
   DeterministicSchedule::afterSharedAccess();
   return rv;
 }

std::string folly::test::glogErrorPattern ( )

inline

Use these patterns together with CaptureFD and EXPECT_PCRE_MATCH() to test for the presence (or absence) of log lines at a particular level:

CaptureFD stderr(2); LOG(INFO) << "All is well"; EXPECT_NO_PCRE_MATCH(glogErrOrWarnPattern(), stderr.readIncremental()); LOG(ERROR) << "Uh-oh"; EXPECT_PCRE_MATCH(glogErrorPattern(), stderr.readIncremental());

Definition at line 205 of file TestUtil.h.

Referenced by TEST().

                                     {
   return ".*(^|\n)E[0-9].*";
 }

std::string folly::test::glogErrOrWarnPattern ( )

inline

Definition at line 212 of file TestUtil.h.

Referenced by TEST().

                                         {
   return ".*(^|\n)[EW][0-9].*";
 }

std::string folly::test::glogWarningPattern ( )

inline

Definition at line 208 of file TestUtil.h.

Referenced by TEST().

                                       {
   return ".*(^|\n)W[0-9].*";
 }

folly::test::MATCHER_P	(	BufMatches	,
		expected	,
		""
	)

Definition at line 54 of file WriteChainAsyncTransportWrapperTest.cpp.

References folly::eq.

                                     {
   folly::IOBufEqualTo eq;
   return eq(*arg, *expected);
 }

template<typename Func >

auto folly::test::msvcSuppressAbortOnInvalidParams ( Func func ) -> decltype(func())

Definition at line 166 of file TestUtil.h.

References folly::test::detail::disableInvalidParameters(), folly::test::detail::enableInvalidParameters(), and SCOPE_EXIT.

Referenced by folly::WriteErrorCallback::readDataAvailable(), TEST(), and TEST_F().

                                                                      {
   auto savedState = detail::disableInvalidParameters();
   SCOPE_EXIT {
     detail::enableInvalidParameters(savedState);
   };
   return func();
 }

bool folly::test::operator==	(	const MovableInt &	a,
		const MovableInt &	b
	)

Definition at line 58 of file TupleOpsTest.cpp.

References folly::test::MovableInt::value().

Referenced by TEST().

                                                           {
   return a.value() == b.value();
 }

template<bool MayBlock, template< typename > class Atom>

void folly::test::run_basic_test ( )

Definition at line 29 of file BatonTestHelpers.h.

References Atom, b, folly::Baton< MayBlock, Atom >::post(), and folly::Baton< MayBlock, Atom >::wait().

                       {
   Baton<MayBlock, Atom> b;
   b.post();
   b.wait();
 }

template<bool MayBlock, template< typename > class Atom, typename Clock >

void folly::test::run_basic_timed_wait_tests ( )

Definition at line 57 of file BatonTestHelpers.h.

References Atom, b, EXPECT_TRUE, now(), folly::Baton< MayBlock, Atom >::post(), and folly::Baton< MayBlock, Atom >::try_wait_until().

                                   {
   Baton<MayBlock, Atom> b;
   b.post();
   // tests if early delivery works fine
   EXPECT_TRUE(b.try_wait_until(Clock::now()));
 }

template<bool MayBlock, template< typename > class Atom>

void folly::test::run_pingpong_test ( int numRounds )

Definition at line 36 of file BatonTestHelpers.h.

References a, Atom, b, i, folly::test::DeterministicSchedule::join(), and folly::test::DeterministicSchedule::thread().

                                       {
   using B = Baton<MayBlock, Atom>;
   B batons[17];
   B& a = batons[0];
   B& b = batons[16]; // to get it on a different cache line
   auto thr = DSched::thread([&] {
     for (int i = 0; i < numRounds; ++i) {
       a.wait();
       a.reset();
       b.post();
     }
   });
   for (int i = 0; i < numRounds; ++i) {
     a.post();
     b.wait();
     b.reset();
   }
   DSched::join(thr);
 }

uint64_t folly::test::run_test	(	int	nthreads,
		int	lines,
		int	numRecs,
		int	work,
		int	ops,
		bool	combining,
		bool	simple,
		bool	dedicated,
		bool	tc,
		bool	syncops,
		bool	excl = `false`,
		bool	allocAll = `false`
	)

Definition at line 180 of file FlatCombiningTestHelpers.h.

References dedicated, folly::gen::lines(), M, mutex, nthreads, ops, syncops, and tc.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), test(), and TEST_P().

                            {
   using M = std::mutex;
   if (simple) {
     using Example = FcSimpleExample<M>;
     return fc_test<Example, bool, M>(
         nthreads,
         lines,
         numRecs,
         work,
         ops,
         combining,
         dedicated,
         tc,
         syncops,
         excl,
         allocAll);
   } else {
     using Example = FcCustomExample<Req, M>;
     return fc_test<Example, Req, M>(
         nthreads,
         lines,
         numRecs,
         work,
         ops,
         combining,
         dedicated,
         tc,
         syncops,
         excl,
         allocAll);
   }
 }

template<bool MayBlock, template< typename > class Atom, typename Clock >

void folly::test::run_timed_wait_regular_test ( )

Definition at line 77 of file BatonTestHelpers.h.

References b, EXPECT_TRUE, folly::test::DeterministicSchedule::join(), now(), folly::Baton< MayBlock, Atom >::post(), folly::test::DeterministicSchedule::thread(), folly::Baton< MayBlock, Atom >::try_wait_until(), and folly::value().

                                    {
   Baton<MayBlock, Atom> b;
 
   auto thr = DSched::thread([&] {
     // To wait forever we'd like to use time_point<Clock>::max, but
     // std::condition_variable does math to convert the timeout to
     // system_clock without handling overflow.
     auto farFuture = Clock::now() + std::chrono::hours(1000);
     bool rv = b.try_wait_until(farFuture);
     if (!std::is_same<Atom<int>, DeterministicAtomic<int>>::value) {
       // DeterministicAtomic ignores actual times, so doesn't guarantee
       // a lack of timeout
       EXPECT_TRUE(rv);
     }
   });
 
   if (!std::is_same<Atom<int>, DeterministicAtomic<int>>::value) {
     // If we are using std::atomic (or EmulatedFutexAtomic) then
     // a sleep here guarantees to a large extent that 'thr' will
     // execute wait before we post it, thus testing late delivery. For
     // DeterministicAtomic, we just rely on DeterministicSchedule to do
     // the scheduling.  The test won't fail if we lose the race, we just
     // don't get coverage.
     std::this_thread::sleep_for(std::chrono::milliseconds(2));
   }
 
   b.post();
   DSched::join(thr);
 }

template<bool MayBlock, template< typename > class Atom, typename Clock >

void folly::test::run_timed_wait_tmo_tests ( )

Definition at line 65 of file BatonTestHelpers.h.

References Atom, b, EXPECT_FALSE, folly::test::DeterministicSchedule::join(), now(), folly::test::DeterministicSchedule::thread(), and folly::Baton< MayBlock, Atom >::try_wait_until().

                                 {
   Baton<MayBlock, Atom> b;
 
   auto thr = DSched::thread([&] {
     bool rv = b.try_wait_until(Clock::now() + std::chrono::milliseconds(1));
     // main thread is guaranteed to not post until timeout occurs
     EXPECT_FALSE(rv);
   });
   DSched::join(thr);
 }

template<bool MayBlock, template< typename > class Atom>

void folly::test::run_try_wait_tests ( )

Definition at line 108 of file BatonTestHelpers.h.

References b, EXPECT_FALSE, EXPECT_TRUE, folly::Baton< MayBlock, Atom >::post(), folly::Baton< MayBlock, Atom >::ready(), and folly::Baton< MayBlock, Atom >::try_wait().

                           {
   Baton<MayBlock, Atom> b;
   EXPECT_FALSE(b.ready());
   EXPECT_FALSE(b.try_wait());
   b.post();
   EXPECT_TRUE(b.ready());
   EXPECT_TRUE(b.try_wait());
 }

void folly::test::runCloseTest ( bool abortive )

Definition at line 139 of file ShutdownSocketSetTest.cpp.

References c, folly::netops::close(), folly::test::Server::closeClients(), createConnectedSocket(), EXPECT_EQ, folly::test::Server::join(), folly::test::Server::port(), fizz::detail::read(), and folly::test::Server::stop().

Referenced by TEST().

                                  {
   Server server;
 
   int sock = createConnectedSocket(server.port());
 
   std::thread stopper([&server, abortive] {
     std::this_thread::sleep_for(std::chrono::milliseconds(200));
     server.stop(abortive);
     server.join();
   });
 
   char c;
   int r = read(sock, &c, 1);
   if (abortive) {
     int e = errno;
     EXPECT_EQ(-1, r);
     EXPECT_EQ(ECONNRESET, e);
   } else {
     EXPECT_EQ(0, r);
   }
 
   close(sock);
 
   stopper.join();
 
   EXPECT_EQ(0, server.closeClients(false)); // closed by server when it exited
 }

void folly::test::runKillTest ( bool abortive )

Definition at line 175 of file ShutdownSocketSetTest.cpp.

Referenced by TEST().

                                 {
   Server server;
 
   int sock = createConnectedSocket(server.port());
 
   std::thread killer([&server, abortive] {
     std::this_thread::sleep_for(std::chrono::milliseconds(200));
     shutdownSocketSet.shutdownAll(abortive);
     server.join();
   });
 
   char c;
   int r = read(sock, &c, 1);
 
   // "abortive" is just a hint for ShutdownSocketSet, so accept both
   // behaviors
   if (abortive) {
     if (r == -1) {
       EXPECT_EQ(ECONNRESET, errno);
     } else {
       EXPECT_EQ(r, 0);
     }
   } else {
     EXPECT_EQ(0, r);
   }
 
   close(sock);
 
   killer.join();
 
   // NOT closed by server when it exited
   EXPECT_EQ(1, server.closeClients(false));
 }

unsigned folly::test::staticTracepointTestFunc ( unsigned v )

Definition at line 24 of file StaticTracepointTestModule.cpp.

References FOLLY_SDT_WITH_SEMAPHORE, and v.

Referenced by TEST().

                                               {
   unsigned res = v * v;
   FOLLY_SDT_WITH_SEMAPHORE(folly, test_semaphore_extern, v, res);
   return res;
 }

folly::test::TEST	(	AtomicBitSet	,
		Simple
	)

Definition at line 26 of file AtomicBitSetTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, i, folly::AtomicBitSet< N >::reset(), folly::AtomicBitSet< N >::set(), and folly::AtomicBitSet< N >::size().

                            {
   constexpr size_t kSize = 1000;
   AtomicBitSet<kSize> bs;
 
   EXPECT_EQ(kSize, bs.size());
 
   for (size_t i = 0; i < kSize; ++i) {
     EXPECT_FALSE(bs[i]);
   }
 
   bs.set(42);
   for (size_t i = 0; i < kSize; ++i) {
     EXPECT_EQ(i == 42, bs[i]);
   }
 
   bs.set(43);
   for (size_t i = 0; i < kSize; ++i) {
     EXPECT_EQ((i == 42 || i == 43), bs[i]);
   }
 
   bs.reset(42);
   for (size_t i = 0; i < kSize; ++i) {
     EXPECT_EQ((i == 43), bs[i]);
   }
 
   bs.reset(43);
   for (size_t i = 0; i < kSize; ++i) {
     EXPECT_FALSE(bs[i]);
   }
 }

folly::test::TEST	(	TupleOps	,
		Copiable
	)

Definition at line 27 of file TupleOpsTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, std::tr1::make_tuple(), string, folly::pushmi::detail::t, folly::tuplePrepend(), and folly::value().

                          {
   auto t = std::make_tuple(10, std::string("hello"), 30);
 
   EXPECT_EQ(10, std::get<0>(t));
   auto t1 = tupleRange<1>(t);
   EXPECT_EQ("hello", std::get<0>(t1));
   EXPECT_EQ(2, std::tuple_size<decltype(t1)>::value);
   auto t2 = tupleRange<1, 1>(t);
   EXPECT_EQ(1, std::tuple_size<decltype(t2)>::value);
   EXPECT_EQ("hello", std::get<0>(t2));
   EXPECT_EQ(30, std::get<0>(tupleRange<1>(tupleRange<1>(t))));
 
   EXPECT_TRUE(t == tuplePrepend(std::get<0>(t), tupleRange<1>(t)));
 }

folly::test::TEST	(	MPMCPipeline	,
		Trivial
	)

Definition at line 30 of file MPMCPipelineTest.cpp.

References a, folly::MPMCPipeline< In, Stages >::blockingRead(), folly::MPMCPipeline< In, Stages >::blockingReadStage(), folly::MPMCPipeline< In, Stages >::blockingWrite(), folly::MPMCPipeline< In, Stages >::blockingWriteStage(), EXPECT_EQ, s, folly::MPMCPipeline< In, Stages >::sizeGuess(), string, ticket, and val.

                             {
   MPMCPipeline<int, std::string> a(2, 2);
   EXPECT_EQ(0, a.sizeGuess());
   a.blockingWrite(42);
   EXPECT_EQ(1, a.sizeGuess());
 
   int val;
   auto ticket = a.blockingReadStage<0>(val);
   EXPECT_EQ(42, val);
   EXPECT_EQ(1, a.sizeGuess());
 
   a.blockingWriteStage<0>(ticket, "hello world");
   EXPECT_EQ(1, a.sizeGuess());
 
   std::string s;
 
   a.blockingRead(s);
   EXPECT_EQ("hello world", s);
   EXPECT_EQ(0, a.sizeGuess());
 }

folly::test::TEST	(	Overload	,
		BoostVariant
	)

Definition at line 36 of file OverloadTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::test::One::toString(), folly::value(), and folly::variant_match().

                              {
   OneOrTwo one(One{});
   OneOrTwo two(Two{});
 
   EXPECT_TRUE(variant_match(
       one, [](const One&) { return true; }, [](const Two&) { return false; }));
   EXPECT_TRUE(variant_match(
       two, [](const One&) { return false; }, [](const Two&) { return true; }));
 
   auto toString = [](const auto& variant) {
     return variant_match(
         variant, [](const auto& value) { return value.toString(); });
   };
   EXPECT_EQ(toString(one), "One");
   EXPECT_EQ(toString(two), "Two");
 }

folly::test::TEST	(	ExceptionTest	,
		Simple
	)

Definition at line 39 of file ExceptionTest.cpp.

References ASSERT_TRUE, folly::checkFopenError(), folly::checkFopenErrorExplicit(), folly::checkKernelError(), folly::checkPosixError(), folly::checkUnixError(), folly::checkUnixErrorExplicit(), EXPECT_NO_THROW, EXPECT_SYSTEM_ERROR, folly::test::TemporaryDirectory::path(), SCOPE_EXIT, folly::throwSystemError(), and folly::throwSystemErrorExplicit().

                             {
   // Make sure errno isn't used when we don't want it to, set it to something
   // else than what we set when we call Explicit functions
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(throwSystemErrorExplicit(EIO, "hello"), EIO, "hello");
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       throwSystemErrorExplicit(EIO, "hello", " world"), EIO, "hello world");
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       throwSystemError("hello", " world"), ERANGE, "hello world");
 
   EXPECT_NO_THROW(checkPosixError(0, "hello", " world"));
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       checkPosixError(EIO, "hello", " world"), EIO, "hello world");
 
   EXPECT_NO_THROW(checkKernelError(0, "hello", " world"));
   EXPECT_NO_THROW(checkKernelError(EIO, "hello", " world"));
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       checkKernelError(-EIO, "hello", " world"), EIO, "hello world");
 
   EXPECT_NO_THROW(checkUnixError(0, "hello", " world"));
   EXPECT_NO_THROW(checkUnixError(1, "hello", " world"));
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       checkUnixError(-1, "hello", " world"), ERANGE, "hello world");
 
   EXPECT_NO_THROW(checkUnixErrorExplicit(0, EIO, "hello", " world"));
   EXPECT_NO_THROW(checkUnixErrorExplicit(1, EIO, "hello", " world"));
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       checkUnixErrorExplicit(-1, EIO, "hello", " world"), EIO, "hello world");
 
   TemporaryDirectory tmpdir;
   auto exnpath = tmpdir.path() / "ExceptionTest";
   auto fp = fopen(exnpath.string().c_str(), "w+b");
   ASSERT_TRUE(fp != nullptr);
   SCOPE_EXIT {
     fclose(fp);
   };
 
   EXPECT_NO_THROW(checkFopenError(fp, "hello", " world"));
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       checkFopenError(nullptr, "hello", " world"), ERANGE, "hello world");
 
   EXPECT_NO_THROW(checkFopenErrorExplicit(fp, EIO, "hello", " world"));
   errno = ERANGE;
   EXPECT_SYSTEM_ERROR(
       checkFopenErrorExplicit(nullptr, EIO, "hello", " world"),
       EIO,
       "hello world");
 }

folly::test::TEST	(	MPMCPipeline	,
		TrivialAmplification
	)

Definition at line 51 of file MPMCPipelineTest.cpp.

                                          {
   MPMCPipeline<int, MPMCPipelineStage<std::string, 2>> a(2, 2);
   EXPECT_EQ(0, a.sizeGuess());
   a.blockingWrite(42);
   EXPECT_EQ(2, a.sizeGuess());
 
   int val;
   auto ticket = a.blockingReadStage<0>(val);
   EXPECT_EQ(42, val);
   EXPECT_EQ(2, a.sizeGuess());
 
   a.blockingWriteStage<0>(ticket, "hello world");
   EXPECT_EQ(2, a.sizeGuess());
   a.blockingWriteStage<0>(ticket, "goodbye");
   EXPECT_EQ(2, a.sizeGuess());
 
   std::string s;
 
   a.blockingRead(s);
   EXPECT_EQ("hello world", s);
   EXPECT_EQ(1, a.sizeGuess());
 
   a.blockingRead(s);
   EXPECT_EQ("goodbye", s);
   EXPECT_EQ(0, a.sizeGuess());
 }

folly::test::TEST	(	Overload	,
		DiscriminatedPtr
	)

Definition at line 53 of file OverloadTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::test::One::toString(), folly::value(), and folly::variant_match().

                                  {
   using V = DiscriminatedPtr<One, Two>;
   One one_obj;
   Two two_obj;
   V one_ptr(&one_obj);
   V two_ptr(&two_obj);
 
   EXPECT_TRUE(variant_match(
       one_ptr,
       [](const One*) { return true; },
       [](const Two*) { return false; }));
   EXPECT_TRUE(variant_match(
       two_ptr,
       [](const One*) { return false; },
       [](const Two*) { return true; }));
 
   auto toString = [](const auto& variant) {
     return variant_match(
         variant, [](const auto* value) { return value->toString(); });
   };
   EXPECT_EQ(toString(one_ptr), "One");
   EXPECT_EQ(toString(two_ptr), "Two");
 }

folly::test::TEST	(	RecordIOTest	,
		Simple
	)

Definition at line 57 of file RecordIOTest.cpp.

References ASSERT_FALSE, folly::RecordIOReader::begin(), folly::RecordIOReader::end(), EXPECT_EQ, EXPECT_TRUE, folly::test::TemporaryFile::fd(), folly::gen::first, and folly::RecordIOWriter::write().

                            {
   TemporaryFile file;
   {
     RecordIOWriter writer(File(file.fd()));
     writer.write(iobufs({"hello ", "world"}));
     writer.write(iobufs({"goodbye"}));
   }
   {
     RecordIOReader reader(File(file.fd()));
     auto it = reader.begin();
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("hello world", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("goodbye", sp((it++)->first));
     EXPECT_TRUE(it == reader.end());
   }
   {
     RecordIOWriter writer(File(file.fd()));
     writer.write(iobufs({"meow"}));
     writer.write(iobufs({"woof"}));
   }
   {
     RecordIOReader reader(File(file.fd()));
     auto it = reader.begin();
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("hello world", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("goodbye", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("meow", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("woof", sp((it++)->first));
     EXPECT_TRUE(it == reader.end());
   }
 }

folly::test::TEST	(	WriteChainAsyncTransportWrapperTest	,
		TestSimpleIov
	)

Definition at line 59 of file WriteChainAsyncTransportWrapperTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_CALL, and folly::WriteChainAsyncTransportWrapper< T >::writev().

                                                          {
   TestWriteChainAsyncTransportWrapper transport;
   auto buf = folly::IOBuf::copyBuffer("foo");
 
   EXPECT_CALL(transport, writeChain(_, BufMatches(buf.get()), _));
 
   auto iov = buf->getIov();
   transport.writev(nullptr, iov.data(), iov.size());
 }

folly::test::TEST	(	TupleOps	,
		Movable
	)

Definition at line 62 of file TupleOpsTest.cpp.

References EXPECT_TRUE, std::tr1::make_tuple(), folly::test::MovableInt::MovableInt(), folly::gen::move, string, folly::T, folly::tuplePrepend(), and tupleTo().

                         {
   auto t1 = std::make_tuple(MovableInt(10), std::string("hello"), 30);
   auto t2 = std::make_tuple(MovableInt(10), std::string("hello"), 30);
   auto t3 = std::make_tuple(MovableInt(10), std::string("hello"), 30);
 
   auto t1car = std::get<0>(std::move(t1));
   auto t2cdr = tupleRange<1>(std::move(t2));
 
   EXPECT_TRUE(t3 == tuplePrepend(std::move(t1car), std::move(t2cdr)));
 }

folly::test::TEST	(	ProgramOptionsTest	,
		Errors
	)

Definition at line 67 of file NestedCommandLineAppTest.cpp.

Referenced by TEST().

                                  {
   callHelper({}, 1);
   callHelper({"--wtf", "foo"}, 1);
   callHelper({"qux"}, 1);
   callHelper({"--global-foo", "x", "foo"}, 1);
 }

folly::test::TEST	(	WriteChainAsyncTransportWrapperTest	,
		TestChainedIov
	)

Definition at line 69 of file WriteChainAsyncTransportWrapperTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_CALL, and folly::WriteChainAsyncTransportWrapper< T >::writev().

                                                           {
   TestWriteChainAsyncTransportWrapper transport;
   auto buf = folly::IOBuf::copyBuffer("hello");
   buf->prependChain(folly::IOBuf::copyBuffer("world"));
 
   EXPECT_CALL(transport, writeChain(_, BufMatches(buf.get()), _));
 
   auto iov = buf->getIov();
   transport.writev(nullptr, iov.data(), iov.size());
 }

folly::test::TEST	(	Varint	,
		Interface
	)

Definition at line 70 of file VarintTest.cpp.

References c, folly::decodeVarint(), and EXPECT_EQ.

                         {
   // Make sure decodeVarint() accepts all of StringPiece, MutableStringPiece,
   // ByteRange, and MutableByteRange.
   char c = 0;
 
   StringPiece sp(&c, 1);
   EXPECT_EQ(decodeVarint(sp), 0);
 
   MutableStringPiece msp(&c, 1);
   EXPECT_EQ(decodeVarint(msp), 0);
 
   ByteRange br(reinterpret_cast<unsigned char*>(&c), 1);
   EXPECT_EQ(decodeVarint(br), 0);
 
   MutableByteRange mbr(reinterpret_cast<unsigned char*>(&c), 1);
   EXPECT_EQ(decodeVarint(mbr), 0);
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GFlagsStyleDefaultValues
	)

Definition at line 71 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GFLAGS.

                                                    {
   EXPECT_EQ(
       "flag_bool_true 1\n"
       "flag_bool_false 0\n"
       "flag_int 42\n"
       "flag_string foo\n",
       callHelper(ProgramOptionsStyle::GFLAGS, {}));
 }

folly::test::TEST	(	ProgramOptionsTest	,
		Help
	)

Definition at line 74 of file NestedCommandLineAppTest.cpp.

                                {
   // Not actually checking help output, just verifying that help doesn't fail
   callHelper({"--version"});
   callHelper({"--help"});
   callHelper({"--help", "foo"});
   callHelper({"--help", "bar"});
   callHelper({"--help", "--", "bar"});
   callHelper({"help"});
   callHelper({"help", "foo"});
   callHelper({"help", "bar"});
 
   // wrong command name
   callHelper({"--help", "qux"}, 1);
   callHelper({"help", "qux"}, 1);
 
   // anything after -- is parsed as arguments
   callHelper({"--", "help", "bar"}, 1);
 }

folly::test::TEST	(	Overload	,
		Pattern
	)

Definition at line 77 of file OverloadTest.cpp.

References folly::apply_visitor(), EXPECT_FALSE, EXPECT_TRUE, folly::overload(), and folly::variant_match().

                         {
   OneOrTwo one(One{});
   OneOrTwo two(Two{});
 
   auto is_one_overload = overload(
       [](const One&) { return true; }, [](const Two&) { return false; });
   EXPECT_TRUE(boost::apply_visitor(is_one_overload, one));
   EXPECT_TRUE(variant_match(one, is_one_overload));
   EXPECT_FALSE(variant_match(two, is_one_overload));
 
   auto is_two_overload = overload(
       [](const One&) { return false; }, [](const Two&) { return true; });
   EXPECT_TRUE(boost::apply_visitor(is_two_overload, two));
   EXPECT_FALSE(variant_match(one, is_two_overload));
   EXPECT_TRUE(variant_match(two, is_two_overload));
 
   auto is_one_copy = overload(is_one_overload);
   auto is_one_const_copy =
       overload(static_cast<const decltype(is_one_overload)&>(is_one_overload));
   EXPECT_TRUE(variant_match(one, is_one_copy));
   EXPECT_TRUE(variant_match(one, is_one_const_copy));
   EXPECT_FALSE(variant_match(two, is_one_copy));
   EXPECT_FALSE(variant_match(two, is_one_const_copy));
 }

folly::test::TEST	(	MPMCPipeline	,
		MultiThreaded
	)

Definition at line 78 of file MPMCPipelineTest.cpp.

References a, folly::MPMCPipeline< In, Stages >::blockingRead(), folly::MPMCPipeline< In, Stages >::blockingReadStage(), folly::MPMCPipeline< In, Stages >::blockingWrite(), folly::MPMCPipeline< In, Stages >::blockingWriteStage(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, i, folly::MPMCPipeline< In, Stages >::read(), folly::MPMCPipeline< In, Stages >::sizeGuess(), string, folly::pushmi::detail::t, threads, ticket, and val.

                                   {
   constexpr size_t numThreadsPerStage = 6;
   MPMCPipeline<int, std::string, std::string> a(5, 5, 5);
 
   std::vector<std::thread> threads;
   threads.reserve(numThreadsPerStage * 2 + 1);
   for (size_t i = 0; i < numThreadsPerStage; ++i) {
     threads.emplace_back([&a] {
       for (;;) {
         int val;
         auto ticket = a.blockingReadStage<0>(val);
         if (val == -1) { // stop
           // We still need to propagate
           a.blockingWriteStage<0>(ticket, "");
           break;
         }
         a.blockingWriteStage<0>(ticket, folly::to<std::string>(val, " hello"));
       }
     });
   }
 
   for (size_t i = 0; i < numThreadsPerStage; ++i) {
     threads.emplace_back([&a] {
       for (;;) {
         std::string val;
         auto ticket = a.blockingReadStage<1>(val);
         if (val.empty()) { // stop
           // We still need to propagate
           a.blockingWriteStage<1>(ticket, "");
           break;
         }
         a.blockingWriteStage<1>(ticket, folly::to<std::string>(val, " world"));
       }
     });
   }
 
   std::vector<std::string> results;
   threads.emplace_back([&a, &results]() {
     for (;;) {
       std::string val;
       a.blockingRead(val);
       if (val.empty()) {
         break;
       }
       results.push_back(val);
     }
   });
 
   constexpr size_t numValues = 1000;
   for (size_t i = 0; i < numValues; ++i) {
     a.blockingWrite(i);
   }
   for (size_t i = 0; i < numThreadsPerStage; ++i) {
     a.blockingWrite(-1);
   }
 
   for (auto& t : threads) {
     t.join();
   }
 
   // The consumer thread dequeued the first empty string, there should be
   // numThreadsPerStage - 1 left.
   EXPECT_EQ(numThreadsPerStage - 1, a.sizeGuess());
   for (size_t i = 0; i < numThreadsPerStage - 1; ++i) {
     std::string val;
     a.blockingRead(val);
     EXPECT_TRUE(val.empty());
   }
   {
     std::string tmp;
     EXPECT_FALSE(a.read(tmp));
   }
   EXPECT_EQ(0, a.sizeGuess());
 
   EXPECT_EQ(numValues, results.size());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_EQ(folly::to<std::string>(i, " hello world"), results[i]);
   }
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GFlagsStyleFlagsSet
	)

Definition at line 80 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GFLAGS.

                                               {
   EXPECT_EQ(
       "flag_bool_true 1\n"
       "flag_bool_false 1\n"
       "flag_int 43\n"
       "flag_string bar\n",
       callHelper(
           ProgramOptionsStyle::GFLAGS,
           {
               "--flag_bool_true",
               "--flag_bool_false",
               "--flag_int",
               "43",
               "--flag_string",
               "bar",
           }));
 }

folly::test::TEST	(	WriteChainAsyncTransportWrapperTest	,
		TestSimpleBuf
	)

Definition at line 80 of file WriteChainAsyncTransportWrapperTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_CALL, and folly::WriteChainAsyncTransportWrapper< T >::write().

                                                          {
   TestWriteChainAsyncTransportWrapper transport;
   auto buf = folly::IOBuf::copyBuffer("foobar");
 
   EXPECT_CALL(transport, writeChain(_, BufMatches(buf.get()), _));
 
   transport.write(nullptr, buf->data(), buf->length());
 }

folly::test::TEST	(	Varint	,
		Simple
	)

Definition at line 88 of file VarintTest.cpp.

References testVarint().

                      {
   testVarint(0, {0});
   testVarint(1, {1});
   testVarint(127, {127});
   testVarint(128, {0x80, 0x01});
   testVarint(300, {0xac, 0x02});
   testVarint(16383, {0xff, 0x7f});
   testVarint(16384, {0x80, 0x80, 0x01});
 
   testVarint(static_cast<uint32_t>(-1), {0xff, 0xff, 0xff, 0xff, 0x0f});
   testVarint(
       static_cast<uint64_t>(-1),
       {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01});
 }

folly::test::TEST	(	RecordIOTest	,
		SmallRecords
	)

Definition at line 93 of file RecordIOTest.cpp.

                                  {
   constexpr size_t kSize = 10;
   char tmp[kSize];
   memset(tmp, 'x', kSize);
   TemporaryFile file;
   {
     RecordIOWriter writer(File(file.fd()));
     for (size_t i = 0; i < kSize; ++i) { // record of size 0 should be ignored
       writer.write(IOBuf::wrapBuffer(tmp, i));
     }
   }
   {
     RecordIOReader reader(File(file.fd()));
     auto it = reader.begin();
     for (size_t i = 1; i < kSize; ++i) {
       ASSERT_FALSE(it == reader.end());
       EXPECT_EQ(StringPiece(tmp, i), sp((it++)->first));
     }
     EXPECT_TRUE(it == reader.end());
   }
 }

folly::test::TEST	(	ProgramOptionsTest	,
		DevFull
	)

Definition at line 93 of file NestedCommandLineAppTest.cpp.

References folly::File::fd().

                                   {
   folly::File full("/dev/full", O_RDWR);
   callHelper({"--help"}, 1, full.fd());
 }

folly::test::TEST	(	ExceptionTest	,
		makeSystemError
	)

Definition at line 95 of file ExceptionTest.cpp.

References folly::Range< Iter >::contains(), EXPECT_EQ, EXPECT_TRUE, folly::makeSystemError(), and folly::makeSystemErrorExplicit().

                                      {
   errno = ENOENT;
   auto ex = makeSystemErrorExplicit(EDEADLK, "stuck");
   EXPECT_EQ(EDEADLK, ex.code().value());
   EXPECT_EQ(std::system_category(), ex.code().category());
   EXPECT_TRUE(StringPiece{ex.what()}.contains("stuck"))
       << "what() string missing input message: " << ex.what();
 
   ex = makeSystemErrorExplicit(EDOM, 300, " is bigger than max=", 255);
   EXPECT_EQ(EDOM, ex.code().value());
   EXPECT_EQ(std::system_category(), ex.code().category());
   EXPECT_TRUE(StringPiece{ex.what()}.contains("300 is bigger than max=255"))
       << "what() string missing input message: " << ex.what();
 
   errno = EINVAL;
   ex = makeSystemError("bad argument ", 1234, ": bogus");
   EXPECT_EQ(EINVAL, ex.code().value());
   EXPECT_EQ(std::system_category(), ex.code().category());
   EXPECT_TRUE(StringPiece{ex.what()}.contains("bad argument 1234: bogus"))
       << "what() string missing input message: " << ex.what();
 
   errno = 0;
   ex = makeSystemError("unexpected success");
   EXPECT_EQ(0, ex.code().value());
   EXPECT_EQ(std::system_category(), ex.code().category());
   EXPECT_TRUE(StringPiece{ex.what()}.contains("unexpected success"))
       << "what() string missing input message: " << ex.what();
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GFlagsStyleBoolFlagsNegation
	)

Definition at line 98 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GFLAGS.

                                                        {
   EXPECT_EQ(
       "flag_bool_true 0\n"
       "flag_bool_false 0\n"
       "flag_int 42\n"
       "flag_string foo\n",
       callHelper(
           ProgramOptionsStyle::GFLAGS,
           {
               "--noflag_bool_true",
               "--noflag_bool_false",
           }));
 }

folly::test::TEST	(	ProgramOptionsTest	,
		CutArguments
	)

Definition at line 98 of file NestedCommandLineAppTest.cpp.

References EXPECT_EQ.

                                        {
   // anything after -- is parsed as arguments
   EXPECT_EQ(
       "running foo\n"
       "foo global-foo 43\n"
       "foo local-foo 42\n"
       "foo arg b\n"
       "foo arg --local-foo\n"
       "foo arg 44\n"
       "foo arg a\n",
       callHelper(
           {"foo", "--global-foo", "43", "--", "b", "--local-foo", "44", "a"}));
 }

folly::test::TEST	(	Varint	,
		Fail
	)

Definition at line 110 of file VarintTest.cpp.

References testVarintFail().

                    {
   testVarintFail({0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff});
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GNUStyleDefaultValues
	)

Definition at line 112 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GNU.

                                                 {
   EXPECT_EQ(
       "flag-bool-true 1\n"
       "flag-bool-false 0\n"
       "flag-int 42\n"
       "flag-string foo\n",
       callHelper(ProgramOptionsStyle::GNU, {}));
 }

folly::test::TEST	(	ProgramOptionsTest	,
		Success
	)

Definition at line 112 of file NestedCommandLineAppTest.cpp.

References EXPECT_EQ.

                                   {
   EXPECT_EQ(
       "running foo\n"
       "foo global-foo 42\n"
       "foo local-foo 42\n",
       callHelper({"foo"}));
 
   EXPECT_EQ(
       "running foo\n"
       "foo global-foo 43\n"
       "foo local-foo 44\n"
       "foo arg a\n"
       "foo arg b\n",
       callHelper({"--global-foo", "43", "foo", "--local-foo", "44", "a", "b"}));
 
   // Check that global flags can still be given after the command
   EXPECT_EQ(
       "running foo\n"
       "foo global-foo 43\n"
       "foo local-foo 44\n"
       "foo arg a\n"
       "foo arg b\n",
       callHelper({"foo", "--global-foo", "43", "--local-foo", "44", "a", "b"}));
 }

folly::test::TEST	(	ZigZag	,
		Simple
	)

Definition at line 114 of file VarintTest.cpp.

References folly::BENCHMARK(), folly::decodeVarint(), folly::decodeZigZag(), folly::Range< Iter >::empty(), folly::encodeVarint(), folly::encodeZigZag(), EXPECT_EQ, i, folly::INFO, folly::kMaxVarintLength64, folly::range(), rng, start, uint64_t, uint8_t, and val.

                      {
   EXPECT_EQ(0, encodeZigZag(0));
   EXPECT_EQ(1, encodeZigZag(-1));
   EXPECT_EQ(2, encodeZigZag(1));
   EXPECT_EQ(3, encodeZigZag(-2));
   EXPECT_EQ(4, encodeZigZag(2));
 
   EXPECT_EQ(0, decodeZigZag(0));
   EXPECT_EQ(-1, decodeZigZag(1));
   EXPECT_EQ(1, decodeZigZag(2));
   EXPECT_EQ(-2, decodeZigZag(3));
   EXPECT_EQ(2, decodeZigZag(4));
 }

folly::test::TEST	(	RecordIOTest	,
		MultipleFileIds
	)

Definition at line 115 of file RecordIOTest.cpp.

References ASSERT_FALSE, folly::RecordIOReader::begin(), folly::RecordIOReader::end(), EXPECT_EQ, EXPECT_TRUE, folly::test::TemporaryFile::fd(), folly::gen::first, and folly::RecordIOWriter::write().

                                     {
   TemporaryFile file;
   {
     RecordIOWriter writer(File(file.fd()), 1);
     writer.write(iobufs({"hello"}));
   }
   {
     RecordIOWriter writer(File(file.fd()), 2);
     writer.write(iobufs({"world"}));
   }
   {
     RecordIOWriter writer(File(file.fd()), 1);
     writer.write(iobufs({"goodbye"}));
   }
   {
     RecordIOReader reader(File(file.fd()), 0); // return all
     auto it = reader.begin();
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("hello", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("world", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("goodbye", sp((it++)->first));
     EXPECT_TRUE(it == reader.end());
   }
   {
     RecordIOReader reader(File(file.fd()), 1);
     auto it = reader.begin();
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("hello", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("goodbye", sp((it++)->first));
     EXPECT_TRUE(it == reader.end());
   }
   {
     RecordIOReader reader(File(file.fd()), 2);
     auto it = reader.begin();
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("world", sp((it++)->first));
     EXPECT_TRUE(it == reader.end());
   }
   {
     RecordIOReader reader(File(file.fd()), 3);
     auto it = reader.begin();
     EXPECT_TRUE(it == reader.end());
   }
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GNUStyleFlagsSet
	)

Definition at line 121 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GNU.

                                            {
   EXPECT_EQ(
       "flag-bool-true 1\n"
       "flag-bool-false 1\n"
       "flag-int 43\n"
       "flag-string bar\n",
       callHelper(
           ProgramOptionsStyle::GNU,
           {
               "--flag-bool-true",
               "--flag-bool-false",
               "--flag-int",
               "43",
               "--flag-string",
               "bar",
           }));
 }

folly::test::TEST	(	ProgramOptionsTest	,
		Aliases
	)

Definition at line 137 of file NestedCommandLineAppTest.cpp.

References EXPECT_EQ.

                                   {
   EXPECT_EQ(
       "running foo\n"
       "foo global-foo 43\n"
       "foo local-foo 44\n"
       "foo arg a\n"
       "foo arg b\n",
       callHelper({"--global-foo", "43", "bar", "--local-foo", "44", "a", "b"}));
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GNUStyleBoolFlagsNegation
	)

Definition at line 139 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GNU.

                                                     {
   EXPECT_EQ(
       "flag-bool-true 0\n"
       "flag-bool-false 0\n"
       "flag-int 42\n"
       "flag-string foo\n",
       callHelper(
           ProgramOptionsStyle::GNU,
           {
               "--no-flag-bool-true",
               "--no-flag-bool-false",
           }));
 }

folly::test::TEST	(	TupleOps	,
		TupleTo
	)

Definition at line 143 of file TupleOpsTest.cpp.

References CHECK_TUPLE_TO.

                         {
   CHECK_TUPLE_TO(tupleTo);
 }

folly::test::TEST	(	ProgramOptionsTest	,
		BuiltinCommand
	)

Definition at line 147 of file NestedCommandLineAppTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, folly::NestedCommandLineApp::isBuiltinCommand(), folly::NestedCommandLineApp::kHelpCommand, folly::NestedCommandLineApp::kVersionCommand, and folly::Range< Iter >::str().

                                          {
   NestedCommandLineApp app;
   ASSERT_TRUE(app.isBuiltinCommand(NestedCommandLineApp::kHelpCommand.str()));
   ASSERT_TRUE(
       app.isBuiltinCommand(NestedCommandLineApp::kVersionCommand.str()));
   ASSERT_FALSE(app.isBuiltinCommand(
       NestedCommandLineApp::kHelpCommand.str() + "nonsense"));
 }

folly::test::TEST	(	TupleOps	,
		TupleTo2
	)

Definition at line 147 of file TupleOpsTest.cpp.

References CHECK_TUPLE_TO, and tupleTo2().

                          {
   CHECK_TUPLE_TO(tupleTo2);
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GNUStyleSubCommand
	)

Definition at line 153 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GNU.

                                              {
   EXPECT_EQ(
       "flag-bool-true 1\n"
       "flag-bool-false 1\n"
       "flag-int 43\n"
       "flag-string foo\n"
       "command hello\n"
       "arg --wtf\n"
       "arg 100\n"
       "arg -x\n"
       "arg -xy\n",
       callHelper(
           ProgramOptionsStyle::GNU,
           {
               "--flag-bool-false",
               "hello",
               "--wtf",
               "--flag-int",
               "43",
               "100",
               "-x",
               "-xy",
           }));
 }

folly::test::TEST	(	RecordIOTest	,
		ExtraMagic
	)

Definition at line 163 of file RecordIOTest.cpp.

References ASSERT_FALSE, folly::RecordIOReader::begin(), folly::RecordIOReader::end(), EXPECT_EQ, EXPECT_TRUE, folly::test::TemporaryFile::fd(), folly::gen::first, folly::recordio_helpers::headerSize(), folly::recordio_helpers::recordio_detail::Header::kMagic, fizz::detail::read(), uint32_t, uint8_t, val, folly::RecordIOWriter::write(), and fizz::detail::write().

                                {
   TemporaryFile file;
   {
     RecordIOWriter writer(File(file.fd()));
     writer.write(iobufs({"hello"}));
   }
   uint8_t buf[recordio_helpers::headerSize() + 5];
   EXPECT_EQ(0, lseek(file.fd(), 0, SEEK_SET));
   EXPECT_EQ(sizeof(buf), read(file.fd(), buf, sizeof(buf)));
   // Append an extra magic
   const uint32_t magic = recordio_helpers::recordio_detail::Header::kMagic;
   EXPECT_EQ(sizeof(magic), write(file.fd(), &magic, sizeof(magic)));
   // and an extra record
   EXPECT_EQ(sizeof(buf), write(file.fd(), buf, sizeof(buf)));
   {
     RecordIOReader reader(File(file.fd()));
     auto it = reader.begin();
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("hello", sp((it++)->first));
     ASSERT_FALSE(it == reader.end());
     EXPECT_EQ("hello", sp((it++)->first));
     EXPECT_TRUE(it == reader.end());
   }
 }

folly::test::TEST	(	ShutdownSocketSetTest	,
		OrderlyClose
	)

Definition at line 167 of file ShutdownSocketSetTest.cpp.

References runCloseTest().

                                           {
   runCloseTest(false);
 }

folly::test::TEST	(	ShutdownSocketSetTest	,
		AbortiveClose
	)

Definition at line 171 of file ShutdownSocketSetTest.cpp.

References runCloseTest().

                                            {
   runCloseTest(true);
 }

folly::test::TEST	(	ProgramOptionsTest	,
		GNUStyleSubCommandUnrecognizedOptionFirst
	)

Definition at line 178 of file ProgramOptionsTest.cpp.

References EXPECT_EQ, and folly::GNU.

                                                                     {
   EXPECT_EQ(
       "flag-bool-true 1\n"
       "flag-bool-false 1\n"
       "flag-int 43\n"
       "flag-string foo\n"
       "arg --wtf\n"
       "arg hello\n"
       "arg 100\n"
       "arg -x\n"
       "arg -xy\n",
       callHelper(
           ProgramOptionsStyle::GNU,
           {
               "--flag-bool-false",
               "--wtf",
               "hello",
               "--flag-int",
               "43",
               "100",
               "-x",
               "-xy",
           }));
 }

folly::test::TEST	(	RecordIOTest	,
		Randomized
	)

Definition at line 197 of file RecordIOTest.cpp.

References ASSERT_LT, folly::basic_fbstring< E, T, A, Storage >::clear(), EXPECT_EQ, folly::test::TemporaryFile::fd(), folly::RecordIOWriter::filePos(), folly::gen::first, folly::recordio_helpers::headerSize(), i, k, folly::gen::move, folly::basic_fbstring< E, T, A, Storage >::push_back(), records, folly::basic_fbstring< E, T, A, Storage >::reserve(), SCOPED_TRACE, folly::basic_fbstring< E, T, A, Storage >::size(), and folly::RecordIOWriter::write().

                                {
   SCOPED_TRACE(to<std::string>("Random seed is ", FLAGS_random_seed));
   std::mt19937 rnd(FLAGS_random_seed);
 
   size_t recordCount = std::uniform_int_distribution<uint32_t>(30, 300)(rnd);
 
   std::uniform_int_distribution<uint32_t> recordSizeDist(1, 3 << 16);
   std::uniform_int_distribution<uint32_t> charDist(0, 255);
   std::uniform_int_distribution<uint32_t> junkDist(0, 1 << 20);
   // corrupt 1/5 of all records
   std::uniform_int_distribution<uint32_t> corruptDist(0, 4);
 
   std::vector<std::pair<fbstring, off_t>> records;
   std::vector<off_t> corruptPositions;
   records.reserve(recordCount);
   TemporaryFile file;
 
   fbstring record;
   // Recreate the writer multiple times so we test that we create a
   // continuous stream
   for (size_t i = 0; i < 3; ++i) {
     RecordIOWriter writer(File(file.fd()));
     for (size_t j = 0; j < recordCount; ++j) {
       off_t beginPos = writer.filePos();
       record.clear();
       size_t recordSize = recordSizeDist(rnd);
       record.reserve(recordSize);
       for (size_t k = 0; k < recordSize; ++k) {
         record.push_back(charDist(rnd));
       }
       writer.write(iobufs({record}));
 
       bool corrupt = (corruptDist(rnd) == 0);
       if (corrupt) {
         // Corrupt one random byte in the record (including header)
         std::uniform_int_distribution<uint32_t> corruptByteDist(
             0, recordSize + recordio_helpers::headerSize() - 1);
         off_t corruptRel = corruptByteDist(rnd);
         VLOG(1) << "n=" << records.size() << " bpos=" << beginPos
                 << " rsize=" << record.size() << " corrupt rel=" << corruptRel
                 << " abs=" << beginPos + corruptRel;
         corruptPositions.push_back(beginPos + corruptRel);
       } else {
         VLOG(2) << "n=" << records.size() << " bpos=" << beginPos
                 << " rsize=" << record.size() << " good";
         records.emplace_back(std::move(record), beginPos);
       }
     }
     VLOG(1) << "n=" << records.size() << " close abs=" << writer.filePos();
   }
 
   for (auto& pos : corruptPositions) {
     corrupt(file.fd(), pos);
   }
 
   {
     size_t i = 0;
     RecordIOReader reader(File(file.fd()));
     for (auto& r : reader) {
       SCOPED_TRACE(i);
       ASSERT_LT(i, records.size());
       EXPECT_EQ(records[i].first, sp(r.first));
       EXPECT_EQ(records[i].second, r.second);
       ++i;
     }
     EXPECT_EQ(records.size(), i);
   }
 }

folly::test::TEST	(	ShutdownSocketSetTest	,
		OrderlyKill
	)

Definition at line 209 of file ShutdownSocketSetTest.cpp.

References runKillTest().

                                          {
   runKillTest(false);
 }

folly::test::TEST	(	ShutdownSocketSetTest	,
		AbortiveKill
	)

Definition at line 213 of file ShutdownSocketSetTest.cpp.

References runKillTest().

                                           {
   runKillTest(true);
 }

folly::test::TEST	(	FileUtilTest2	,
		wrapv
	)

Definition at line 248 of file FileUtilTest.cpp.

References ASSERT_EQ, EXPECT_EQ, folly::test::TemporaryFile::fd(), i, int32_t, folly::test::IovecBuffers::iov(), folly::test::IovecBuffers::size(), sizes, sum(), and folly::fileutil_detail::wrapvFull().

                            {
   TemporaryFile tempFile("file-util-test");
   std::vector<size_t> sizes;
   size_t sum = 0;
   for (int32_t i = 0; i < 1500; ++i) {
     sizes.push_back(i % 3 + 1);
     sum += sizes.back();
   }
   IovecBuffers buf(sizes);
   ASSERT_EQ(sum, buf.size());
   auto iov = buf.iov();
   EXPECT_EQ(sum, wrapvFull(writev, tempFile.fd(), iov.data(), iov.size()));
 }

folly::test::TEST	(	String	,
		readFile
	)

Definition at line 276 of file FileUtilTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::test::TemporaryFile::path(), folly::readFile(), and folly::writeFile().

                        {
   const TemporaryFile afileTemp, emptyFileTemp;
   auto afile = afileTemp.path().string();
   auto emptyFile = emptyFileTemp.path().string();
 
   EXPECT_TRUE(writeFile(string(), emptyFile.c_str()));
   EXPECT_TRUE(writeFile(StringPiece("bar"), afile.c_str()));
 
   {
     string contents;
     EXPECT_TRUE(readFile(emptyFile.c_str(), contents));
     EXPECT_EQ(contents, "");
     EXPECT_TRUE(readFile(afile.c_str(), contents, 0));
     EXPECT_EQ("", contents);
     EXPECT_TRUE(readFile(afile.c_str(), contents, 2));
     EXPECT_EQ("ba", contents);
     EXPECT_TRUE(readFile(afile.c_str(), contents));
     EXPECT_EQ("bar", contents);
   }
   {
     vector<unsigned char> contents;
     EXPECT_TRUE(readFile(emptyFile.c_str(), contents));
     EXPECT_EQ(vector<unsigned char>(), contents);
     EXPECT_TRUE(readFile(afile.c_str(), contents, 0));
     EXPECT_EQ(vector<unsigned char>(), contents);
     EXPECT_TRUE(readFile(afile.c_str(), contents, 2));
     EXPECT_EQ(vector<unsigned char>({'b', 'a'}), contents);
     EXPECT_TRUE(readFile(afile.c_str(), contents));
     EXPECT_EQ(vector<unsigned char>({'b', 'a', 'r'}), contents);
   }
 }

folly::test::TEST_F	(	FileUtilTest	,
		read
	)

Definition at line 163 of file FileUtilTest.cpp.

References EXPECT_EQ, folly::test::FileUtilTest::in_, folly::test::FileUtilTest::readers_, string, and folly::fileutil_detail::wrapFull().

Referenced by TEST_F(), and fizz::test::TEST_F().

                            {
   for (auto& p : readers_) {
     std::string out(in_.size(), '\0');
     EXPECT_EQ(p.first, wrapFull(p.second, 0, &out[0], out.size()));
     if (p.first != (decltype(p.first))(-1)) {
       EXPECT_EQ(in_.substr(0, p.first), out.substr(0, p.first));
     }
   }
 }

folly::test::TEST_F	(	FileUtilTest	,
		pread
	)

Definition at line 173 of file FileUtilTest.cpp.

References EXPECT_EQ, folly::test::FileUtilTest::in_, folly::test::FileUtilTest::readers_, string, and folly::fileutil_detail::wrapFull().

                             {
   for (auto& p : readers_) {
     std::string out(in_.size(), '\0');
     EXPECT_EQ(p.first, wrapFull(p.second, 0, &out[0], out.size(), off_t(42)));
     if (p.first != (decltype(p.first))(-1)) {
       EXPECT_EQ(in_.substr(0, p.first), out.substr(0, p.first));
     }
   }
 }

folly::test::TEST_F	(	FileUtilTest	,
		readv
	)

Definition at line 235 of file FileUtilTest.cpp.

References ASSERT_EQ, EXPECT_EQ, folly::test::FileUtilTest::in_, folly::test::FileUtilTest::readers_, and folly::fileutil_detail::wrapvFull().

                             {
   for (auto& p : readers_) {
     IovecBuffers buf({12, 19, 31});
     ASSERT_EQ(62, buf.size());
 
     auto iov = buf.iov();
     EXPECT_EQ(p.first, wrapvFull(p.second, 0, iov.data(), iov.size()));
     if (p.first != (decltype(p.first))(-1)) {
       EXPECT_EQ(in_.substr(0, p.first), buf.join().substr(0, p.first));
     }
   }
 }

folly::test::TEST_F	(	FileUtilTest	,
		preadv
	)

Definition at line 262 of file FileUtilTest.cpp.

References ASSERT_EQ, EXPECT_EQ, folly::test::FileUtilTest::in_, folly::test::FileUtilTest::readers_, and folly::fileutil_detail::wrapvFull().

                              {
   for (auto& p : readers_) {
     IovecBuffers buf({12, 19, 31});
     ASSERT_EQ(62, buf.size());
 
     auto iov = buf.iov();
     EXPECT_EQ(
         p.first, wrapvFull(p.second, 0, iov.data(), iov.size(), off_t(42)));
     if (p.first != (decltype(p.first))(-1)) {
       EXPECT_EQ(in_.substr(0, p.first), buf.join().substr(0, p.first));
     }
   }
 }

folly::test::TEST_F	(	ReadFileFd	,
		ReadZeroBytes
	)

Definition at line 317 of file FileUtilTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::readFile(), and string.

                                   {
   std::string contents;
   EXPECT_TRUE(readFile(aFile.fd(), contents, 0));
   EXPECT_EQ("", contents);
 }

folly::test::TEST_F	(	ReadFileFd	,
		ReadPartial
	)

Definition at line 323 of file FileUtilTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::readFile(), and string.

                                 {
   std::string contents;
   EXPECT_TRUE(readFile(aFile.fd(), contents, 2));
   EXPECT_EQ("ba", contents);
 }

folly::test::TEST_F	(	ReadFileFd	,
		ReadFull
	)

Definition at line 329 of file FileUtilTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::readFile(), and string.

                              {
   std::string contents;
   EXPECT_TRUE(readFile(aFile.fd(), contents));
   EXPECT_EQ("bar", contents);
 }

folly::test::TEST_F	(	ReadFileFd	,
		WriteOnlyFd
	)

Definition at line 335 of file FileUtilTest.cpp.

References EXPECT_FALSE, f, folly::INFO, folly::readFile(), and string.

                                 {
   File f(aFile.path().string(), O_WRONLY);
   std::string contents;
   EXPECT_FALSE(readFile(f.fd(), contents));
   PLOG(INFO);
 }

folly::test::TEST_F	(	ReadFileFd	,
		InvalidFd
	)

Definition at line 342 of file FileUtilTest.cpp.

References EXPECT_FALSE, f, folly::INFO, msvcSuppressAbortOnInvalidParams(), folly::readFile(), and string.

                               {
   File f(aFile.path().string());
   f.close();
   std::string contents;
   msvcSuppressAbortOnInvalidParams(
       [&] { EXPECT_FALSE(readFile(f.fd(), contents)); });
   PLOG(INFO);
 }

folly::test::TEST_F	(	WriteFileAtomic	,
		writeNew
	)

Definition at line 394 of file FileUtilTest.cpp.

References EXPECT_EQ, and folly::writeFileAtomic().

                                   {
   // Call writeFileAtomic() to create a new file
   auto path = tmpPath("foo");
   auto contents = StringPiece{"contents\n"};
   writeFileAtomic(path, contents);
 
   // The directory should contain exactly 1 file now, with the correct contents
   EXPECT_EQ(set<string>{"foo"}, listTmpDir());
   EXPECT_EQ(contents, readData(path));
   EXPECT_EQ(0644, getPerms(path));
 }

folly::test::TEST_F	(	WriteFileAtomic	,
		overwrite
	)

Definition at line 406 of file FileUtilTest.cpp.

References EXPECT_EQ, string, and folly::writeFileAtomic().

                                    {
   // Call writeFileAtomic() to create a new file
   auto path = tmpPath("foo");
   auto contents1 = StringPiece{"contents\n"};
   writeFileAtomic(path, contents1);
 
   EXPECT_EQ(set<string>{"foo"}, listTmpDir());
   EXPECT_EQ(contents1, readData(path));
   EXPECT_EQ(0644, getPerms(path));
 
   // Now overwrite the file with different contents
   auto contents2 = StringPiece{"testing"};
   writeFileAtomic(path, contents2);
   EXPECT_EQ(set<string>{"foo"}, listTmpDir());
   EXPECT_EQ(contents2, readData(path));
   EXPECT_EQ(0644, getPerms(path));
 
   // Test overwriting with relatively large contents, and different permissions
   auto contents3 =
       "asdf" + string(10240, '\n') + "foobar\n" + string(10240, 'b') + "\n";
   writeFileAtomic(path, contents3, 0444);
   EXPECT_EQ(set<string>{"foo"}, listTmpDir());
   EXPECT_EQ(contents3, readData(path));
   EXPECT_EQ(0444, getPerms(path));
 
   // Test overwriting with empty contents
   //
   // Note that the file's permissions are 0444 at this point (read-only),
   // but we writeFileAtomic() should still replace it successfully.  Since we
   // update it with a rename we need write permissions on the parent directory,
   // but not the destination file.
   auto contents4 = StringPiece("");
   writeFileAtomic(path, contents4, 0400);
   EXPECT_EQ(set<string>{"foo"}, listTmpDir());
   EXPECT_EQ(contents4, readData(path));
   EXPECT_EQ(0400, getPerms(path));
 }

folly::test::TEST_F	(	WriteFileAtomic	,
		directoryPermissions
	)

Definition at line 444 of file FileUtilTest.cpp.

References EXPECT_EQ, EXPECT_THROW, SCOPE_EXIT, and folly::writeFileAtomic().

                                               {
   // Test writeFileAtomic() when we do not have write permission in the target
   // directory.
   //
   // Make the test directory read-only
   setDirPerms(0555);
   SCOPE_EXIT {
     // Restore directory permissions before we exit, just to ensure the code
     // will be able to clean up the directory.
     try {
       setDirPerms(0755);
     } catch (const std::exception&) {
       // Intentionally ignore errors here, in case an exception is already
       // being thrown.
     }
   };
 
   // writeFileAtomic() should fail, and the directory should still be empty
   auto path1 = tmpPath("foo");
   auto contents = StringPiece("testing");
   EXPECT_THROW(writeFileAtomic(path1, contents), std::system_error);
   EXPECT_EQ(set<string>{}, listTmpDir());
 
   // Make the directory writable again, then create the file
   setDirPerms(0755);
   writeFileAtomic(path1, contents, 0400);
   EXPECT_EQ(contents, readData(path1));
   EXPECT_EQ(set<string>{"foo"}, listTmpDir());
 
   // Make the directory read-only again
   // Creating another file now should fail and we should still have only the
   // first file.
   setDirPerms(0555);
   EXPECT_THROW(
       writeFileAtomic(tmpPath("another_file.txt"), "x\n"), std::system_error);
   EXPECT_EQ(set<string>{"foo"}, listTmpDir());
 }

folly::test::TEST_F	(	WriteFileAtomic	,
		multipleFiles
	)

Definition at line 482 of file FileUtilTest.cpp.

References EXPECT_EQ, EXPECT_THROW, fail(), mode, TEST_F(), and folly::writeFileAtomic().

                                        {
   // Test creating multiple files in the same directory
   writeFileAtomic(tmpPath("foo.txt"), "foo");
   writeFileAtomic(tmpPath("bar.txt"), "bar", 0400);
   writeFileAtomic(tmpPath("foo_txt"), "underscore", 0440);
   writeFileAtomic(tmpPath("foo.txt2"), "foo2", 0444);
 
   auto expectedPaths = set<string>{"foo.txt", "bar.txt", "foo_txt", "foo.txt2"};
   EXPECT_EQ(expectedPaths, listTmpDir());
   EXPECT_EQ("foo", readData(tmpPath("foo.txt")));
   EXPECT_EQ("bar", readData(tmpPath("bar.txt")));
   EXPECT_EQ("underscore", readData(tmpPath("foo_txt")));
   EXPECT_EQ("foo2", readData(tmpPath("foo.txt2")));
   EXPECT_EQ(0644, getPerms(tmpPath("foo.txt")));
   EXPECT_EQ(0400, getPerms(tmpPath("bar.txt")));
   EXPECT_EQ(0440, getPerms(tmpPath("foo_txt")));
   EXPECT_EQ(0444, getPerms(tmpPath("foo.txt2")));
 }

void folly::test::testVarint	(	uint64_t	val,
		std::initializer_list< uint8_t >	bytes
	)

Definition at line 35 of file VarintTest.cpp.

References folly::decodeVarint(), folly::Range< Iter >::empty(), folly::encodeVarint(), folly::encodeVarintSize(), EXPECT_EQ, EXPECT_TRUE, folly::kMaxVarintLength64, folly::Range< Iter >::size(), uint64_t, and uint8_t.

Referenced by TEST().

                                                                   {
   size_t n = bytes.size();
   ByteRange expected(&*bytes.begin(), n);
 
   {
     uint8_t buf[kMaxVarintLength64];
     EXPECT_EQ(expected.size(), encodeVarint(val, buf));
     EXPECT_TRUE(ByteRange(buf, expected.size()) == expected);
     EXPECT_EQ(expected.size(), encodeVarintSize(val));
   }
 
   {
     ByteRange r = expected;
     uint64_t decoded = decodeVarint(r);
     EXPECT_TRUE(r.empty());
     EXPECT_EQ(val, decoded);
   }
 
   if (n < kMaxVarintLength64) {
     // Try from a full buffer too, different code path
     uint8_t buf[kMaxVarintLength64];
     memcpy(buf, &*bytes.begin(), n);
 
     uint8_t fills[] = {0, 0x7f, 0x80, 0xff};
 
     for (uint8_t fill : fills) {
       memset(buf + n, fill, kMaxVarintLength64 - n);
       ByteRange r(buf, kMaxVarintLength64);
       uint64_t decoded = decodeVarint(r);
       EXPECT_EQ(val, decoded);
       EXPECT_EQ(kMaxVarintLength64 - n, r.size());
     }
   }
 }

void folly::test::testVarintFail ( std::initializer_list< uint8_t > bytes )

Definition at line 103 of file VarintTest.cpp.

References folly::data(), EXPECT_FALSE, and folly::tryDecodeVarint().

Referenced by TEST().

                                                         {
   size_t n = bytes.size();
   ByteRange data(&*bytes.begin(), n);
   auto ret = tryDecodeVarint(data);
   EXPECT_FALSE(ret.hasValue());
 }

template<class U , class T >

U folly::test::tupleTo ( const T & input )

Definition at line 105 of file TupleOpsTest.cpp.

Referenced by TEST().

                           {
   return TupleTo<U, T>::convert(input);
 }

template<class U , class T , class Seq = typename TemplateTupleRange<U>::type, class Enable = typename std::enable_if< (std::tuple_size<U>::value == std::tuple_size<T>::value)>::type>

U folly::test::tupleTo2 ( const T & input )

Definition at line 130 of file TupleOpsTest.cpp.

Referenced by TEST().

                            {
   return TupleTo2<Seq>::template convert<U>(input);
 }

Variable Documentation

std::mutex folly::test::futexLock

static

Definition at line 45 of file DeterministicSchedule.cpp.

std::unordered_map< const detail::Futex<DeterministicAtomic>*, std::list<std::pair<uint32_t, bool*> > > folly::test::futexQueues

static

Definition at line 43 of file DeterministicSchedule.cpp.

Referenced by futexWaitImpl(), and futexWakeImpl().

ShutdownSocketSet folly::test::shutdownSocketSet

Definition at line 34 of file ShutdownSocketSetTest.cpp.

Referenced by folly::AsyncServerSocket::bind(), folly::AsyncSocket::connect(), folly::AsyncSocket::doClose(), folly::AsyncSocket::setShutdownSocketSet(), folly::AsyncServerSocket::setShutdownSocketSet(), folly::AsyncServerSocket::setupSocket(), and folly::AsyncServerSocket::stopAccepting().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation