FreeRTOS port on GAP8/RISC-V
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Catch Namespace Reference

Namespaces

 Detail
 
 Generators
 
 literals
 
 Matchers
 

Data Structures

struct  CaseSensitive
 
class  NonCopyable
 
struct  SourceLineInfo
 
struct  StreamEndStop
 
struct  RegistrarForTagAliases
 
struct  ITestInvoker
 
struct  ITestCaseRegistry
 
class  StringRef
 A non-owning string class (similar to the forthcoming std::string_view) Note that, because a StringRef may be a substring of another string, it may not be null terminated. c_str() must return a null terminated string, however, and so the StringRef will internally take ownership (taking a copy), if necessary. In theory this ownership is not externally visible - but it does mean (substring) StringRefs should not be shared between threads. More...
 
struct  is_unique
 
struct  is_unique< T0, T1, Rest...>
 
struct  TypeList
 
struct  append
 
struct  append< L1< E1...>, L2< E2...> >
 
struct  append< L1< E1...>, L2< E2...>, Rest...>
 
struct  rewrap
 
struct  rewrap< Container, List< elems...> >
 
struct  rewrap< Container, List< Elems...>, Elements...>
 
struct  combine
 
struct  always_false
 
class  TestInvokerAsMethod
 
struct  NameAndTags
 
struct  AutoReg
 
struct  ResultWas
 
struct  ResultDisposition
 
struct  AssertionInfo
 
struct  IStream
 
class  ReusableStringStream
 
struct  StringMaker
 
struct  StringMaker< std::string >
 
struct  StringMaker< char const * >
 
struct  StringMaker< char * >
 
struct  StringMaker< std::wstring >
 
struct  StringMaker< wchar_t const * >
 
struct  StringMaker< wchar_t * >
 
struct  StringMaker< char[SZ]>
 
struct  StringMaker< signed char[SZ]>
 
struct  StringMaker< unsigned char[SZ]>
 
struct  StringMaker< int >
 
struct  StringMaker< long >
 
struct  StringMaker< long long >
 
struct  StringMaker< unsigned int >
 
struct  StringMaker< unsigned long >
 
struct  StringMaker< unsigned long long >
 
struct  StringMaker< bool >
 
struct  StringMaker< char >
 
struct  StringMaker< signed char >
 
struct  StringMaker< unsigned char >
 
struct  StringMaker< std::nullptr_t >
 
struct  StringMaker< float >
 
struct  StringMaker< double >
 
struct  StringMaker< T * >
 
struct  StringMaker< R C::* >
 
struct  not_this_one
 
struct  is_range
 
struct  StringMaker< R, typename std::enable_if< is_range< R >::value &&!::Catch::Detail::IsStreamInsertable< R >::value >::type >
 
struct  StringMaker< T[SZ]>
 
struct  ITransientExpression
 
class  BinaryExpr
 
class  UnaryExpr
 
class  ExprLhs
 
struct  Decomposer
 
struct  IResultCapture
 
struct  TestFailureException
 
class  LazyExpression
 
struct  AssertionReaction
 
class  AssertionHandler
 
struct  MessageInfo
 
struct  MessageStream
 
struct  MessageBuilder
 
class  ScopedMessage
 
class  Capturer
 
struct  Counts
 
struct  Totals
 
struct  SectionInfo
 
struct  SectionEndInfo
 
class  Timer
 
class  Section
 
class  BenchmarkLooper
 
struct  IRegistryHub
 
struct  IMutableRegistryHub
 
struct  IExceptionTranslator
 
struct  IExceptionTranslatorRegistry
 
class  ExceptionTranslatorRegistrar
 
struct  StringMaker< Catch::Detail::Approx >
 
struct  pluralise
 
class  MatchExpr
 
struct  IGeneratorTracker
 
class  GeneratorException
 
struct  IContext
 
struct  IMutableContext
 
struct  WarnAbout
 
struct  ShowDurations
 
struct  RunTests
 
struct  UseColour
 
struct  WaitForKeypress
 
