folly::test::detail Namespace Reference

Classes
class	CheckResult
struct	SavedState

Typedefs
typedef boost::random::mt19937	RandomT

Functions
SavedState	disableInvalidParameters ()
void	enableInvalidParameters (SavedState)
bool	hasPCREPatternMatch (StringPiece pattern, StringPiece target)
bool	hasNoPCREPatternMatch (StringPiece pattern, StringPiece target)
static RandomT	rng (seed)
template<class Integral1 , class Integral2 >
Integral2	random (Integral1 low, Integral2 up)
template<class String >
void	randomString (String *toFill, unsigned int maxSize=1000)
template<class String , class Integral >
void	Num2String (String &str, Integral)
std::list< char >	RandomList (unsigned int maxSize)
template<class T >
T	randomObject ()
template<>
int	randomObject< int > ()
template<>
std::string	randomObject< std::string > ()
template<>
folly::fbstring	randomObject< folly::fbstring > ()
template<typename Fn >
CheckResult	checkThrowErrno (Fn &&fn, int errnoValue, const char *statementStr)
template<typename ExType , typename Fn >
CheckResult	checkThrowRegex (Fn &&fn, const char *pattern, const char *statementStr, const char *excTypeStr)

Variables
static auto const	seed = randomNumberSeed()

Typedef Documentation

typedef boost::random::mt19937 folly::test::detail::RandomT

Definition at line 32 of file FBVectorTestUtil.h.

Function Documentation

template<typename Fn >

CheckResult folly::test::detail::checkThrowErrno	(	Fn &&	fn,
		int	errnoValue,
		const char *	statementStr
	)

Helper function for implementing EXPECT_THROW

Definition at line 181 of file TestUtils.h.

References folly::test::detail::CheckResult::CheckResult(), errnoValue, and folly::exceptionStr().

                                                                               {
  try {
    fn();
  } catch (const std::system_error& ex) {
    // TODO: POSIX errno values should use std::generic_category(), but
    // folly/Exception.h incorrectly throws them using std::system_category()
    // at the moment.
    // For now we also accept std::system_category so that we will also handle
    // exceptions from folly/Exception.h correctly.
    if (ex.code().category() != std::generic_category() &&
        ex.code().category() != std::system_category()) {
      return CheckResult(false)
          << "Expected: " << statementStr << " throws an exception with errno "
          << errnoValue << " (" << std::generic_category().message(errnoValue)
          << ")\nActual: it throws a system_error with category "
          << ex.code().category().name() << ": " << ex.what();
    }
    if (ex.code().value() != errnoValue) {
      return CheckResult(false)
          << "Expected: " << statementStr << " throws an exception with errno "
          << errnoValue << " (" << std::generic_category().message(errnoValue)
          << ")\nActual: it throws errno " << ex.code().value() << ": "
          << ex.what();
    }
    return CheckResult(true);
  } catch (const std::exception& ex) {
    return CheckResult(false)
        << "Expected: " << statementStr << " throws an exception with errno "
        << errnoValue << " (" << std::generic_category().message(errnoValue)
        << ")\nActual: it throws a different exception: " << exceptionStr(ex);
  } catch (...) {
    return CheckResult(false)
        << "Expected: " << statementStr << " throws an exception with errno "
        << errnoValue << " (" << std::generic_category().message(errnoValue)
        << ")\nActual: it throws a non-exception type";
  }
  return CheckResult(false)
      << "Expected: " << statementStr << " throws an exception with errno "
      << errnoValue << " (" << std::generic_category().message(errnoValue)
      << ")\nActual: it throws nothing";
}

template<typename ExType , typename Fn >

CheckResult folly::test::detail::checkThrowRegex	(	Fn &&	fn,
		const char *	pattern,
		const char *	statementStr,
		const char *	excTypeStr
	)

Helper function for implementing EXPECT_THROW_RE

Definition at line 227 of file TestUtils.h.

References folly::test::detail::CheckResult::CheckResult(), folly::exceptionStr(), regex, and value.

                            {
  static_assert(
      std::is_base_of<std::exception, ExType>::value,
      "EXPECT_THROW_RE() exception type must derive from std::exception");

  try {
    fn();
  } catch (const std::exception& ex) {
    const auto* derived = dynamic_cast<const ExType*>(&ex);
    if (!derived) {
      return CheckResult(false)
          << "Expected: " << statementStr << "throws a " << excTypeStr
          << ")\nActual: it throws a different exception type: "
          << exceptionStr(ex);
    }

    std::regex re(pattern);
    if (!std::regex_search(derived->what(), re)) {
      return CheckResult(false)
          << "Expected: " << statementStr << " throws a " << excTypeStr
          << " with message matching \"" << pattern
          << "\"\nActual: message is: " << derived->what();
    }
    return CheckResult(true);
  } catch (...) {
    return CheckResult(false)
        << "Expected: " << statementStr << " throws a " << excTypeStr
        << ")\nActual: it throws a non-exception type";
  }
  return CheckResult(false) << "Expected: " << statementStr << " throws a "
                            << excTypeStr << ")\nActual: it throws nothing";
}

