bsltf.h

Go to the documentation of this file.

/// @file bsltf.h
///
///
/// @defgroup bsltf Package bsltf
/// @brief  Basic Standard Library Test Facility (bsltf)
/// @addtogroup bsl
/// @{
/// @addtogroup bsltf
/// @{
/// * <a href="#bsltf-purpose"> Purpose</a>
/// * <a href="#bsltf-mnemonic"> Mnemonic </a>
/// * <a href="#bsltf-description"> Description </a>
///   * <a href="#bsltf-hierarchical-synopsis"> Hierarchical Synopsis </a>
///   * <a href="#bsltf-component-synopsis"> Component Synopsis </a>
///
/// # Purpose {#bsltf-purpose}
/// Provide a set of utilities and types to help with testing.
///
/// # Mnemonic {#bsltf-mnemonic}
/// Basic Standard Library Test Facility (bsltf)
///
/// # Description {#bsltf-description}
/// This package mainly provides a set test types and utilities that
/// operates on those types, which can help simplify, particularly for templates,
/// the implementation of test drivers.
///
/// See @ref bsltf_templatetestfacility-description  for an overview of the
/// facilities in this package and examples of their use.
///
/// ## Hierarchical Synopsis {#bsltf-hierarchical-synopsis}
///
/// The 'bsltf' package currently has 38 components having 7 levels of physical
/// dependency.  The list below shows the hierarchical ordering of the components.
/// The order of components within each level is not architecturally significant,
/// just alphabetical.
/// @code
///  7. bsltf_stdstatefulallocator
///     bsltf_streamutil
///     bsltf_testvaluesarray
///
///  6. bsltf_templatetestfacility
///
///  5. bsltf_allocemplacabletesttype
///     bsltf_emplacabletesttype
///
///  4. bsltf_allocargumenttype
///     bsltf_argumenttype
///     bsltf_movablealloctesttype
///     bsltf_movabletesttype
///     bsltf_moveonlyalloctesttype
///     bsltf_wellbehavedmoveonlyalloctesttype
///
///  3. bsltf_copymovetracker
///     bsltf_movestate
///
///  2. bsltf_allocbitwisemoveabletesttype
///     bsltf_alloctesttype
///     bsltf_bitwisecopyabletesttype
///     bsltf_bitwisemoveabletesttype
///     bsltf_convertiblevaluewrapper
///     bsltf_copymovestate
///     bsltf_degeneratefunctor
///     bsltf_enumeratedtesttype
///     bsltf_evilbooleantype
///     bsltf_inputiterator
///     bsltf_nonassignabletesttype
///     bsltf_noncopyconstructibletesttype
///     bsltf_nondefaultconstructibletesttype
///     bsltf_nonequalcomparabletesttype
///     bsltf_nonoptionalalloctesttype
///     bsltf_nontypicaloverloadstesttype
///     bsltf_simpletesttype
///     bsltf_stdallocatoradaptor
///     bsltf_stdalloctesttype
///     bsltf_stdtestallocator
///     bsltf_uniontesttype
///
///  1. bsltf_stdallocatoradaptor_cpp03                                  !PRIVATE!
///     bsltf_stdstatefulallocator_cpp03                                 !PRIVATE!
///     bsltf_stdtestallocator_cpp03                                     !PRIVATE!
/// @endcode
///
/// ## Component Synopsis {#bsltf-component-synopsis}
///
///  @ref bsltf_allocargumenttype :
///       Provide an allocating test class to represent function arguments.
/// 
///  @ref bsltf_allocbitwisemoveabletesttype :
///       Provide a class that allocates memory and is bitwise-moveable.
/// 
///  @ref bsltf_allocemplacabletesttype :
///       Provide an allocating test class used to test `emplace` methods.
/// 
///  @ref bsltf_alloctesttype :
///       Provide a class for testing that allocates with `bsl::allocator`.
/// 
///  @ref bsltf_argumenttype :
///       Provide a non-allocating class to test variadic function arguments.
/// 
///  @ref bsltf_bitwisecopyabletesttype :
///       Provide a bitwise-copyable test class.
/// 
///  @ref bsltf_bitwisemoveabletesttype :
///       Provide a bitwise-moveable test class.
/// 
///  @ref bsltf_convertiblevaluewrapper :
///       Provide a wrapper class, convertible to a supplied value.
/// 
///  @ref bsltf_copymovestate :
///       Provide an enumeration of copy/move state, including unsupported.
/// 
///  @ref bsltf_copymovetracker :
///       Provide a type that tracks if it's been copied or moved
/// 
///  @ref bsltf_degeneratefunctor :
///       Provide an awkward type to adapt a user-supplied functor.
/// 
///  @ref bsltf_emplacabletesttype :
///       Provide a non-allocating test class used to test `emplace` methods.
/// 
///  @ref bsltf_enumeratedtesttype :
///       Provide an enumerated test type.
/// 
///  @ref bsltf_evilbooleantype :
///       Provide the most awkward type that is convertible to `bool`.
/// 
///  @ref bsltf_inputiterator :
///       Provide a pure input iterator capable of traversing a range.
/// 
///  @ref bsltf_movablealloctesttype :
///       Provide an allocating test class that records when moved from.
/// 
///  @ref bsltf_movabletesttype :
///       Provide a non-allocating test class that records when moved from.
/// 
///  @ref bsltf_moveonlyalloctesttype :
///       Provide testing type that is move-only & uses `bslma` allocators.
/// 
///  @ref bsltf_movestate :
///       Provide an enumeration of move-state, including unsupported.
/// 
///  @ref bsltf_nonassignabletesttype :
///       Provide an attribute class to which can not be assigned.
/// 
///  @ref bsltf_noncopyconstructibletesttype :
///       Provide an attribute class that is not copy constructible.
/// 
///  @ref bsltf_nondefaultconstructibletesttype :
///       Provide an attribute class that is not default constructible.
/// 
///  @ref bsltf_nonequalcomparabletesttype :
///       Provide an attribute class that is not equal comparable.
/// 
///  @ref bsltf_nonoptionalalloctesttype :
///       Provide a class for testing that allocates with `bslma::Allocator`.
/// 
///  @ref bsltf_nontypicaloverloadstesttype :
///       Provide a class that overloads the non-typical operators.
/// 
///  @ref bsltf_simpletesttype :
///       Provide a non-allocating test class without type traits.
/// 
///  @ref bsltf_stdallocatoradaptor :
///       Provide a mechanism to propagate standard allocator state.
/// 
///  @ref bsltf_stdallocatoradaptor_cpp03 :                                  !PRIVATE!
///       Provide C++03 implementation for bsltf_stdallocatoradaptor.h
/// 
///  @ref bsltf_stdalloctesttype :
///       Provide a class for testing that allocates with standard allocator
/// 
///  @ref bsltf_stdstatefulallocator :
///       Provide a minimal standard compliant allocator.
/// 
///  @ref bsltf_stdstatefulallocator_cpp03 :                                 !PRIVATE!
///       Provide C++03 implementation for bsltf_stdstatefulallocator.h
/// 
///  @ref bsltf_stdtestallocator :
///       Provide a minimal standard compliant allocator.
/// 
///  @ref bsltf_stdtestallocator_cpp03 :                                     !PRIVATE!
///       Provide C++03 implementation for bsltf_stdtestallocator.h
/// 
///  @ref bsltf_streamutil :
///       Provide streaming output operators for bsltf-defined types.
/// 
///  @ref bsltf_templatetestfacility :
///       Provide utilities to help with testing templates.
/// 
///  @ref bsltf_testvaluesarray :
///       Provide a container for values used for testing.
/// 
///  @ref bsltf_uniontesttype :
///       Provide an union test type.
/// 
///  @ref bsltf_wellbehavedmoveonlyalloctesttype :
///       Provide well-behaved move-only type using `bslma` allocators.
///
/// @}
/** @} */