struct  IConfig
 
struct  TestCaseInfo
 
class  TestCase
 
struct  IRunner
 

Typedefs

using IReporterFactoryPtr = std::shared_ptr< IReporterFactory >
 
using exceptionTranslateFunction ) = std::string(*)(
 
using ExceptionTranslators = std::vector< std::unique_ptr< IExceptionTranslator const >>
 
using StringMatcher = Matchers::Impl::MatcherBase< std::string >
 
using IConfigPtr = std::shared_ptr< IConfig const >
 

Enumerations

enum  Verbosity
 

Functions

unsigned int rngSeed ()
 
std::ostream & operator<< (std::ostream &os, SourceLineInfo const &info)
 
template<typename T >
T const & operator+ (T const &value, StreamEndStop)
 
bool matchTest (TestCase const &testCase, TestSpec const &testSpec, IConfig const &config)
 
std::vector< TestCasefilterTests (std::vector< TestCase > const &testCases, TestSpec const &testSpec, IConfig const &config)
 
std::vector< TestCase > const & getAllTestCasesSorted (IConfig const &config)
 
auto operator+ (StringRef const &lhs, StringRef const &rhs) -> std::string
 
auto operator+ (StringRef const &lhs, char const *rhs) -> std::string
 
auto operator+ (char const *lhs, StringRef const &rhs) -> std::string
 
auto operator+= (std::string &lhs, StringRef const &sr) -> std::string &
 
auto operator<< (std::ostream &os, StringRef const &sr) -> std::ostream &
 
auto operator""_sr (char const *rawChars, std::size_t size) noexcept-> StringRef
 
auto makeTestInvoker (void(*testAsFunction)()) noexcept-> ITestInvoker *
 
template<typename C >
auto makeTestInvoker (void(C::*testAsMethod)()) noexcept-> ITestInvoker *
 
bool isOk (ResultWas::OfType resultType)
 
bool isJustInfo (int flags)
 
ResultDisposition::Flags operator| (ResultDisposition::Flags lhs, ResultDisposition::Flags rhs)
 
bool shouldContinueOnFailure (int flags)
 
bool isFalseTest (int flags)
 
bool shouldSuppressFailure (int flags)
 
std::ostream & cout ()
 
std::ostream & cerr ()
 
std::ostream & clog ()
 
auto makeStream (StringRef const &filename) -> IStream const *
 
template<typename Range >
std::string rangeToString (Range const &range)
 
template<typename Allocator >
std::string rangeToString (std::vector< bool, Allocator > const &v)
 
void formatReconstructedExpression (std::ostream &os, std::string const &lhs, StringRef op, std::string const &rhs)
 
template<typename LhsT , typename RhsT >
auto compareEqual (LhsT const &lhs, RhsT const &rhs) -> bool
 
template<typename T >
auto compareEqual (T *const &lhs, int rhs) -> bool
 
template<typename T >
auto compareEqual (T *const &lhs, long rhs) -> bool
 
template<typename T >
auto compareEqual (int lhs, T *const &rhs) -> bool
 
template<typename T >
auto compareEqual (long lhs, T *const &rhs) -> bool
 
template<typename LhsT , typename RhsT >
auto compareNotEqual (LhsT const &lhs, RhsT &&rhs) -> bool
 
template<typename T >
auto compareNotEqual (T *const &lhs, int rhs) -> bool
 
template<typename T >
auto compareNotEqual (T *const &lhs, long rhs) -> bool
 
template<typename T >
auto compareNotEqual (int lhs, T *const &rhs) -> bool
 
template<typename T >
auto compareNotEqual (long lhs, T *const &rhs) -> bool
 
void handleExpression (ITransientExpression const &expr)
 
template<typename T >
void handleExpression (ExprLhs< T > const &expr)
 
IResultCapturegetResultCapture ()
 
void handleExceptionMatchExpr (AssertionHandler &handler, std::string const &str, StringRef const &matcherString)
 
auto getCurrentNanosecondsSinceEpoch () -> uint64_t
 
auto getEstimatedClockResolution () -> uint64_t
 
IRegistryHub const & getRegistryHub ()
 
IMutableRegistryHubgetMutableRegistryHub ()
 
void cleanUp ()
 
std::string translateActiveException ()
 
bool startsWith (std::string const &s, std::string const &prefix)
 
bool startsWith (std::string const &s, char prefix)
 
bool endsWith (std::string const &s, std::string const &suffix)
 
bool endsWith (std::string const &s, char suffix)
 
bool contains (std::string const &s, std::string const &infix)
 
void toLowerInPlace (std::string &s)
 
std::string toLower (std::string const &s)
 
std::string trim (std::string const &str)
 
bool replaceInPlace (std::string &str, std::string const &replaceThis, std::string const &withThis)
 
void handleExceptionMatchExpr (AssertionHandler &handler, StringMatcher const &matcher, StringRef const &matcherString)
 
template<typename ArgT , typename MatcherT >
auto makeMatchExpr (ArgT const &arg, MatcherT const &matcher, StringRef const &matcherString) -> MatchExpr< ArgT, MatcherT >
 
void throw_exception (std::exception const &e)
 
IMutableContextgetCurrentMutableContext ()
 
IContextgetCurrentContext ()
 
void cleanUpContext ()
 
TestCase makeTestCase (ITestInvoker *testCase, std::string const &className, NameAndTags const &nameAndTags, SourceLineInfo const &lineInfo)
 

Variables

not_this_one begin (...)
 
not_this_one end (...)
 

Typedef Documentation

using Catch::exceptionTranslateFunction = typedef std::string(*)(
using Catch::ExceptionTranslators = typedef std::vector<std::unique_ptr<IExceptionTranslator const>>
typedef std::shared_ptr< IConfig const > Catch::IConfigPtr
using Catch::IReporterFactoryPtr = typedef std::shared_ptr<IReporterFactory>
using Catch::StringMatcher = typedef Matchers::Impl::MatcherBase<std::string>

Enumeration Type Documentation

enum Catch::Verbosity
strong
Enumerator
Quiet 
Normal 
High 

Function Documentation

std::ostream& Catch::cerr ( )
void Catch::cleanUp ( )
void Catch::cleanUpContext ( )
std::ostream& Catch::clog ( )
template<typename LhsT , typename RhsT >
auto Catch::compareEqual ( LhsT const &  lhs,
RhsT const &  rhs 
) -> bool
template<typename T >
auto Catch::compareEqual ( T *const &  lhs,
int  rhs 
) -> bool
template<typename T >
auto Catch::compareEqual ( T *const &  lhs,
long  rhs 
) -> bool
template<typename T >
auto Catch::compareEqual ( int  lhs,
T *const &  rhs 
) -> bool
template<typename T >
auto Catch::compareEqual ( long  lhs,
T *const &  rhs 
) -> bool
template<typename LhsT , typename RhsT >
auto Catch::compareNotEqual ( LhsT const &  lhs,
RhsT &&  rhs 
) -> bool
template<typename T >
auto Catch::compareNotEqual ( T *const &  lhs,
int  rhs 
) -> bool
template<typename T >
auto Catch::compareNotEqual ( T *const &  lhs,
long  rhs 
) -> bool
template<typename T >
auto Catch::compareNotEqual ( int  lhs,
T *const &  rhs 
) -> bool
template<typename T >
auto Catch::compareNotEqual ( long  lhs,
T *const &  rhs 
) -> bool
bool Catch::contains ( std::string const &  s,
std::string const &  infix 
)
std::ostream& Catch::cout ( )
bool Catch::endsWith ( std::string const &  s,
std::string const &  suffix 
)
bool Catch::endsWith ( std::string const &  s,
char  suffix 
)
std::vector<TestCase> Catch::filterTests ( std::vector< TestCase > const &  testCases,
TestSpec const &  testSpec,
IConfig const &  config 
)
void Catch::formatReconstructedExpression ( std::ostream &  os,
std::string const &  lhs,
StringRef  op,
std::string const &  rhs 
)
std::vector<TestCase> const& Catch::getAllTestCasesSorted ( IConfig const &  config)
IContext& Catch::getCurrentContext ( )
inline
IMutableContext& Catch::getCurrentMutableContext ( )
inline
auto Catch::getCurrentNanosecondsSinceEpoch ( ) -> uint64_t
auto Catch::getEstimatedClockResolution ( ) -> uint64_t
IRegistryHub const& Catch::getRegistryHub ( )
IResultCapture& Catch::getResultCapture ( )
void Catch::handleExceptionMatchExpr ( AssertionHandler &  handler,
std::string const &  str,
StringRef const &  matcherString 
)
void Catch::handleExceptionMatchExpr ( AssertionHandler &  handler,
StringMatcher const &  matcher,
StringRef const &  matcherString 
)
void Catch::handleExpression ( ITransientExpression const &  expr)

Referenced by handleExpression().

template<typename T >
void Catch::handleExpression ( ExprLhs< T > const &  expr)
bool Catch::isFalseTest ( int  flags)
inline
bool Catch::isJustInfo ( int  flags)
bool Catch::isOk ( ResultWas::OfType  resultType)
template<typename ArgT , typename MatcherT >
auto Catch::makeMatchExpr ( ArgT const &  arg,
MatcherT const &  matcher,
StringRef const &  matcherString 
) -> MatchExpr<ArgT, MatcherT>
auto Catch::makeStream ( StringRef const &  filename) -> IStream const *
TestCase Catch::makeTestCase ( ITestInvoker *  testCase,
std::string const &  className,
NameAndTags const &  nameAndTags,
SourceLineInfo const &  lineInfo 
)
auto Catch::makeTestInvoker ( void(*)()  testAsFunction) -> ITestInvoker *
noexcept
template<typename C >
auto Catch::makeTestInvoker ( void(C::*)()  testAsMethod) -> ITestInvoker*
noexcept
bool Catch::matchTest ( TestCase const &  testCase,
TestSpec const &  testSpec,
IConfig const &  config 
)
auto Catch::operator""_sr ( char const *  rawChars,
std::size_t  size 
) -> StringRef
inlinenoexcept
template<typename T >
T const& Catch::operator+ ( T const &  value,
StreamEndStop   
)
auto Catch::operator+ ( StringRef const &  lhs,
StringRef const &  rhs 
) -> std::string
auto Catch::operator+ ( StringRef const &  lhs,
char const *  rhs 
) -> std::string
auto Catch::operator+ ( char const *  lhs,
StringRef const &  rhs 
) -> std::string
auto Catch::operator+= ( std::string &  lhs,
StringRef const &  sr 
) -> std::string &
std::ostream& Catch::operator<< ( std::ostream &  os,
SourceLineInfo const &  info 
)
auto Catch::operator<< ( std::ostream &  os,
StringRef const &  sr 
) -> std::ostream &
ResultDisposition::Flags Catch::operator| ( ResultDisposition::Flags  lhs,
ResultDisposition::Flags  rhs 
)
template<typename Allocator >
std::string Catch::rangeToString ( std::vector< bool, Allocator > const &  v)
bool Catch::replaceInPlace ( std::string &  str,
std::string const &  replaceThis,
std::string const &  withThis 
)
unsigned int Catch::rngSeed ( )
bool Catch::shouldContinueOnFailure ( int  flags)
bool Catch::shouldSuppressFailure ( int  flags)
bool Catch::startsWith ( std::string const &  s,
std::string const &  prefix 
)
bool Catch::startsWith ( std::string const &  s,
char  prefix 
)
std::string Catch::toLower ( std::string const &  s)
void Catch::toLowerInPlace ( std::string &  s)
std::string Catch::translateActiveException ( )
std::string Catch::trim ( std::string const &  str)

Variable Documentation

not_this_one Catch::begin(...)

Referenced by rangeToString().