SavedState folly::test::detail::disableInvalidParameters

(

)

Definition at line 146 of file TestUtil.cpp.

References enableInvalidParameters(), folly::test::detail::SavedState::previousCrtReportMode, and folly::test::detail::SavedState::previousThreadLocalHandler.

Referenced by folly::test::msvcSuppressAbortOnInvalidParams().

                                      {
#ifdef _WIN32
  SavedState ret;
  ret.previousThreadLocalHandler =
      _set_thread_local_invalid_parameter_handler([](const wchar_t*,
                                                     const wchar_t*,
                                                     const wchar_t*,
                                                     unsigned int,
                                                     uintptr_t) {});
  ret.previousCrtReportMode = _CrtSetReportMode(_CRT_ASSERT, 0);
  return ret;
#else
  return SavedState();
#endif
}

void folly::test::detail::enableInvalidParameters

(

SavedState

)

Definition at line 169 of file TestUtil.cpp.

Referenced by disableInvalidParameters(), and folly::test::msvcSuppressAbortOnInvalidParams().

{}

bool folly::test::detail::hasNoPCREPatternMatch	(	StringPiece	pattern,
		StringPiece	target
	)

Definition at line 179 of file TestUtil.cpp.

References hasPCREPatternMatch().

                                                                    {
  return !hasPCREPatternMatch(pattern, target);
}

bool folly::test::detail::hasPCREPatternMatch	(	StringPiece	pattern,
		StringPiece	target
	)

Definition at line 172 of file TestUtil.cpp.

References folly::Range< Iter >::begin(), folly::Range< Iter >::end(), and regex.

Referenced by hasNoPCREPatternMatch().

                                                                  {
  return boost::regex_match(
      target.begin(),
      target.end(),
      boost::regex(pattern.begin(), pattern.end()));
}

template<class String , class Integral >

void folly::test::detail::Num2String	(	String &	str,
		Integral
	)

Definition at line 51 of file FBVectorTestUtil.h.

                                         {
  str.resize(10, '\0');
  sprintf(&str[0], "%ul", 10);
  str.resize(strlen(str.c_str()));
}

template<class Integral1 , class Integral2 >

Integral2 folly::test::detail::random	(	Integral1	low,
		Integral2	up
	)

Definition at line 36 of file FBVectorTestUtil.h.

References folly::range(), and rng().

Referenced by RandomList(), randomObject< int >(), and randomString().

                                              {
  boost::uniform_int<> range(low, up);
  return range(rng);
}

std::list<char> folly::test::detail::RandomList

(

unsigned int

maxSize

)

Definition at line 57 of file FBVectorTestUtil.h.

References i, random(), randomObject(), and folly::T.

                                               {
  std::list<char> lst(random(0u, maxSize));
  std::list<char>::iterator i = lst.begin();
  for (; i != lst.end(); ++i) {
    *i = random('a', 'z');
  }
  return lst;
}

template<class T >

T folly::test::detail::randomObject

(

)

Referenced by RandomList().

template<>

folly::fbstring folly::test::detail::randomObject< folly::fbstring >

(

)

Definition at line 82 of file FBVectorTestUtil.h.

References randomString().

                                            {
  folly::fbstring result;
  randomString(&result);
  return result;
}

template<>

int folly::test::detail::randomObject< int >

(

)

Definition at line 70 of file FBVectorTestUtil.h.

References random().

Referenced by TEST().

                        {
  return random(0, 1024);
}

template<>

std::string folly::test::detail::randomObject< std::string >

(

)

Definition at line 75 of file FBVectorTestUtil.h.

References randomString(), and string.

                                    {
  std::string result;
  randomString(&result);
  return result;
}

template<class String >

void folly::test::detail::randomString	(	String *	toFill,
		unsigned int	maxSize = 1000
	)

Definition at line 42 of file FBVectorTestUtil.h.

References c, and random().

Referenced by randomObject< folly::fbstring >(), and randomObject< std::string >().

                                                               {
  assert(toFill);
  toFill->resize(random(0, maxSize));
  for (auto& c : *toFill) {
    c = random('a', 'z');
  }
}

static RandomT folly::test::detail::rng ( seed  )

static

Referenced by random().

Variable Documentation

auto const folly::test::detail::seed = randomNumberSeed()

static

Definition at line 31 of file FBVectorTestUtil.h.