proxygen: proxygen/folly/folly/test/stl_tests/StlVectorTest.cpp File Reference

#include <folly/FBVector.h>
#include <climits>
#include <cstddef>
#include <exception>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/preprocessor.hpp>
#include <folly/Conv.h>
#include <folly/Portability.h>
#include <folly/ScopeGuard.h>
#include <folly/portability/GFlags.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	D0< b >

struct	D0< true >

struct	D1< b >

struct	D1< true >

struct	D2< b >

struct	D2< true >

struct	D3< b >

struct	D3< true >

struct	D4< b >

struct	D4< true >

struct	Delete< f >

struct	TickException

struct	Ticker

struct	DataTicker< f >

class	Counter

struct	Tracker

struct	DataTracker< isRelocatable >

struct	Data< f, pad >

struct	folly::IsRelocatable< Data< f, pad > >

struct	isPropCopy< T >

struct	isPropCopy< Data< f, pad > >

struct	isPropMove< T >

struct	isPropMove< Data< f, pad > >

struct	isPropSwap< T >

struct	isPropSwap< Data< f, pad > >

struct	AllocTracker

struct	Alloc< T >

struct	is_copy_constructibleAndAssignable< T >

struct	is_move_constructibleAndAssignable< T >

struct	customAllocator< Vector >

struct	special_move_assignable< T >

struct	special_move_assignable< Data< f, pad > >

struct	PrettyType< T >

struct	PrettyType< Data< f, pad > >

struct	PrettyType< std::allocator< T > >

struct	PrettyType< Alloc< T > >

struct	allocGen< A >

struct	allocGen< Alloc< T > >

class	DataState< Vector >

class	Transformer< It, tag >

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——

Macros
#define	VECTOR_ folly::fbvector

#define	IBOOST_PP_VARIADIC_SIZE(...)

#define	IBOOST_PP_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63, size, ...) size

#define	IBOOST_PP_VARIADIC_TO_SEQ(...) BOOST_PP_TUPLE_TO_SEQ(IBOOST_PP_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__))

#define	GEN_TEST(r, name, type)

#define	GEN_TYPE_TEST(r, name, type)

#define	GEN_RUNNABLE_TEST(r, name, type) one = test_I_##name##3 < type > () \|\| one;

#define	GEN_LOOPER(r, d, arg) BOOST_PP_CAT(LOOPER_, arg)

#define	GEN_VMAKER(r, d, arg)

#define	GEN_UMAKER(r, d, arg)

#define	GEN_CLOSER(r, d, arg) BOOST_PP_CAT(CLOSER_, arg)

#define	TYPIFY(r, d, name) BOOST_PP_CAT(TYPIFY_, name)

#define	ARGIFY(r, d, name) TYPIFY(r, d, name) name

#define	MAKE_TEST(ref, name, types, restriction, argseq, ...)

#define	DECL(name, ...)

#define	STL_TEST_I(ref, name, restriction, ...)

#define	STL_TEST(ref, name, restriction, ...) STL_TEST_I(ref, name, restriction, z, ##__VA_ARGS__, ticks)

#define	TEST_TYPES (_TVIS)(_TVI)(_TV1)(_TV2)(_TV3)(_TV4)(_TV5v1)(_TV5)(_TP1)(_TP2)(_TP3)

#define	INTERFACE_TYPES

#define	SETUP hardReset();

#define	TEARDOWN

#define	TYPIFY_z std::nullptr_t

#define	LOOPER_z

#define	VMAKER_z std::nullptr_t z = nullptr;

#define	UMAKER_z

#define	CLOSER_z

#define	VERIFICATION

#define	TYPIFY_ticks int

#define	LOOPER_ticks

#define	VMAKER_ticks

#define	UMAKER_ticks

#define	CLOSER_ticks }

#define	TYPIFY_a Vector&

#define	LOOPER_a for (const auto& a_ss : VectorSizes) {

#define	VMAKER_a

#define	UMAKER_a

#define	CLOSER_a }

#define	TYPIFY_b Vector&

#define	LOOPER_b for (int b_i = -2; b_i < (int)VectorSizes.size(); ++b_i) {

#define	VMAKER_b

#define	UMAKER_b

#define	CLOSER_b }

#define	TYPIFY_n int

#define	LOOPER_n for (int n : nSizes) {

#define	VMAKER_n

#define	UMAKER_n

#define	CLOSER_n }

#define	TYPIFY_i int*

#define	LOOPER_i

#define	VMAKER_i

#define	UMAKER_i

#define	CLOSER_i

#define	TYPIFY_j int*

#define	LOOPER_j for (int j_i = 0; j_i < 12; ++j_i) {

#define	VMAKER_j

#define	UMAKER_j

#define	CLOSER_j }

#define	TYPIFY_p typename Vector::iterator

#define	LOOPER_p for (int p_i = 0; p_i < 4; ++p_i) {

#define	VMAKER_p

#define	UMAKER_p

#define	CLOSER_p }

#define	TYPIFY_q typename Vector::iterator

#define	LOOPER_q for (int q_i = p_i; q_i < 4; ++q_i) {

#define	VMAKER_q

#define	UMAKER_q

#define	CLOSER_q }

#define	TYPIFY_t typename Vector::value_type&

#define	LOOPER_t for (int t_v : tVals) {

#define	VMAKER_t

#define	UMAKER_t

#define	CLOSER_t }

#define	TYPIFY_m typename Vector::allocator_type

#define	LOOPER_m

#define	VMAKER_m

#define	UMAKER_m

#define	CLOSER_m }

Typedefs
typedef uint32_t	Flags

typedef Data	ED1

typedef Data< 0, 4080 >	ED2

typedef Data< MC_NOEXCEPT >	ED3

typedef Data< MC_NOEXCEPT\|CC_DELETE >	ED4

typedef Data< IS_RELOCATABLE >	ED5

typedef folly::fbvector< int, std::allocator< int > >	_TVIS

typedef folly::fbvector< int, Alloc< int > >	_TVI

typedef folly::fbvector< ED1, std::allocator< ED1 > >	_TV1

typedef folly::fbvector< ED2, std::allocator< ED2 > >	_TV2

typedef folly::fbvector< ED3, std::allocator< ED3 > >	_TV3

typedef folly::fbvector< ED4, std::allocator< ED4 > >	_TV4

typedef folly::fbvector< ED5, std::allocator< ED5 > >	_TV5v1

typedef folly::fbvector< ED5, Alloc< ED5 > >	_TV5

typedef Data< PROP_COPY >	EP1

typedef Data< PROP_MOVE >	EP2

typedef Data< PROP_SWAP >	EP3

typedef folly::fbvector< EP1, Alloc< EP1 > >	_TP1

typedef folly::fbvector< EP2, Alloc< EP2 > >	_TP2

typedef folly::fbvector< EP3, Alloc< EP3 > >	_TP3

typedef Data< ALL_DELETE >	DD1

typedef Data< DC_DELETE\|CC_DELETE\|MC_DELETE >	DD2

typedef Data< CA_DELETE\|MA_DELETE >	DD3

typedef Data< CC_DELETE\|MC_DELETE >	DD4

typedef Data< ALL_DELETE &~DC_DELETE >	DD5

typedef Data< CC_DELETE >	DD6

typedef Data< CA_DELETE >	DD7

typedef Data< ALL_DELETE\|PROP_MOVE >	DDSMA

typedef folly::fbvector< DDSMA, Alloc< DDSMA > >	_TSpecialMA

Enumerations
enum	FlagVals : Flags { DC_NOEXCEPT = 0x1, DC_THROW = 0x2, DC_DELETE = 0x8000, CC_NOEXCEPT = 0x4, CC_THROW = 0x8, CC_DELETE = 0x10000, MC_NOEXCEPT = 0x10, MC_THROW = 0x20, MC_DELETE = 0x20000, OC_NOEXCEPT = 0x40, OC_THROW = 0x80, CA_NOEXCEPT = 0x100, CA_THROW = 0x200, CA_DELETE = 0x40000, MA_NOEXCEPT = 0x400, MA_THROW = 0x800, MA_DELETE = 0x80000, ALL_DELETE = DC_DELETE \| CC_DELETE \| MC_DELETE \| CA_DELETE \| MA_DELETE, IS_RELOCATABLE = 0x2000, PROP_COPY = 0x100000, PROP_MOVE = 0x200000, PROP_SWAP = 0x400000 }

Functions
void	softReset (int ticks=-1)

void	hardReset ()

int	getTotal ()

void	isSane ()

uint64_t	ReadTSC ()

template<class Vector >
void	populate (Vector &v, const pair< int, int > &ss)

template<class Vector >
std::pair< typename Vector::iterator, string >	iterSpotter (Vector &v, int i)

template<class Vector >
void	verifyVector (const Vector &v)

void	verifyAllocator (int ele, int cap)

template<class Vector >
void	verify (int extras)

template<class Vector >
void	verify (int extras, const Vector &v)

template<class Vector >
void	verify (int extras, const Vector &v1, const Vector &v2)

int	convertToInt (int t)

template<Flags f, size_t pad>
int	convertToInt (const Data< f, pad > &t)

template<typename T >
int	convertToInt (const std::allocator< T > &)

template<typename T >
int	convertToInt (const Alloc< T > &a)

template<typename It >
Transformer< It, forward_iterator_tag >	makeForwardIterator (const It &it)

template<typename It >
Transformer< It, input_iterator_tag >	makeInputIterator (const It &it)

void	mutate (int &i)

void	mutate (uint64_t &i)

template<Flags f, size_t pad>
void	mutate (Data< f, pad > &ds)

template<class Vector , typename T , typename Allocator >
void	test_containerTypedefs (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_containerTypedefs2 (std::false_type)

template<class Vector >
void	test_containerTypedefs2 (std::true_type)

template<class Vector >
void	test_containerTypedefs3 ()

template<class Vector >
bool	test_I_containerTypedefs2 (std::false_type)

template<class Vector >
bool	test_I_containerTypedefs2 (std::true_type)

template<class Vector >
bool	test_I_containerTypedefs3 ()

	TEST (FBVector, containerTypedefs)

template<class Vector , typename T , typename Allocator >
void	test_emptyConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_emptyConstruction2 (std::false_type)

template<class Vector >
void	test_emptyConstruction2 (std::true_type)

template<class Vector >
void	test_emptyConstruction3 ()

template<class Vector >
bool	test_I_emptyConstruction2 (std::false_type)

template<class Vector >
bool	test_I_emptyConstruction2 (std::true_type)

template<class Vector >
bool	test_I_emptyConstruction3 ()

	TEST (FBVector, emptyConstruction)

template<class Vector , typename T , typename Allocator >
void	test_populate (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_populate2 (std::false_type)

template<class Vector >
void	test_populate2 (std::true_type)

template<class Vector >
void	test_populate3 ()

template<class Vector >
bool	test_I_populate2 (std::false_type)

template<class Vector >
bool	test_I_populate2 (std::true_type)

template<class Vector >
bool	test_I_populate3 ()

	TEST (FBVector, populate)

template<class Vector , typename T , typename Allocator >
void	test_copyConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_copyConstruction2 (std::false_type)

template<class Vector >
void	test_copyConstruction2 (std::true_type)

template<class Vector >
void	test_copyConstruction3 ()

template<class Vector >
bool	test_I_copyConstruction2 (std::false_type)

template<class Vector >
bool	test_I_copyConstruction2 (std::true_type)

template<class Vector >
bool	test_I_copyConstruction3 ()

	TEST (FBVector, copyConstruction)

template<class Vector , typename T , typename Allocator >
void	test_moveConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_moveConstruction2 (std::false_type)

template<class Vector >
void	test_moveConstruction2 (std::true_type)

template<class Vector >
void	test_moveConstruction3 ()

template<class Vector >
bool	test_I_moveConstruction2 (std::false_type)

template<class Vector >
bool	test_I_moveConstruction2 (std::true_type)

template<class Vector >
bool	test_I_moveConstruction3 ()

	TEST (FBVector, moveConstruction)

template<class Vector , typename T , typename Allocator >
void	test_moveAssignment (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))))

template<class Vector >
void	test_moveAssignment2 (std::false_type)

template<class Vector >
void	test_moveAssignment2 (std::true_type)

template<class Vector >
void	test_moveAssignment3 ()

template<class Vector >
bool	test_I_moveAssignment2 (std::false_type)

template<class Vector >
bool	test_I_moveAssignment2 (std::true_type)

template<class Vector >
bool	test_I_moveAssignment3 ()

	TEST (FBVector, moveAssignment)

template<class Vector , typename T , typename Allocator >
void	test_destructible (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_destructible2 (std::false_type)

template<class Vector >
void	test_destructible2 (std::true_type)

template<class Vector >
void	test_destructible3 ()

template<class Vector >
bool	test_I_destructible2 (std::false_type)

template<class Vector >
bool	test_I_destructible2 (std::true_type)

template<class Vector >
bool	test_I_destructible3 ()

	TEST (FBVector, destructible)

template<class Vector , typename T , typename Allocator >
void	test_iterators (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_iterators2 (std::false_type)

template<class Vector >
void	test_iterators2 (std::true_type)

template<class Vector >
void	test_iterators3 ()

template<class Vector >
bool	test_I_iterators2 (std::false_type)

template<class Vector >
bool	test_I_iterators2 (std::true_type)

template<class Vector >
bool	test_I_iterators3 ()

	TEST (FBVector, iterators)

template<class Vector , typename T , typename Allocator >
void	test_equitable (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))))

template<class Vector >
void	test_equitable2 (std::false_type)

template<class Vector >
void	test_equitable2 (std::true_type)

template<class Vector >
void	test_equitable3 ()

template<class Vector >
bool	test_I_equitable2 (std::false_type)

template<class Vector >
bool	test_I_equitable2 (std::true_type)

template<class Vector >
bool	test_I_equitable3 ()

	TEST (FBVector, equitable)

template<class Vector , typename T , typename Allocator >
void	test_memberSwappable (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))))

template<class Vector >
void	test_memberSwappable2 (std::false_type)

template<class Vector >
void	test_memberSwappable2 (std::true_type)

template<class Vector >
void	test_memberSwappable3 ()

template<class Vector >
bool	test_I_memberSwappable2 (std::false_type)

template<class Vector >
bool	test_I_memberSwappable2 (std::true_type)

template<class Vector >
bool	test_I_memberSwappable3 ()

	TEST (FBVector, memberSwappable)

template<class Vector , typename T , typename Allocator >
void	test_nonmemberSwappable (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))))

template<class Vector >
void	test_nonmemberSwappable2 (std::false_type)

template<class Vector >
void	test_nonmemberSwappable2 (std::true_type)

template<class Vector >
void	test_nonmemberSwappable3 ()

template<class Vector >
bool	test_I_nonmemberSwappable2 (std::false_type)

template<class Vector >
bool	test_I_nonmemberSwappable2 (std::true_type)

template<class Vector >
bool	test_I_nonmemberSwappable3 ()

	TEST (FBVector, nonmemberSwappable)

template<class Vector , typename T , typename Allocator >
void	test_copyAssign (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))))

template<class Vector >
void	test_copyAssign2 (std::false_type)

template<class Vector >
void	test_copyAssign2 (std::true_type)

template<class Vector >
void	test_copyAssign3 ()

template<class Vector >
bool	test_I_copyAssign2 (std::false_type)

template<class Vector >
bool	test_I_copyAssign2 (std::true_type)

template<class Vector >
bool	test_I_copyAssign3 ()

	TEST (FBVector, copyAssign)

template<class Vector , typename T , typename Allocator >
void	test_sizeops (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_sizeops2 (std::false_type)

template<class Vector >
void	test_sizeops2 (std::true_type)

template<class Vector >
void	test_sizeops3 ()

template<class Vector >
bool	test_I_sizeops2 (std::false_type)

template<class Vector >
bool	test_I_sizeops2 (std::true_type)

template<class Vector >
bool	test_I_sizeops3 ()

	TEST (FBVector, sizeops)

template<class Vector , typename T , typename Allocator >
void	test_reversibleContainerTypedefs (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_reversibleContainerTypedefs2 (std::false_type)

template<class Vector >
void	test_reversibleContainerTypedefs2 (std::true_type)

template<class Vector >
void	test_reversibleContainerTypedefs3 ()

template<class Vector >
bool	test_I_reversibleContainerTypedefs2 (std::false_type)

template<class Vector >
bool	test_I_reversibleContainerTypedefs2 (std::true_type)

template<class Vector >
bool	test_I_reversibleContainerTypedefs3 ()

	TEST (FBVector, reversibleContainerTypedefs)

template<class Vector , typename T , typename Allocator >
void	test_reversibleIterators (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_reversibleIterators2 (std::false_type)

template<class Vector >
void	test_reversibleIterators2 (std::true_type)

template<class Vector >
void	test_reversibleIterators3 ()

template<class Vector >
bool	test_I_reversibleIterators2 (std::false_type)

template<class Vector >
bool	test_I_reversibleIterators2 (std::true_type)

template<class Vector >
bool	test_I_reversibleIterators3 ()

	TEST (FBVector, reversibleIterators)

template<class Vector , typename T , typename Allocator >
void	test_comparable (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_comparable2 (std::false_type)

template<class Vector >
void	test_comparable2 (std::true_type)

template<class Vector >
void	test_comparable3 ()

template<class Vector >
bool	test_I_comparable2 (std::false_type)

template<class Vector >
bool	test_I_comparable2 (std::true_type)

template<class Vector >
bool	test_I_comparable3 ()

	TEST (FBVector, comparable)

template<class Vector , typename T , typename Allocator >
void	test_allocatorTypedefs (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_allocatorTypedefs2 (std::false_type)

template<class Vector >
void	test_allocatorTypedefs2 (std::true_type)

template<class Vector >
void	test_allocatorTypedefs3 ()

template<class Vector >
bool	test_I_allocatorTypedefs2 (std::false_type)

template<class Vector >
bool	test_I_allocatorTypedefs2 (std::true_type)

template<class Vector >
bool	test_I_allocatorTypedefs3 ()

	TEST (FBVector, allocatorTypedefs)

template<class Vector , typename T , typename Allocator >
void	test_getAllocator (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_getAllocator2 (std::false_type)

template<class Vector >
void	test_getAllocator2 (std::true_type)

template<class Vector >
void	test_getAllocator3 ()

template<class Vector >
bool	test_I_getAllocator2 (std::false_type)

template<class Vector >
bool	test_I_getAllocator2 (std::true_type)

template<class Vector >
bool	test_I_getAllocator3 ()

	TEST (FBVector, getAllocator)

template<class Vector , typename T , typename Allocator >
void	test_defaultAllocator (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_defaultAllocator2 (std::false_type)

template<class Vector >
void	test_defaultAllocator2 (std::true_type)

template<class Vector >
void	test_defaultAllocator3 ()

template<class Vector >
bool	test_I_defaultAllocator2 (std::false_type)

template<class Vector >
bool	test_I_defaultAllocator2 (std::true_type)

template<class Vector >
bool	test_I_defaultAllocator3 ()

	TEST (FBVector, defaultAllocator)

template<class Vector , typename T , typename Allocator >
void	test_customAllocator (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, m, ticks)))))

template<class Vector >
void	test_customAllocator2 (std::false_type)

template<class Vector >
void	test_customAllocator2 (std::true_type)

template<class Vector >
void	test_customAllocator3 ()

template<class Vector >
bool	test_I_customAllocator2 (std::false_type)

template<class Vector >
bool	test_I_customAllocator2 (std::true_type)

template<class Vector >
bool	test_I_customAllocator3 ()

	TEST (FBVector, customAllocator)

template<class Vector , typename T , typename Allocator >
void	test_copyWithAllocator (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, m, ticks)))))

template<class Vector >
void	test_copyWithAllocator2 (std::false_type)

template<class Vector >
void	test_copyWithAllocator2 (std::true_type)

template<class Vector >
void	test_copyWithAllocator3 ()

template<class Vector >
bool	test_I_copyWithAllocator2 (std::false_type)

template<class Vector >
bool	test_I_copyWithAllocator2 (std::true_type)

template<class Vector >
bool	test_I_copyWithAllocator3 ()

	TEST (FBVector, copyWithAllocator)

template<class Vector , typename T , typename Allocator >
void	test_moveConstructionWithAllocator (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_moveConstructionWithAllocator2 (std::false_type)

template<class Vector >
void	test_moveConstructionWithAllocator2 (std::true_type)

template<class Vector >
void	test_moveConstructionWithAllocator3 ()

template<class Vector >
bool	test_I_moveConstructionWithAllocator2 (std::false_type)

template<class Vector >
bool	test_I_moveConstructionWithAllocator2 (std::true_type)

template<class Vector >
bool	test_I_moveConstructionWithAllocator3 ()

	TEST (FBVector, moveConstructionWithAllocator)

template<class Vector , typename T , typename Allocator >
void	test_moveConstructionWithAllocatorSupplied (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, m, ticks)))))

template<class Vector >
void	test_moveConstructionWithAllocatorSupplied2 (std::false_type)

template<class Vector >
void	test_moveConstructionWithAllocatorSupplied2 (std::true_type)

template<class Vector >
void	test_moveConstructionWithAllocatorSupplied3 ()

template<class Vector >
bool	test_I_moveConstructionWithAllocatorSupplied2 (std::false_type)

template<class Vector >
bool	test_I_moveConstructionWithAllocatorSupplied2 (std::true_type)

template<class Vector >
bool	test_I_moveConstructionWithAllocatorSupplied3 ()

	TEST (FBVector, moveConstructionWithAllocatorSupplied)

template<class Vector , typename T , typename Allocator >
void	test_allocAssign (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_allocAssign2 (std::false_type)

template<class Vector >
void	test_allocAssign2 (std::true_type)

template<class Vector >
void	test_allocAssign3 ()

template<class Vector >
bool	test_I_allocAssign2 (std::false_type)

template<class Vector >
bool	test_I_allocAssign2 (std::true_type)

template<class Vector >
bool	test_I_allocAssign3 ()

	TEST (FBVector, allocAssign)

template<class Vector , typename T , typename Allocator >
void	test_nAllocConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, n, m, ticks)))))

template<class Vector >
void	test_nAllocConstruction2 (std::false_type)

template<class Vector >
void	test_nAllocConstruction2 (std::true_type)

template<class Vector >
void	test_nAllocConstruction3 ()

template<class Vector >
bool	test_I_nAllocConstruction2 (std::false_type)

template<class Vector >
bool	test_I_nAllocConstruction2 (std::true_type)

template<class Vector >
bool	test_I_nAllocConstruction3 ()

	TEST (FBVector, nAllocConstruction)

template<class Vector , typename T , typename Allocator >
void	test_nCopyAllocConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, n, t, m, ticks)))))

template<class Vector >
void	test_nCopyAllocConstruction2 (std::false_type)

template<class Vector >
void	test_nCopyAllocConstruction2 (std::true_type)

template<class Vector >
void	test_nCopyAllocConstruction3 ()

template<class Vector >
bool	test_I_nCopyAllocConstruction2 (std::false_type)

template<class Vector >
bool	test_I_nCopyAllocConstruction2 (std::true_type)

template<class Vector >
bool	test_I_nCopyAllocConstruction3 ()

	TEST (FBVector, nCopyAllocConstruction)

template<class Vector , typename T , typename Allocator >
void	test_forwardIteratorAllocConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, i, j, m, ticks)))))

template<class Vector >
void	test_forwardIteratorAllocConstruction2 (std::false_type)

template<class Vector >
void	test_forwardIteratorAllocConstruction2 (std::true_type)

template<class Vector >
void	test_forwardIteratorAllocConstruction3 ()

template<class Vector >
bool	test_I_forwardIteratorAllocConstruction2 (std::false_type)

template<class Vector >
bool	test_I_forwardIteratorAllocConstruction2 (std::true_type)

template<class Vector >
bool	test_I_forwardIteratorAllocConstruction3 ()

	TEST (FBVector, forwardIteratorAllocConstruction)

template<class Vector , typename T , typename Allocator >
void	test_inputIteratorAllocConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, i, j, m, ticks)))))

template<class Vector >
void	test_inputIteratorAllocConstruction2 (std::false_type)

template<class Vector >
void	test_inputIteratorAllocConstruction2 (std::true_type)

template<class Vector >
void	test_inputIteratorAllocConstruction3 ()

template<class Vector >
bool	test_I_inputIteratorAllocConstruction2 (std::false_type)

template<class Vector >
bool	test_I_inputIteratorAllocConstruction2 (std::true_type)

template<class Vector >
bool	test_I_inputIteratorAllocConstruction3 ()

	TEST (FBVector, inputIteratorAllocConstruction)

template<class Vector , typename T , typename Allocator >
void	test_ilAllocConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, m, ticks)))))

template<class Vector >
void	test_ilAllocConstruction2 (std::false_type)

template<class Vector >
void	test_ilAllocConstruction2 (std::true_type)

template<class Vector >
void	test_ilAllocConstruction3 ()

template<class Vector >
bool	test_I_ilAllocConstruction2 (std::false_type)

template<class Vector >
bool	test_I_ilAllocConstruction2 (std::true_type)

template<class Vector >
bool	test_I_ilAllocConstruction3 ()

	TEST (FBVector, ilAllocConstruction)

template<class Vector , typename T , typename Allocator >
void	test_dataRaces (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_dataRaces2 (std::false_type)

template<class Vector >
void	test_dataRaces2 (std::true_type)

template<class Vector >
void	test_dataRaces3 ()

template<class Vector >
bool	test_I_dataRaces2 (std::false_type)

template<class Vector >
bool	test_I_dataRaces2 (std::true_type)

template<class Vector >
bool	test_I_dataRaces3 ()

	TEST (FBVector, dataRaces)

template<class Vector , typename T , typename Allocator >
void	test_nConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, n, ticks)))))

template<class Vector >
void	test_nConstruction2 (std::false_type)

template<class Vector >
void	test_nConstruction2 (std::true_type)

template<class Vector >
void	test_nConstruction3 ()

template<class Vector >
bool	test_I_nConstruction2 (std::false_type)

template<class Vector >
bool	test_I_nConstruction2 (std::true_type)

template<class Vector >
bool	test_I_nConstruction3 ()

	TEST (FBVector, nConstruction)

template<class Vector , typename T , typename Allocator >
void	test_nCopyConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, n, t, ticks)))))

template<class Vector >
void	test_nCopyConstruction2 (std::false_type)

template<class Vector >
void	test_nCopyConstruction2 (std::true_type)

template<class Vector >
void	test_nCopyConstruction3 ()

template<class Vector >
bool	test_I_nCopyConstruction2 (std::false_type)

template<class Vector >
bool	test_I_nCopyConstruction2 (std::true_type)

template<class Vector >
bool	test_I_nCopyConstruction3 ()

	TEST (FBVector, nCopyConstruction)

template<class Vector , typename T , typename Allocator >
void	test_forwardIteratorConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, i, j, ticks)))))

template<class Vector >
void	test_forwardIteratorConstruction2 (std::false_type)

template<class Vector >
void	test_forwardIteratorConstruction2 (std::true_type)

template<class Vector >
void	test_forwardIteratorConstruction3 ()

template<class Vector >
bool	test_I_forwardIteratorConstruction2 (std::false_type)

template<class Vector >
bool	test_I_forwardIteratorConstruction2 (std::true_type)

template<class Vector >
bool	test_I_forwardIteratorConstruction3 ()

	TEST (FBVector, forwardIteratorConstruction)

template<class Vector , typename T , typename Allocator >
void	test_inputIteratorConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, i, j, ticks)))))

template<class Vector >
void	test_inputIteratorConstruction2 (std::false_type)

template<class Vector >
void	test_inputIteratorConstruction2 (std::true_type)

template<class Vector >
void	test_inputIteratorConstruction3 ()

template<class Vector >
bool	test_I_inputIteratorConstruction2 (std::false_type)

template<class Vector >
bool	test_I_inputIteratorConstruction2 (std::true_type)

template<class Vector >
bool	test_I_inputIteratorConstruction3 ()

	TEST (FBVector, inputIteratorConstruction)

template<class Vector , typename T , typename Allocator >
void	test_ilConstruction (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_ilConstruction2 (std::false_type)

template<class Vector >
void	test_ilConstruction2 (std::true_type)

template<class Vector >
void	test_ilConstruction3 ()

template<class Vector >
bool	test_I_ilConstruction2 (std::false_type)

template<class Vector >
bool	test_I_ilConstruction2 (std::true_type)

template<class Vector >
bool	test_I_ilConstruction3 ()

	TEST (FBVector, ilConstruction)

template<class Vector , typename T , typename Allocator >
void	test_ilAssignment (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_ilAssignment2 (std::false_type)

template<class Vector >
void	test_ilAssignment2 (std::true_type)

template<class Vector >
void	test_ilAssignment3 ()

template<class Vector >
bool	test_I_ilAssignment2 (std::false_type)

template<class Vector >
bool	test_I_ilAssignment2 (std::true_type)

template<class Vector >
bool	test_I_ilAssignment3 ()

	TEST (FBVector, ilAssignment)

template<class Vector >
void	insertNTCheck (const Vector &a, DataState< Vector > &dsa, int idx, int n, int val)

template<class Vector , typename T , typename Allocator >
void	test_iteratorEmplacement (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, p, ticks)))))

template<class Vector >
void	test_iteratorEmplacement2 (std::false_type)

template<class Vector >
void	test_iteratorEmplacement2 (std::true_type)

template<class Vector >
void	test_iteratorEmplacement3 ()

template<class Vector >
bool	test_I_iteratorEmplacement2 (std::false_type)

template<class Vector >
bool	test_I_iteratorEmplacement2 (std::true_type)

template<class Vector >
bool	test_I_iteratorEmplacement3 ()

	TEST (FBVector, iteratorEmplacement)

template<class Vector , typename T , typename Allocator >
void	test_iteratorInsertion (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, p, t, ticks)))))

template<class Vector >
void	test_iteratorInsertion2 (std::false_type)

template<class Vector >
void	test_iteratorInsertion2 (std::true_type)

template<class Vector >
void	test_iteratorInsertion3 ()

template<class Vector >
bool	test_I_iteratorInsertion2 (std::false_type)

template<class Vector >
bool	test_I_iteratorInsertion2 (std::true_type)

template<class Vector >
bool	test_I_iteratorInsertion3 ()

	TEST (FBVector, iteratorInsertion)

template<class Vector , typename T , typename Allocator >
void	test_iteratorInsertionRV (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, p, t, ticks)))))

template<class Vector >
void	test_iteratorInsertionRV2 (std::false_type)

template<class Vector >
void	test_iteratorInsertionRV2 (std::true_type)

template<class Vector >
void	test_iteratorInsertionRV3 ()

template<class Vector >
bool	test_I_iteratorInsertionRV2 (std::false_type)

template<class Vector >
bool	test_I_iteratorInsertionRV2 (std::true_type)

template<class Vector >
bool	test_I_iteratorInsertionRV3 ()

	TEST (FBVector, iteratorInsertionRV)

template<class Vector , typename T , typename Allocator >
void	test_iteratorInsertionN (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(6,(z, a, p, n, t, ticks)))))

template<class Vector >
void	test_iteratorInsertionN2 (std::false_type)

template<class Vector >
void	test_iteratorInsertionN2 (std::true_type)

template<class Vector >
void	test_iteratorInsertionN3 ()

template<class Vector >
bool	test_I_iteratorInsertionN2 (std::false_type)

template<class Vector >
bool	test_I_iteratorInsertionN2 (std::true_type)

template<class Vector >
bool	test_I_iteratorInsertionN3 ()

	TEST (FBVector, iteratorInsertionN)

template<class Vector >
void	insertItCheck (const Vector &a, DataState< Vector > &dsa, int idx, int b, int e)

template<class Vector , typename T , typename Allocator >
void	test_iteratorInsertionIterator (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(6,(z, a, p, i, j, ticks)))))

template<class Vector >
void	test_iteratorInsertionIterator2 (std::false_type)

template<class Vector >
void	test_iteratorInsertionIterator2 (std::true_type)

template<class Vector >
void	test_iteratorInsertionIterator3 ()

template<class Vector >
bool	test_I_iteratorInsertionIterator2 (std::false_type)

template<class Vector >
bool	test_I_iteratorInsertionIterator2 (std::true_type)

template<class Vector >
bool	test_I_iteratorInsertionIterator3 ()

	TEST (FBVector, iteratorInsertionIterator)

template<class Vector , typename T , typename Allocator >
void	test_iteratorInsertionInputIterator (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(6,(z, a, p, i, j, ticks)))))

template<class Vector >
void	test_iteratorInsertionInputIterator2 (std::false_type)

template<class Vector >
void	test_iteratorInsertionInputIterator2 (std::true_type)

template<class Vector >
void	test_iteratorInsertionInputIterator3 ()

template<class Vector >
bool	test_I_iteratorInsertionInputIterator2 (std::false_type)

template<class Vector >
bool	test_I_iteratorInsertionInputIterator2 (std::true_type)

template<class Vector >
bool	test_I_iteratorInsertionInputIterator3 ()

	TEST (FBVector, iteratorInsertionInputIterator)

template<class Vector , typename T , typename Allocator >
void	test_iteratorInsertIL (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, p, ticks)))))

template<class Vector >
void	test_iteratorInsertIL2 (std::false_type)

template<class Vector >
void	test_iteratorInsertIL2 (std::true_type)

template<class Vector >
void	test_iteratorInsertIL3 ()

template<class Vector >
bool	test_I_iteratorInsertIL2 (std::false_type)

template<class Vector >
bool	test_I_iteratorInsertIL2 (std::true_type)

template<class Vector >
bool	test_I_iteratorInsertIL3 ()

	TEST (FBVector, iteratorInsertIL)

template<class Vector >
void	eraseCheck (Vector &a, DataState< Vector > &dsa, int idx, int n)

template<class Vector , typename T , typename Allocator >
void	test_iteratorErase (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, p, ticks)))))

template<class Vector >
void	test_iteratorErase2 (std::false_type)

template<class Vector >
void	test_iteratorErase2 (std::true_type)

template<class Vector >
void	test_iteratorErase3 ()

template<class Vector >
bool	test_I_iteratorErase2 (std::false_type)

template<class Vector >
bool	test_I_iteratorErase2 (std::true_type)

template<class Vector >
bool	test_I_iteratorErase3 ()

	TEST (FBVector, iteratorErase)

template<class Vector , typename T , typename Allocator >
void	test_iteratorEraseRange (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, p, q, ticks)))))

template<class Vector >
void	test_iteratorEraseRange2 (std::false_type)

template<class Vector >
void	test_iteratorEraseRange2 (std::true_type)

template<class Vector >
void	test_iteratorEraseRange3 ()

template<class Vector >
bool	test_I_iteratorEraseRange2 (std::false_type)

template<class Vector >
bool	test_I_iteratorEraseRange2 (std::true_type)

template<class Vector >
bool	test_I_iteratorEraseRange3 ()

	TEST (FBVector, iteratorEraseRange)

template<class Vector , typename T , typename Allocator >
void	test_clear (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_clear2 (std::false_type)

template<class Vector >
void	test_clear2 (std::true_type)

template<class Vector >
void	test_clear3 ()

template<class Vector >
bool	test_I_clear2 (std::false_type)

template<class Vector >
bool	test_I_clear2 (std::true_type)

template<class Vector >
bool	test_I_clear3 ()

	TEST (FBVector, clear)

template<class Vector , typename T , typename Allocator >
void	test_assignRange (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, i, j, ticks)))))

template<class Vector >
void	test_assignRange2 (std::false_type)

template<class Vector >
void	test_assignRange2 (std::true_type)

template<class Vector >
void	test_assignRange3 ()

template<class Vector >
bool	test_I_assignRange2 (std::false_type)

template<class Vector >
bool	test_I_assignRange2 (std::true_type)

template<class Vector >
bool	test_I_assignRange3 ()

	TEST (FBVector, assignRange)

template<class Vector , typename T , typename Allocator >
void	test_assignInputRange (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, i, j, ticks)))))

template<class Vector >
void	test_assignInputRange2 (std::false_type)

template<class Vector >
void	test_assignInputRange2 (std::true_type)

template<class Vector >
void	test_assignInputRange3 ()

template<class Vector >
bool	test_I_assignInputRange2 (std::false_type)

template<class Vector >
bool	test_I_assignInputRange2 (std::true_type)

template<class Vector >
bool	test_I_assignInputRange3 ()

	TEST (FBVector, assignInputRange)

template<class Vector , typename T , typename Allocator >
void	test_assignIL (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_assignIL2 (std::false_type)

template<class Vector >
void	test_assignIL2 (std::true_type)

template<class Vector >
void	test_assignIL3 ()

template<class Vector >
bool	test_I_assignIL2 (std::false_type)

template<class Vector >
bool	test_I_assignIL2 (std::true_type)

template<class Vector >
bool	test_I_assignIL3 ()

	TEST (FBVector, assignIL)

template<class Vector , typename T , typename Allocator >
void	test_assignN (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, n, t, ticks)))))

template<class Vector >
void	test_assignN2 (std::false_type)

template<class Vector >
void	test_assignN2 (std::true_type)

template<class Vector >
void	test_assignN3 ()

template<class Vector >
bool	test_I_assignN2 (std::false_type)

template<class Vector >
bool	test_I_assignN2 (std::true_type)

template<class Vector >
bool	test_I_assignN3 ()

	TEST (FBVector, assignN)

template<class Vector , typename T , typename Allocator >
void	test_front (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_front2 (std::false_type)

template<class Vector >
void	test_front2 (std::true_type)

template<class Vector >
void	test_front3 ()

template<class Vector >
bool	test_I_front2 (std::false_type)

template<class Vector >
bool	test_I_front2 (std::true_type)

template<class Vector >
bool	test_I_front3 ()

	TEST (FBVector, front)

template<class Vector , typename T , typename Allocator >
void	test_back (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_back2 (std::false_type)

template<class Vector >
void	test_back2 (std::true_type)

template<class Vector >
void	test_back3 ()

template<class Vector >
bool	test_I_back2 (std::false_type)

template<class Vector >
bool	test_I_back2 (std::true_type)

template<class Vector >
bool	test_I_back3 ()

	TEST (FBVector, back)

template<class Vector , typename T , typename Allocator >
void	test_emplaceBack (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_emplaceBack2 (std::false_type)

template<class Vector >
void	test_emplaceBack2 (std::true_type)

template<class Vector >
void	test_emplaceBack3 ()

template<class Vector >
bool	test_I_emplaceBack2 (std::false_type)

template<class Vector >
bool	test_I_emplaceBack2 (std::true_type)

template<class Vector >
bool	test_I_emplaceBack3 ()

	TEST (FBVector, emplaceBack)

template<class Vector , typename T , typename Allocator >
void	test_pushBack (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, t, ticks)))))

template<class Vector >
void	test_pushBack2 (std::false_type)

template<class Vector >
void	test_pushBack2 (std::true_type)

template<class Vector >
void	test_pushBack3 ()

template<class Vector >
bool	test_I_pushBack2 (std::false_type)

template<class Vector >
bool	test_I_pushBack2 (std::true_type)

template<class Vector >
bool	test_I_pushBack3 ()

	TEST (FBVector, pushBack)

template<class Vector , typename T , typename Allocator >
void	test_pushBackRV (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, t, ticks)))))

template<class Vector >
void	test_pushBackRV2 (std::false_type)

template<class Vector >
void	test_pushBackRV2 (std::true_type)

template<class Vector >
void	test_pushBackRV3 ()

template<class Vector >
bool	test_I_pushBackRV2 (std::false_type)

template<class Vector >
bool	test_I_pushBackRV2 (std::true_type)

template<class Vector >
bool	test_I_pushBackRV3 ()

	TEST (FBVector, pushBackRV)

template<class Vector , typename T , typename Allocator >
void	test_popBack (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_popBack2 (std::false_type)

template<class Vector >
void	test_popBack2 (std::true_type)

template<class Vector >
void	test_popBack3 ()

template<class Vector >
bool	test_I_popBack2 (std::false_type)

template<class Vector >
bool	test_I_popBack2 (std::true_type)

template<class Vector >
bool	test_I_popBack3 ()

	TEST (FBVector, popBack)

template<class Vector , typename T , typename Allocator >
void	test_operatorBrace (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_operatorBrace2 (std::false_type)

template<class Vector >
void	test_operatorBrace2 (std::true_type)

template<class Vector >
void	test_operatorBrace3 ()

template<class Vector >
bool	test_I_operatorBrace2 (std::false_type)

template<class Vector >
bool	test_I_operatorBrace2 (std::true_type)

template<class Vector >
bool	test_I_operatorBrace3 ()

	TEST (FBVector, operatorBrace)

template<class Vector , typename T , typename Allocator >
void	test_at (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_at2 (std::false_type)

template<class Vector >
void	test_at2 (std::true_type)

template<class Vector >
void	test_at3 ()

template<class Vector >
bool	test_I_at2 (std::false_type)

template<class Vector >
bool	test_I_at2 (std::true_type)

template<class Vector >
bool	test_I_at3 ()

	TEST (FBVector, at)

template<class Vector , typename T , typename Allocator >
void	test_moveIterators (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_moveIterators2 (std::false_type)

template<class Vector >
void	test_moveIterators2 (std::true_type)

template<class Vector >
void	test_moveIterators3 ()

template<class Vector >
bool	test_I_moveIterators2 (std::false_type)

template<class Vector >
bool	test_I_moveIterators2 (std::true_type)

template<class Vector >
bool	test_I_moveIterators3 ()

	TEST (FBVector, moveIterators)

template<class Vector , typename T , typename Allocator >
void	test_dataAndCapacity (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_dataAndCapacity2 (std::false_type)

template<class Vector >
void	test_dataAndCapacity2 (std::true_type)

template<class Vector >
void	test_dataAndCapacity3 ()

template<class Vector >
bool	test_I_dataAndCapacity2 (std::false_type)

template<class Vector >
bool	test_I_dataAndCapacity2 (std::true_type)

template<class Vector >
bool	test_I_dataAndCapacity3 ()

	TEST (FBVector, dataAndCapacity)

template<class Vector , typename T , typename Allocator >
void	test_reserve (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, n, ticks)))))

template<class Vector >
void	test_reserve2 (std::false_type)

template<class Vector >
void	test_reserve2 (std::true_type)

template<class Vector >
void	test_reserve3 ()

template<class Vector >
bool	test_I_reserve2 (std::false_type)

template<class Vector >
bool	test_I_reserve2 (std::true_type)

template<class Vector >
bool	test_I_reserve3 ()

	TEST (FBVector, reserve)

template<class Vector , typename T , typename Allocator >
void	test_lengthError (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_lengthError2 (std::false_type)

template<class Vector >
void	test_lengthError2 (std::true_type)

template<class Vector >
void	test_lengthError3 ()

template<class Vector >
bool	test_I_lengthError2 (std::false_type)

template<class Vector >
bool	test_I_lengthError2 (std::true_type)

template<class Vector >
bool	test_I_lengthError3 ()

	TEST (FBVector, lengthError)

template<class Vector , typename T , typename Allocator >
void	test_resize (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, n, ticks)))))

template<class Vector >
void	test_resize2 (std::false_type)

template<class Vector >
void	test_resize2 (std::true_type)

template<class Vector >
void	test_resize3 ()

template<class Vector >
bool	test_I_resize2 (std::false_type)

template<class Vector >
bool	test_I_resize2 (std::true_type)

template<class Vector >
bool	test_I_resize3 ()

	TEST (FBVector, resize)

template<class Vector , typename T , typename Allocator >
void	test_resizeT (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, n, t, ticks)))))

template<class Vector >
void	test_resizeT2 (std::false_type)

template<class Vector >
void	test_resizeT2 (std::true_type)

template<class Vector >
void	test_resizeT3 ()

template<class Vector >
bool	test_I_resizeT2 (std::false_type)

template<class Vector >
bool	test_I_resizeT2 (std::true_type)

template<class Vector >
bool	test_I_resizeT3 ()

	TEST (FBVector, resizeT)

template<class Vector , typename T , typename Allocator >
void	test_shrinkToFit (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_shrinkToFit2 (std::false_type)

template<class Vector >
void	test_shrinkToFit2 (std::true_type)

template<class Vector >
void	test_shrinkToFit3 ()

template<class Vector >
bool	test_I_shrinkToFit2 (std::false_type)

template<class Vector >
bool	test_I_shrinkToFit2 (std::true_type)

template<class Vector >
bool	test_I_shrinkToFit3 ()

	TEST (FBVector, shrinkToFit)

template<class Vector , typename T , typename Allocator >
void	test_ebo (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))))

template<class Vector >
void	test_ebo2 (std::false_type)

template<class Vector >
void	test_ebo2 (std::true_type)

template<class Vector >
void	test_ebo3 ()

template<class Vector >
bool	test_I_ebo2 (std::false_type)

template<class Vector >
bool	test_I_ebo2 (std::true_type)

template<class Vector >
bool	test_I_ebo3 ()

	TEST (FBVector, ebo)

template<class Vector , typename T , typename Allocator >
void	test_relinquish (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_relinquish2 (std::false_type)

template<class Vector >
void	test_relinquish2 (std::true_type)

template<class Vector >
void	test_relinquish3 ()

template<class Vector >
bool	test_I_relinquish2 (std::false_type)

template<class Vector >
bool	test_I_relinquish2 (std::true_type)

template<class Vector >
bool	test_I_relinquish3 ()

	TEST (FBVector, relinquish)

template<class Vector , typename T , typename Allocator >
void	test_attach (BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))))

template<class Vector >
void	test_attach2 (std::false_type)

template<class Vector >
void	test_attach2 (std::true_type)

template<class Vector >
void	test_attach3 ()

template<class Vector >
bool	test_I_attach2 (std::false_type)

template<class Vector >
bool	test_I_attach2 (std::true_type)

template<class Vector >
bool	test_I_attach3 ()

	TEST (FBVector, attach)

int	main (int argc, char **argv)

Variables
static const vector< pair< int, int > >	VectorSizes

int	populateIndex = 1426

static const vector< int >	nSizes = {0, 1, 2, 9, 10, 11}

static int	ijarr [12] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89}

static int	ijarC [12] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89}

static const vector< int >	tVals = {0, 1, 2, 3, 17, 66, 521}

Macro Definition Documentation

#define ARGIFY	(	r,
		d,
		name
	)	TYPIFY(r, d, name) name

Definition at line 906 of file StlVectorTest.cpp.

#define CLOSER_a }

Definition at line 1277 of file StlVectorTest.cpp.

#define CLOSER_b }

Definition at line 1302 of file StlVectorTest.cpp.

#define CLOSER_i

Definition at line 1329 of file StlVectorTest.cpp.

#define CLOSER_j }

Definition at line 1340 of file StlVectorTest.cpp.

#define CLOSER_m }

Definition at line 1439 of file StlVectorTest.cpp.

#define CLOSER_n }

Definition at line 1315 of file StlVectorTest.cpp.

#define CLOSER_p }

Definition at line 1393 of file StlVectorTest.cpp.

#define CLOSER_q }

Definition at line 1403 of file StlVectorTest.cpp.

#define CLOSER_t }

Definition at line 1426 of file StlVectorTest.cpp.

#define CLOSER_ticks }

Definition at line 1197 of file StlVectorTest.cpp.

#define CLOSER_z

Definition at line 1151 of file StlVectorTest.cpp.

#define DECL	(	name,
		...
	)

Value:

template <class Vector, typename T, typename Allocator>    \
  void test_##name(BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM( \
      ARGIFY, _, IBOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))))

Definition at line 964 of file StlVectorTest.cpp.

#define GEN_CLOSER	(	r,
		d,
		arg
	)	BOOST_PP_CAT(CLOSER_, arg)

Definition at line 903 of file StlVectorTest.cpp.

#define GEN_LOOPER	(	r,
		d,
		arg
	)	BOOST_PP_CAT(LOOPER_, arg)

Definition at line 895 of file StlVectorTest.cpp.

#define GEN_RUNNABLE_TEST	(	r,
		name,
		type
	)	one = test_I_##name##3 < type > () \|\| one;

Definition at line 892 of file StlVectorTest.cpp.

#define GEN_TEST	(	r,
		name,
		type
	)

Value:

{                                                               \
    string atype = PrettyType<typename type::allocator_type>()(); \
    string ptype = PrettyType<typename type::value_type>()();     \
    SCOPED_TRACE("allocator: " + atype);                          \
    {                                                             \
      SCOPED_TRACE("datatype: " + ptype);                         \
      {                                                           \
        test_##name##3 < type > ();                               \
        if (::testing::Test::HasFatalFailure())                   \
          return;                                                 \
      }                                                           \
    }                                                             \
  }

Definition at line 875 of file StlVectorTest.cpp.

#define GEN_TYPE_TEST	(	r,
		name,
		type
	)

Value:

if (0) \

test_I_##name##3 < type > ();

type

PskType type

Definition: ClientProtocol.cpp:777

name

const char * name

Definition: http_parser.c:437

Definition at line 889 of file StlVectorTest.cpp.

#define GEN_UMAKER	(	r,
		d,
		arg
	)

Value:

}                           \
  BOOST_PP_CAT(UMAKER_, arg)  \
  }

Definition at line 899 of file StlVectorTest.cpp.

#define GEN_VMAKER	(	r,
		d,
		arg
	)

Value:

{ \

BOOST_PP_CAT(VMAKER_, arg) {

Definition at line 896 of file StlVectorTest.cpp.

#define IBOOST_PP_VARIADIC_SIZE ( ... )

Value:

IBOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__,   \
  64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, \
  45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, \
  26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8,   \
  7, 6, 5, 4, 3, 2, 1,)

Definition at line 858 of file StlVectorTest.cpp.

#define IBOOST_PP_VARIADIC_SIZE_I	(	e0,
		e1,
		e2,
		e3,
		e4,
		e5,
		e6,
		e7,
		e8,
		e9,
		e10,
		e11,
		e12,
		e13,
		e14,
		e15,
		e16,
		e17,
		e18,
		e19,
		e20,
		e21,
		e22,
		e23,
		e24,
		e25,
		e26,
		e27,
		e28,
		e29,
		e30,
		e31,
		e32,
		e33,
		e34,
		e35,
		e36,
		e37,
		e38,
		e39,
		e40,
		e41,
		e42,
		e43,
		e44,
		e45,
		e46,
		e47,
		e48,
		e49,
		e50,
		e51,
		e52,
		e53,
		e54,
		e55,
		e56,
		e57,
		e58,
		e59,
		e60,
		e61,
		e62,
		e63,
		size,
		...
	)	size

Definition at line 863 of file StlVectorTest.cpp.

#define IBOOST_PP_VARIADIC_TO_SEQ ( ... ) BOOST_PP_TUPLE_TO_SEQ(IBOOST_PP_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__))

Definition at line 869 of file StlVectorTest.cpp.

#define INTERFACE_TYPES

Value:

(_TVI)(VECTOR_<DD1>)(VECTOR_<DD2>)(VECTOR_<DD3>) \
  (VECTOR_<DD4>)(VECTOR_<DD5>)(VECTOR_<DD6>) \
  (VECTOR_<DD7>)(_TSpecialMA)

Definition at line 1024 of file StlVectorTest.cpp.

#define LOOPER_a for (const auto& a_ss : VectorSizes) {

Definition at line 1266 of file StlVectorTest.cpp.

#define LOOPER_b for (int b_i = -2; b_i < (int)VectorSizes.size(); ++b_i) {

Definition at line 1280 of file StlVectorTest.cpp.

#define LOOPER_i

Definition at line 1324 of file StlVectorTest.cpp.

#define LOOPER_j for (int j_i = 0; j_i < 12; ++j_i) {

Definition at line 1332 of file StlVectorTest.cpp.

#define LOOPER_m

Value:

int m_max = 1 + (a_p != nullptr); \

for (int m_i = 0; m_i < m_max; ++m_i) {

Definition at line 1432 of file StlVectorTest.cpp.

#define LOOPER_n for (int n : nSizes) {

Definition at line 1310 of file StlVectorTest.cpp.

#define LOOPER_p for (int p_i = 0; p_i < 4; ++p_i) {

Definition at line 1386 of file StlVectorTest.cpp.

#define LOOPER_q for (int q_i = p_i; q_i < 4; ++q_i) {

Definition at line 1396 of file StlVectorTest.cpp.

#define LOOPER_t for (int t_v : tVals) {

Definition at line 1411 of file StlVectorTest.cpp.

#define LOOPER_ticks

Value:

int _maxTicks_ = 0;        \
  bool ticks_thrown = false; \
  for (int ticks = -1; ticks < _maxTicks_; ++ticks) {

Definition at line 1167 of file StlVectorTest.cpp.

#define LOOPER_z

Value:

Vector* a_p = nullptr; \
  Vector* b_p = nullptr; \
  typename Vector::value_type* t_p = nullptr;

Definition at line 1141 of file StlVectorTest.cpp.

#define MAKE_TEST	(	ref,
		name,
		types,
		restriction,
		argseq,
		...
	)

Definition at line 909 of file StlVectorTest.cpp.

#define SETUP hardReset();

Definition at line 1131 of file StlVectorTest.cpp.

#define STL_TEST	(	ref,
		name,
		restriction,
		...
	)	STL_TEST_I(ref, name, restriction, z, ##__VA_ARGS__, ticks)

Definition at line 980 of file StlVectorTest.cpp.

Referenced by insertItCheck(), insertNTCheck(), test_I_assignIL3(), test_I_assignRange3(), test_I_copyWithAllocator3(), test_I_forwardIteratorAllocConstruction3(), test_I_forwardIteratorConstruction3(), test_iteratorEmplacement3(), test_iteratorErase3(), test_iteratorInsertion3(), test_iteratorInsertionIterator3(), test_iteratorInsertionRV3(), test_moveConstructionWithAllocator3(), test_nCopyAllocConstruction3(), test_nCopyConstruction3(), and test_nonmemberSwappable3().

#define STL_TEST_I	(	ref,
		name,
		restriction,
		...
	)

Value:

DECL(name, __VA_ARGS__);                      \
  MAKE_TEST(                                    \
      ref,                                      \
      name,                                     \
      TEST_TYPES,                               \
      restriction,                              \
      IBOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__),   \
      __VA_ARGS__)                              \
  DECL(name, __VA_ARGS__)

Definition at line 969 of file StlVectorTest.cpp.

#define TEARDOWN

Definition at line 1132 of file StlVectorTest.cpp.

#define TEST_TYPES (_TVIS)(_TVI)(_TV1)(_TV2)(_TV3)(_TV4)(_TV5v1)(_TV5)(_TP1)(_TP2)(_TP3)

Definition at line 1009 of file StlVectorTest.cpp.

#define TYPIFY	(	r,
		d,
		name
	)	BOOST_PP_CAT(TYPIFY_, name)

Definition at line 905 of file StlVectorTest.cpp.

#define TYPIFY_a Vector&

Definition at line 1265 of file StlVectorTest.cpp.

#define TYPIFY_b Vector&

Definition at line 1279 of file StlVectorTest.cpp.

#define TYPIFY_i int*

Definition at line 1323 of file StlVectorTest.cpp.

#define TYPIFY_j int*

Definition at line 1331 of file StlVectorTest.cpp.

#define TYPIFY_m typename Vector::allocator_type

Definition at line 1431 of file StlVectorTest.cpp.

#define TYPIFY_n int

Definition at line 1309 of file StlVectorTest.cpp.

#define TYPIFY_p typename Vector::iterator

Definition at line 1385 of file StlVectorTest.cpp.

#define TYPIFY_q typename Vector::iterator

Definition at line 1395 of file StlVectorTest.cpp.

#define TYPIFY_t typename Vector::value_type&

Definition at line 1410 of file StlVectorTest.cpp.

#define TYPIFY_ticks int

Definition at line 1166 of file StlVectorTest.cpp.

#define TYPIFY_z std::nullptr_t

Definition at line 1140 of file StlVectorTest.cpp.

#define UMAKER_a

Value:

verify(0, a);                           \
  if (::testing::Test::HasFatalFailure()) \
    return;

Definition at line 1273 of file StlVectorTest.cpp.

#define UMAKER_b

Value:

verify(0, a, b);                        \
  if (::testing::Test::HasFatalFailure()) \
    return;

Definition at line 1298 of file StlVectorTest.cpp.

#define UMAKER_i

Definition at line 1328 of file StlVectorTest.cpp.

#define UMAKER_j

Value:

for (int j_c = 0; j_c < 12; ++j_c) \

ASSERT_EQ(ijarC[j_c], ijarr[j_c]);

ijarC

static int ijarC[12]

Definition: StlVectorTest.cpp:1321

ASSERT_EQ

#define ASSERT_EQ(val1, val2)

Definition: gtest.h:1956

ijarr

static int ijarr[12]

Definition: StlVectorTest.cpp:1320

Definition at line 1337 of file StlVectorTest.cpp.

#define UMAKER_m

Definition at line 1438 of file StlVectorTest.cpp.

#define UMAKER_n

Definition at line 1314 of file StlVectorTest.cpp.

#define UMAKER_p

Definition at line 1392 of file StlVectorTest.cpp.

#define UMAKER_q

Definition at line 1402 of file StlVectorTest.cpp.

#define UMAKER_t

Definition at line 1425 of file StlVectorTest.cpp.

#define UMAKER_ticks

Value:

_maxTicks_ = Ticker::CountTicks;                                    \
  }                                                                   \
  catch (const TickException&) {                                      \
    ticks_thrown = true;                                              \
  }                                                                   \
  catch (const std::exception& e) {                                   \
    FAIL() << "EXCEPTION: " << e.what();                              \
  }                                                                   \
  catch (...) {                                                       \
    FAIL() << "UNKNOWN EXCEPTION";                                    \
  }                                                                   \
  if (ticks >= 0 && Ticker::CountTicks > ticks && !ticks_thrown)      \
    FAIL() << "CountTicks = " << Ticker::CountTicks << " > " << ticks \
           << " = ticks"                                              \
           << ", but no tick error was observed";                     \
  VERIFICATION

Definition at line 1180 of file StlVectorTest.cpp.

#define UMAKER_z

Value:

verify<Vector>(0);                        \
  if (::testing::Test::HasFatalFailure()) { \
    return;                                 \
  }

Definition at line 1146 of file StlVectorTest.cpp.

#define VECTOR_ folly::fbvector

Definition at line 166 of file StlVectorTest.cpp.

#define VERIFICATION

Value:

if (b_p != nullptr)                     \
    verify(t_p != nullptr, *a_p, *b_p);   \
  else if (a_p != nullptr)                \
    verify(t_p != nullptr, *a_p);         \
  else                                    \
    verify<Vector>(t_p != nullptr);       \
  if (::testing::Test::HasFatalFailure()) \
    return;

Definition at line 1156 of file StlVectorTest.cpp.

#define VMAKER_a

Value:

Vector a(allocGen<typename Vector::allocator_type>::get());               \
  a_p = &a;                                                                 \
  populate(*a_p, a_ss);                                                     \
  string a_st = folly::to<string>("a (", a.size(), "/", a.capacity(), ")"); \
  SCOPED_TRACE(a_st);

Definition at line 1267 of file StlVectorTest.cpp.

#define VMAKER_b

Value:

Vector b_s(allocGen<typename Vector::allocator_type>::get());            \
  b_p = &b_s;                                                              \
  string b_st;                                                             \
  if (b_i == -2) {                                                         \
    b_p = &a;                                                              \
    b_st = "b is an alias of a";                                           \
  } else if (b_i == -1) {                                                  \
    b_s.~Vector();                                                         \
    new (&b_s) Vector(a);                                                  \
    b_st = "b is a deep copy of a";                                        \
  } else {                                                                 \
    populate(b_s, VectorSizes[b_i]);                                       \
    b_st = folly::to<string>("b (", b_s.size(), "/", b_s.capacity(), ")"); \
  }                                                                        \
  Vector& b = *b_p;                                                        \
  SCOPED_TRACE(b_st);

Definition at line 1281 of file StlVectorTest.cpp.

#define VMAKER_i

Value:

int* i = ijarr; \

SCOPED_TRACE("i = fib[0]");

Definition: gtest_output_test_golden_lin.txt:83

SCOPED_TRACE

#define SCOPED_TRACE(message)

Definition: gtest.h:2115

ijarr

static int ijarr[12]

Definition: StlVectorTest.cpp:1320

Definition at line 1325 of file StlVectorTest.cpp.

#define VMAKER_j

Value:

int* j = ijarr + j_i;                                  \
  string j_st = folly::to<string>("j = fib[", j_i, "]"); \
  SCOPED_TRACE(j_st);

Definition at line 1333 of file StlVectorTest.cpp.

#define VMAKER_m

Value:

typename Vector::allocator_type m = \

m_i == 0 ? typename Vector::allocator_type() : a_p->get_allocator();

static map< string, int > m

Definition: StringKeyedBenchmark.cpp:46

Definition at line 1435 of file StlVectorTest.cpp.

#define VMAKER_n

Value:

string n_st = folly::to<string>("n = ", n); \

SCOPED_TRACE(n_st);

SCOPED_TRACE

#define SCOPED_TRACE(message)

Definition: gtest.h:2115

Definition at line 1311 of file StlVectorTest.cpp.

#define VMAKER_p

Value:

auto p_im = iterSpotter(a, p_i); \
  auto& p = p_im.first;            \
  auto& p_m = p_im.second;         \
  SCOPED_TRACE("p = " + p_m);

Definition at line 1387 of file StlVectorTest.cpp.

#define VMAKER_q

Value:

auto q_im = iterSpotter(a, q_i); \
  auto& q = q_im.first;            \
  auto& q_m = q_im.second;         \
  SCOPED_TRACE("q = " + q_m);

Definition at line 1397 of file StlVectorTest.cpp.

#define VMAKER_t

Value:

typename Vector::value_type t_s(t_v);            \
  t_p = addressof(t_s);                            \
  string t_st = folly::to<string>("t(", t_v, ")"); \
  if (t_v < 4 && a_p != nullptr) {                 \
    auto t_im = iterSpotter(*a_p, t_v);            \
    if (t_im.first != a_p->end()) {                \
      t_p = addressof(*t_im.first);                \
      t_st = "t is " + t_im.second;                \
    }                                              \
  }                                                \
  typename Vector::value_type& t = *t_p;           \
  SCOPED_TRACE(t_st);

Definition at line 1412 of file StlVectorTest.cpp.

#define VMAKER_ticks

Value:

string ticks_st = folly::to<string>("ticks = ", ticks); \
  SCOPED_TRACE(ticks_st);                                 \
  {                                                       \
    SCOPED_TRACE("pre-run verification");                 \
    VERIFICATION                                          \
  }                                                       \
  try {                                                   \
    softReset(ticks);

Definition at line 1171 of file StlVectorTest.cpp.

#define VMAKER_z std::nullptr_t z = nullptr;

Definition at line 1145 of file StlVectorTest.cpp.

Typedef Documentation

typedef folly::fbvector<EP1, Alloc<EP1> > _TP1

Definition at line 1005 of file StlVectorTest.cpp.

typedef folly::fbvector<EP2, Alloc<EP2> > _TP2

Definition at line 1006 of file StlVectorTest.cpp.

typedef folly::fbvector<EP3, Alloc<EP3> > _TP3

Definition at line 1007 of file StlVectorTest.cpp.

typedef folly::fbvector<DDSMA, Alloc<DDSMA> > _TSpecialMA

Definition at line 1021 of file StlVectorTest.cpp.

typedef folly::fbvector<ED1, std::allocator<ED1> > _TV1

Definition at line 994 of file StlVectorTest.cpp.

typedef folly::fbvector<ED2, std::allocator<ED2> > _TV2

Definition at line 995 of file StlVectorTest.cpp.

typedef folly::fbvector<ED3, std::allocator<ED3> > _TV3

Definition at line 996 of file StlVectorTest.cpp.

typedef folly::fbvector<ED4, std::allocator<ED4> > _TV4

Definition at line 997 of file StlVectorTest.cpp.

typedef folly::fbvector<ED5, Alloc<ED5> > _TV5

Definition at line 999 of file StlVectorTest.cpp.

typedef folly::fbvector<ED5, std::allocator<ED5> > _TV5v1

Definition at line 998 of file StlVectorTest.cpp.

typedef folly::fbvector<int, Alloc<int> > _TVI

Definition at line 993 of file StlVectorTest.cpp.

typedef folly::fbvector<int, std::allocator<int> > _TVIS

Definition at line 992 of file StlVectorTest.cpp.

typedef Data<ALL_DELETE> DD1

Definition at line 1012 of file StlVectorTest.cpp.

typedef Data<DC_DELETE | CC_DELETE | MC_DELETE> DD2

Definition at line 1013 of file StlVectorTest.cpp.

typedef Data<CA_DELETE | MA_DELETE> DD3

Definition at line 1014 of file StlVectorTest.cpp.

typedef Data<CC_DELETE | MC_DELETE> DD4

Definition at line 1015 of file StlVectorTest.cpp.

typedef Data<ALL_DELETE & ~DC_DELETE> DD5

Definition at line 1016 of file StlVectorTest.cpp.

typedef Data<CC_DELETE> DD6

Definition at line 1017 of file StlVectorTest.cpp.

typedef Data<CA_DELETE> DD7

Definition at line 1018 of file StlVectorTest.cpp.

typedef Data<ALL_DELETE | PROP_MOVE> DDSMA

Definition at line 1020 of file StlVectorTest.cpp.

typedef Data ED1

Definition at line 986 of file StlVectorTest.cpp.

typedef Data<0, 4080> ED2

Definition at line 987 of file StlVectorTest.cpp.

typedef Data<MC_NOEXCEPT> ED3

Definition at line 988 of file StlVectorTest.cpp.

typedef Data<MC_NOEXCEPT | CC_DELETE> ED4

Definition at line 989 of file StlVectorTest.cpp.

typedef Data<IS_RELOCATABLE> ED5

Definition at line 990 of file StlVectorTest.cpp.

typedef Data<PROP_COPY> EP1

Definition at line 1001 of file StlVectorTest.cpp.

typedef Data<PROP_MOVE> EP2

Definition at line 1002 of file StlVectorTest.cpp.

typedef Data<PROP_SWAP> EP3

Definition at line 1003 of file StlVectorTest.cpp.

typedef uint32_t Flags

Definition at line 211 of file StlVectorTest.cpp.

Enumeration Type Documentation

enum FlagVals : Flags

Enumerator
DC_NOEXCEPT
DC_THROW
DC_DELETE
CC_NOEXCEPT
CC_THROW
CC_DELETE
MC_NOEXCEPT
MC_THROW
MC_DELETE
OC_NOEXCEPT
OC_THROW
CA_NOEXCEPT
CA_THROW
CA_DELETE
MA_NOEXCEPT
MA_THROW
MA_DELETE
ALL_DELETE
IS_RELOCATABLE
PROP_COPY
PROP_MOVE
PROP_SWAP

Definition at line 223 of file StlVectorTest.cpp.

               : Flags {
   DC_NOEXCEPT = 0x1,
   DC_THROW = 0x2,
   DC_DELETE = 0x8000,
   CC_NOEXCEPT = 0x4,
   CC_THROW = 0x8,
   CC_DELETE = 0x10000,
   MC_NOEXCEPT = 0x10,
   MC_THROW = 0x20,
   MC_DELETE = 0x20000,
   OC_NOEXCEPT = 0x40,
   OC_THROW = 0x80,
   // OC_DELETE - DNE
 
   CA_NOEXCEPT = 0x100,
   CA_THROW = 0x200,
   CA_DELETE = 0x40000,
   MA_NOEXCEPT = 0x400,
   MA_THROW = 0x800,
   MA_DELETE = 0x80000,
 
   ALL_DELETE = DC_DELETE | CC_DELETE | MC_DELETE | CA_DELETE | MA_DELETE,
 
   IS_RELOCATABLE = 0x2000,
 
   // for the allocator
   PROP_COPY = 0x100000,
   PROP_MOVE = 0x200000,
   PROP_SWAP = 0x400000,
 };

Function Documentation

int convertToInt ( int t )

Definition at line 1528 of file StlVectorTest.cpp.

References folly::pushmi::detail::t.

Referenced by DataState< Vector >::DataState(), eraseCheck(), insertItCheck(), insertNTCheck(), test_I_assignIL3(), test_I_assignInputRange3(), test_I_assignN3(), test_I_assignRange3(), test_I_copyAssign3(), test_I_emplaceBack3(), test_I_forwardIteratorConstruction3(), test_ilAssignment3(), test_ilConstruction3(), test_inputIteratorConstruction3(), test_iteratorInsertion3(), test_iteratorInsertionN3(), test_iteratorInsertionRV3(), test_memberSwappable3(), test_nCopyConstruction3(), test_nonmemberSwappable3(), test_popBack3(), test_populate3(), test_pushBack3(), test_pushBackRV3(), test_resize3(), and test_resizeT3().

                         {
   return t;
 }

template<Flags f, size_t pad>

int convertToInt ( const Data< f, pad > & t )

Definition at line 1532 of file StlVectorTest.cpp.

                                         {
   return t.uid;
 }

template<typename T >

int convertToInt ( const std::allocator< T > & )

Definition at line 1536 of file StlVectorTest.cpp.

                                          {
   return -1;
 }

template<typename T >

int convertToInt ( const Alloc< T > & a )

Definition at line 1540 of file StlVectorTest.cpp.

References Alloc< T >::id.

                                     {
   return a.id;
 }

template<class Vector >

void eraseCheck	(	Vector &	a,
		DataState< Vector > &	dsa,
		int	idx,
		int	n
	)

Definition at line 2563 of file StlVectorTest.cpp.

References ASSERT_EQ, convertToInt(), i, and DataState< Vector >::size().

Referenced by test_iteratorErase3(), and test_iteratorEraseRange3().

                                                                    {
   ASSERT_EQ(dsa.size() - n, a.size());
   int i = 0;
   auto it = a.begin();
   for (; it != a.end(); ++it, ++i) {
     if (i == idx) {
       i += n;
     }
     ASSERT_EQ(dsa[i], convertToInt(*it));
   }
 }

int getTotal ( )

Definition at line 768 of file StlVectorTest.cpp.

References Counter::CountCC, Counter::CountDC, Counter::CountDestroy, Counter::CountLoggedConstruction, Counter::CountMC, and Counter::CountOC.

Referenced by isSane(), and verify().

                {
   int con = Counter::CountDC + Counter::CountCC + Counter::CountMC +
       Counter::CountOC + Counter::CountLoggedConstruction;
   int del = Counter::CountDestroy;
   return con - del;
 }

void hardReset ( )

Definition at line 755 of file StlVectorTest.cpp.

References AllocTracker::Constructed, Counter::CountLoggedConstruction, AllocTracker::Destroyed, softReset(), and Tracker::UIDTotal.

                  {
   Tracker::UIDCount.clear();
   Tracker::UIDTotal = 0;
   Tracker::Locations.clear();
   softReset();
   Counter::CountLoggedConstruction = 0;
 
   AllocTracker::Constructed = 0;
   AllocTracker::Destroyed = 0;
   AllocTracker::Allocated.clear();
   AllocTracker::Owner.clear();
 }

template<class Vector >

void insertItCheck	(	const Vector &	a,
		DataState< Vector > &	dsa,
		int	idx,
		int *	b,
		int *	e
	)

Definition at line 2451 of file StlVectorTest.cpp.

References a, ASSERT_EQ, b, convertToInt(), i, DataState< Vector >::size(), and STL_TEST.

Referenced by test_iteratorInsertIL3(), test_iteratorInsertionInputIterator3(), and test_iteratorInsertionIterator3().

             {
   ASSERT_EQ(dsa.size() + (e - b), a.size());
   int i = 0;
   for (; i < idx; ++i) {
     ASSERT_EQ(dsa[i], convertToInt(a.data()[i]));
   }
   for (; i < idx + (e - b); ++i) {
     ASSERT_EQ(*(b + i - idx), convertToInt(a.data()[i]));
   }
   for (; size_t(i) < a.size(); ++i) {
     ASSERT_EQ(dsa[i - (e - b)], convertToInt(a.data()[i]));
   }
 }

template<class Vector >

void insertNTCheck	(	const Vector &	a,
		DataState< Vector > &	dsa,
		int	idx,
		int	n,
		int	val
	)

Definition at line 2342 of file StlVectorTest.cpp.

References a, ASSERT_EQ, convertToInt(), i, DataState< Vector >::size(), and STL_TEST.

Referenced by test_iteratorEmplacement3(), test_iteratorInsertion3(), test_iteratorInsertionN3(), and test_iteratorInsertionRV3().

              {
   ASSERT_EQ(dsa.size() + n, a.size());
   int i = 0;
   for (; i < idx; ++i) {
     ASSERT_EQ(dsa[i], convertToInt(a.data()[i])) << i;
   }
   for (; i < idx + n; ++i) {
     ASSERT_EQ(val, convertToInt(a.data()[i])) << i;
   }
   for (; size_t(i) < a.size(); ++i) {
     ASSERT_EQ(dsa[i - n], convertToInt(a.data()[i])) << i;
   }
 }

void isSane ( )

Definition at line 775 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_GE, ASSERT_TRUE, folly::empty(), getTotal(), folly::size(), and Tracker::UIDTotal.

Referenced by folly::basic_fbstring< E, T, A, Storage >::replaceImpl(), folly::basic_fbstring< E, T, A, Storage >::replaceImplDiscr(), and verify().

               {
   int tot = getTotal();
   ASSERT_GE(tot, 0) << "more objects deleted than constructed";
 
   ASSERT_EQ(tot, Tracker::UIDTotal)
       << "UIDTotal has incorrect number of objects";
 
   int altTot = 0;
   for (const auto& kv : Tracker::UIDCount) {
     ASSERT_TRUE(kv.second >= 0) << "there exists " << kv.second
                                 << " Data "
                                    "with uid "
                                 << kv.first;
     altTot += kv.second;
   }
   ASSERT_EQ(tot, altTot) << "UIDCount corrupted";
 
   if (!Tracker::Locations.empty()) { // implied by IsRelocatable
     ASSERT_EQ(tot, Tracker::Locations.size())
         << "Locations has incorrect number of objects";
     for (const auto& du : Tracker::Locations) {
       ASSERT_EQ(du.second, du.first->uid) << "Locations contains wrong uid";
       ASSERT_EQ(du.first, du.first->self) << "Data.self is corrupted";
     }
   }
 }

template<class Vector >

std::pair<typename Vector::iterator, string> iterSpotter	(	Vector &	v,
		int	i
	)

Definition at line 1346 of file StlVectorTest.cpp.

References FOLLY_FALLTHROUGH.

                                                                        {
   typename Vector::iterator it;
   string msg;
 
   switch (i) {
     case 1:
       if (!v.empty()) {
         it = v.begin();
         ++it;
         msg = "a[1]";
         break;
       }
       FOLLY_FALLTHROUGH;
     case 0:
       it = v.begin();
       msg = "a.begin";
       break;
 
     case 2:
       if (!v.empty()) {
         it = v.end();
         --it;
         msg = "a[-1]";
         break;
       }
       FOLLY_FALLTHROUGH;
     case 3:
       it = v.end();
       msg = "a.end";
       break;
 
     default:
       cerr << "internal error" << endl;
       exit(1);
   }
 
   return make_pair(it, msg);
 }

int main	(	int	argc,
		char **	argv
	)

Definition at line 3070 of file StlVectorTest.cpp.

References FOLLY_POP_WARNING, testing::InitGoogleTest(), and RUN_ALL_TESTS().

                                 {
   testing::InitGoogleTest(&argc, argv);
   gflags::ParseCommandLineFlags(&argc, &argv, true);
 
   return RUN_ALL_TESTS();
 }

template<typename It >

Transformer<It, forward_iterator_tag> makeForwardIterator ( const It & it )

Definition at line 1616 of file StlVectorTest.cpp.

Referenced by test_I_assignRange3(), test_I_forwardIteratorAllocConstruction3(), test_I_forwardIteratorConstruction3(), test_iteratorInsertionIterator3(), and test_moveIterators3().

                                                                         {
   return Transformer<It, forward_iterator_tag>(it);
 }

template<typename It >

Transformer<It, input_iterator_tag> makeInputIterator ( const It & it )

Definition at line 1620 of file StlVectorTest.cpp.

Referenced by test_I_assignInputRange3(), test_inputIteratorAllocConstruction3(), test_inputIteratorConstruction3(), test_iteratorInsertionInputIterator3(), and test_moveIterators3().

                                                                     {
   return Transformer<It, input_iterator_tag>(it);
 }

void mutate ( int & i )

Definition at line 1625 of file StlVectorTest.cpp.

Referenced by test_I_at3(), test_I_back3(), test_I_front3(), and test_operatorBrace3().

                     {
   if ((false)) {
     i = 0;
   }
 }

void mutate ( uint64_t & i )

Definition at line 1630 of file StlVectorTest.cpp.

                          {
   if ((false)) {
     i = 0;
   }
 }

template<Flags f, size_t pad>

void mutate ( Data< f, pad > & ds )

Definition at line 1636 of file StlVectorTest.cpp.

                               {
   if ((false)) {
     ds.uid = 0;
   }
 }

template<class Vector >

void populate	(	Vector &	v,
		const pair< int, int > &	ss
	)

Definition at line 1238 of file StlVectorTest.cpp.

References i, and populateIndex.

Referenced by TEST().

                                                    {
   int i = 0;
   for (; i < ss.first; ++i) {
     v.emplace_back(populateIndex++);
   }
   if (ss.second >= 0) {
     while (v.capacity() - v.size() != size_t(ss.second)) {
       v.emplace_back(populateIndex++);
     }
   }
 }

uint64_t ReadTSC ( )

Definition at line 838 of file StlVectorTest.cpp.

References uint64_t.

                    {
 #ifdef _MSC_VER
   return __rdtsc();
 #else
   unsigned reslo, reshi;
 
   __asm__ __volatile__("xorl %%eax,%%eax \n cpuid \n" ::
                            : "%eax", "%ebx", "%ecx", "%edx");
   __asm__ __volatile__("rdtsc\n" : "=a"(reslo), "=d"(reshi));
   __asm__ __volatile__("xorl %%eax,%%eax \n cpuid \n" ::
                            : "%eax", "%ebx", "%ecx", "%edx");
 
   return ((uint64_t)reshi << 32) | reslo;
 #endif
 }

void softReset ( int ticks = -1 )

Definition at line 745 of file StlVectorTest.cpp.

References Counter::CountCA, Counter::CountCC, Counter::CountDC, Counter::CountDestroy, Counter::CountLoggedConstruction, Counter::CountMA, Counter::CountMC, Counter::CountOC, Ticker::CountTicks, Counter::CountTotalOps, and Ticker::TicksLeft.

Referenced by hardReset().

                                {
   Counter::CountLoggedConstruction += Counter::CountDC + Counter::CountCC +
       Counter::CountMC + Counter::CountOC - Counter::CountDestroy;
   Counter::CountDC = Counter::CountCC = Counter::CountMC = Counter::CountOC =
       Counter::CountCA = Counter::CountMA = 0;
   Counter::CountDestroy = Counter::CountTotalOps = 0;
   Ticker::CountTicks = 0;
   Ticker::TicksLeft = ticks;
 }

TEST	(	FBVector	,
		containerTypedefs
	)

Definition at line 1652 of file StlVectorTest.cpp.

1652 {

TEST	(	FBVector	,
		emptyConstruction
	)

Definition at line 1715 of file StlVectorTest.cpp.

1715 {

TEST	(	FBVector	,
		populate
	)

Definition at line 1729 of file StlVectorTest.cpp.

1729 {

TEST	(	FBVector	,
		copyConstruction
	)

Definition at line 1764 of file StlVectorTest.cpp.

1764 {

TEST	(	FBVector	,
		moveConstruction
	)

Definition at line 1785 of file StlVectorTest.cpp.

1785 {

TEST	(	FBVector	,
		moveAssignment
	)

Definition at line 1801 of file StlVectorTest.cpp.

1801 {

TEST	(	FBVector	,
		destructible
	)

Definition at line 1819 of file StlVectorTest.cpp.

1819 {

TEST	(	FBVector	,
		iterators
	)

Definition at line 1823 of file StlVectorTest.cpp.

1823 {

TEST	(	FBVector	,
		equitable
	)

Definition at line 1855 of file StlVectorTest.cpp.

1855 {

TEST	(	FBVector	,
		memberSwappable
	)

Definition at line 1870 of file StlVectorTest.cpp.

1870 {

TEST	(	FBVector	,
		nonmemberSwappable
	)

Definition at line 1903 of file StlVectorTest.cpp.

1903 {

TEST	(	FBVector	,
		copyAssign
	)

Definition at line 1941 of file StlVectorTest.cpp.

1941 {

TEST	(	FBVector	,
		sizeops
	)

Definition at line 1971 of file StlVectorTest.cpp.

1971 {

TEST	(	FBVector	,
		reversibleContainerTypedefs
	)

Definition at line 1978 of file StlVectorTest.cpp.

1978 {

TEST	(	FBVector	,
		reversibleIterators
	)

Definition at line 1992 of file StlVectorTest.cpp.

1992 {

TEST	(	FBVector	,
		comparable
	)

Definition at line 2027 of file StlVectorTest.cpp.

2027 {

TEST	(	FBVector	,
		allocatorTypedefs
	)

Definition at line 2046 of file StlVectorTest.cpp.

2046 {

TEST	(	FBVector	,
		getAllocator
	)

Definition at line 2052 of file StlVectorTest.cpp.

2052 {

TEST	(	FBVector	,
		defaultAllocator
	)

Definition at line 2056 of file StlVectorTest.cpp.

2056 {

TEST	(	FBVector	,
		customAllocator
	)

Definition at line 2060 of file StlVectorTest.cpp.

2060 {

TEST	(	FBVector	,
		copyWithAllocator
	)

Definition at line 2072 of file StlVectorTest.cpp.

2072 {

TEST	(	FBVector	,
		moveConstructionWithAllocator
	)

Definition at line 2090 of file StlVectorTest.cpp.

2090 {

TEST	(	FBVector	,
		moveConstructionWithAllocatorSupplied
	)

Definition at line 2100 of file StlVectorTest.cpp.

2100 {

TEST	(	FBVector	,
		allocAssign
	)

Definition at line 2119 of file StlVectorTest.cpp.

2119 {

TEST	(	FBVector	,
		nAllocConstruction
	)

Definition at line 2123 of file StlVectorTest.cpp.

2123 {

TEST	(	FBVector	,
		nCopyAllocConstruction
	)

Definition at line 2133 of file StlVectorTest.cpp.

2133 {

TEST	(	FBVector	,
		forwardIteratorAllocConstruction
	)

Definition at line 2148 of file StlVectorTest.cpp.

2148 {

TEST	(	FBVector	,
		inputIteratorAllocConstruction
	)

Definition at line 2166 of file StlVectorTest.cpp.

2166 {

TEST	(	FBVector	,
		ilAllocConstruction
	)

Definition at line 2183 of file StlVectorTest.cpp.

2183 {

TEST	(	FBVector	,
		dataRaces
	)

Definition at line 2199 of file StlVectorTest.cpp.

2199 {

TEST	(	FBVector	,
		nConstruction
	)

Definition at line 2223 of file StlVectorTest.cpp.

2223 {

TEST	(	FBVector	,
		nCopyConstruction
	)

Definition at line 2231 of file StlVectorTest.cpp.

2231 {

TEST	(	FBVector	,
		forwardIteratorConstruction
	)

Definition at line 2249 of file StlVectorTest.cpp.

2249 {

TEST	(	FBVector	,
		inputIteratorConstruction
	)

Definition at line 2274 of file StlVectorTest.cpp.

2274 {

TEST	(	FBVector	,
		ilConstruction
	)

Definition at line 2294 of file StlVectorTest.cpp.

2294 {

TEST	(	FBVector	,
		ilAssignment
	)

Definition at line 2314 of file StlVectorTest.cpp.

2314 {

TEST	(	FBVector	,
		iteratorEmplacement
	)

Definition at line 2366 of file StlVectorTest.cpp.

2366 {

TEST	(	FBVector	,
		iteratorInsertion
	)

Definition at line 2384 of file StlVectorTest.cpp.

2384 {

TEST	(	FBVector	,
		iteratorInsertionRV
	)

Definition at line 2404 of file StlVectorTest.cpp.

2404 {

TEST	(	FBVector	,
		iteratorInsertionN
	)

Definition at line 2429 of file StlVectorTest.cpp.

2429 {

TEST	(	FBVector	,
		iteratorInsertionIterator
	)

Definition at line 2477 of file StlVectorTest.cpp.

2477 {

TEST	(	FBVector	,
		iteratorInsertionInputIterator
	)

Definition at line 2508 of file StlVectorTest.cpp.

2508 {

TEST	(	FBVector	,
		iteratorInsertIL
	)

Definition at line 2532 of file StlVectorTest.cpp.

2532 {

TEST	(	FBVector	,
		iteratorErase
	)

Definition at line 2575 of file StlVectorTest.cpp.

2575 {

TEST	(	FBVector	,
		iteratorEraseRange
	)

Definition at line 2597 of file StlVectorTest.cpp.

2597 {

TEST	(	FBVector	,
		clear
	)

Definition at line 2616 of file StlVectorTest.cpp.

2616 {

TEST	(	FBVector	,
		assignRange
	)

Definition at line 2629 of file StlVectorTest.cpp.

2629 {

TEST	(	FBVector	,
		assignInputRange
	)

Definition at line 2651 of file StlVectorTest.cpp.

2651 {

TEST	(	FBVector	,
		assignIL
	)

Definition at line 2667 of file StlVectorTest.cpp.

2667 {

TEST	(	FBVector	,
		assignN
	)

Definition at line 2696 of file StlVectorTest.cpp.

2696 {

TEST	(	FBVector	,
		front
	)

Definition at line 2710 of file StlVectorTest.cpp.

2710 {

TEST	(	FBVector	,
		back
	)

Definition at line 2726 of file StlVectorTest.cpp.

2726 {

TEST	(	FBVector	,
		emplaceBack
	)

Definition at line 2742 of file StlVectorTest.cpp.

2742 {

TEST	(	FBVector	,
		pushBack
	)

Definition at line 2768 of file StlVectorTest.cpp.

2768 {

TEST	(	FBVector	,
		pushBackRV
	)

Definition at line 2796 of file StlVectorTest.cpp.

2796 {

TEST	(	FBVector	,
		popBack
	)

Definition at line 2823 of file StlVectorTest.cpp.

2823 {

TEST	(	FBVector	,
		operatorBrace
	)

Definition at line 2842 of file StlVectorTest.cpp.

2842 {

TEST	(	FBVector	,
		at
	)

Definition at line 2855 of file StlVectorTest.cpp.

2855 {

TEST	(	FBVector	,
		moveIterators
	)

Definition at line 2876 of file StlVectorTest.cpp.

2876 {

TEST	(	FBVector	,
		dataAndCapacity
	)

Definition at line 2900 of file StlVectorTest.cpp.

2900 {

TEST	(	FBVector	,
		reserve
	)

Definition at line 2906 of file StlVectorTest.cpp.

2906 {

TEST	(	FBVector	,
		lengthError
	)

Definition at line 2923 of file StlVectorTest.cpp.

2923 {

TEST	(	FBVector	,
		resize
	)

Definition at line 2940 of file StlVectorTest.cpp.

2940 {

TEST	(	FBVector	,
		resizeT
	)

Definition at line 2961 of file StlVectorTest.cpp.

2961 {

TEST	(	FBVector	,
		shrinkToFit
	)

Definition at line 2993 of file StlVectorTest.cpp.

2993 {

TEST	(	FBVector	,
		ebo
	)

Definition at line 3020 of file StlVectorTest.cpp.

3020 {

TEST	(	FBVector	,
		relinquish
	)

Definition at line 3027 of file StlVectorTest.cpp.

3027 {

TEST	(	FBVector	,
		attach
	)

Definition at line 3053 of file StlVectorTest.cpp.

3053 {

template<class Vector , typename T , typename Allocator >

void test_allocAssign ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2119 of file StlVectorTest.cpp.

                                                               {
   // there is nothing new to test here
 }

template<class Vector >

void test_allocAssign2 ( std::false_type )

Definition at line 2119 of file StlVectorTest.cpp.

2119 {

template<class Vector >

void test_allocAssign2 ( std::true_type )

Definition at line 2119 of file StlVectorTest.cpp.

2119 {

template<class Vector >

void test_allocAssign3 ( )

Definition at line 2119 of file StlVectorTest.cpp.

2119 {

template<class Vector , typename T , typename Allocator >

void test_allocatorTypedefs ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2046 of file StlVectorTest.cpp.

                                                                   {
   static_assert(
       is_same<T, typename Vector::allocator_type::value_type>::value,
       "Vector and vector's allocator value_type mismatch");
 }

template<class Vector >

void test_allocatorTypedefs2 ( std::false_type )

Definition at line 2046 of file StlVectorTest.cpp.

2046 {

template<class Vector >

void test_allocatorTypedefs2 ( std::true_type )

Definition at line 2046 of file StlVectorTest.cpp.

2046 {

template<class Vector >

void test_allocatorTypedefs3 ( )

Definition at line 2046 of file StlVectorTest.cpp.

2046 {

template<class Vector , typename T , typename Allocator >

void test_assignIL ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2667 of file StlVectorTest.cpp.

                                                             {
   // whitebox: ensure that assign(il) is implemented in terms of
   // assign(il.begin(), il.end())
 
   // gcc fail
   if (Ticker::TicksLeft >= 0) {
     return;
   }
 
   auto am = a.get_allocator();
 
   a.assign({1, 4, 7});
 
   ASSERT_TRUE(am == a.get_allocator());
   int ila[] = {1, 4, 7};
   int* i = ila;
 
   ASSERT_EQ(3, a.size());
   for (auto it = a.begin(); it != a.end(); ++it, ++i) {
     ASSERT_EQ(*i, convertToInt(*it));
   }
 }

template<class Vector >

void test_assignIL2 ( std::false_type )

Definition at line 2667 of file StlVectorTest.cpp.

2667 {

template<class Vector >

void test_assignIL2 ( std::true_type )

Definition at line 2667 of file StlVectorTest.cpp.

2667 {

template<class Vector >

void test_assignIL3 ( )

Definition at line 2667 of file StlVectorTest.cpp.

2667 {

template<class Vector , typename T , typename Allocator >

void test_assignInputRange ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a,i,j, ticks)))) )

Definition at line 2651 of file StlVectorTest.cpp.

        {
   auto ii = makeInputIterator(i);
   auto ij = makeInputIterator(j);
   const auto& cii = ii;
   const auto& cij = ij;
   auto am = a.get_allocator();
 
   a.assign(cii, cij);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(distance(i, j), a.size());
   for (auto it = a.begin(); it != a.end(); ++it, ++i) {
     ASSERT_EQ(*i, convertToInt(*it));
   }
 }

template<class Vector >

void test_assignInputRange2 ( std::false_type )

Definition at line 2651 of file StlVectorTest.cpp.

2651 {

template<class Vector >

void test_assignInputRange2 ( std::true_type )

Definition at line 2651 of file StlVectorTest.cpp.

2651 {

template<class Vector >

void test_assignInputRange3 ( )

Definition at line 2651 of file StlVectorTest.cpp.

2651 {

template<class Vector , typename T , typename Allocator >

void test_assignN ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a,n,t, ticks)))) )

Definition at line 2696 of file StlVectorTest.cpp.

        {
   auto am = a.get_allocator();
   auto const& ct = t;
   auto tval = convertToInt(t);
 
   a.assign(n, ct);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(n, a.size());
   for (auto it = a.begin(); it != a.end(); ++it) {
     ASSERT_EQ(tval, convertToInt(*it));
   }
 }

template<class Vector >

void test_assignN2 ( std::false_type )

Definition at line 2696 of file StlVectorTest.cpp.

2696 {

template<class Vector >

void test_assignN2 ( std::true_type )

Definition at line 2696 of file StlVectorTest.cpp.

2696 {

template<class Vector >

void test_assignN3 ( )

Definition at line 2696 of file StlVectorTest.cpp.

2696 {

template<class Vector , typename T , typename Allocator >

void test_assignRange ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, i, j, ticks)))) )

Definition at line 2629 of file StlVectorTest.cpp.

                                                                           {
   auto fi = makeForwardIterator(i);
   auto fj = makeForwardIterator(j);
   const auto& cfi = fi;
   const auto& cfj = fj;
   auto am = a.get_allocator();
 
   a.assign(cfi, cfj);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(distance(i, j), a.size());
   for (auto it = a.begin(); it != a.end(); ++it, ++i) {
     ASSERT_EQ(*i, convertToInt(*it));
   }
 }

template<class Vector >

void test_assignRange2 ( std::false_type )

Definition at line 2629 of file StlVectorTest.cpp.

2629 {

template<class Vector >

void test_assignRange2 ( std::true_type )

Definition at line 2629 of file StlVectorTest.cpp.

2629 {

template<class Vector >

void test_assignRange3 ( )

Definition at line 2629 of file StlVectorTest.cpp.

2629 {

template<class Vector , typename T , typename Allocator >

void test_at ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2855 of file StlVectorTest.cpp.

                                                         {
   const auto& ca = a;
   for (size_t i = 0; i < ca.size(); ++i) {
     ASSERT_TRUE(addressof(ca.at(i)) == ca.data() + i);
   }
 
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   try {
     ca.at(ca.size());
     FAIL() << "at(size) should have thrown an error";
   } catch (const std::out_of_range& e) {
   } catch (...) {
     FAIL() << "at(size) threw error other than out_of_range";
   }
 
   if (false) {
     mutate(a.at(0));
   }
 }

template<class Vector >

void test_at2 ( std::false_type )

Definition at line 2855 of file StlVectorTest.cpp.

2855 {

template<class Vector >

void test_at2 ( std::true_type )

Definition at line 2855 of file StlVectorTest.cpp.

2855 {

template<class Vector >

void test_at3 ( )

Definition at line 2855 of file StlVectorTest.cpp.

2855 {

template<class Vector , typename T , typename Allocator >

void test_attach ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 3053 of file StlVectorTest.cpp.

                                                {
   DataState<Vector> dsa(a);
 
   auto sz = a.size();
   auto cap = a.capacity();
   auto guts = relinquish(a);
 
   ASSERT_EQ(a.data(), nullptr);
   attach(a, guts, sz, cap);
 
   ASSERT_TRUE(dsa == a);
 }

template<class Vector >

void test_attach2 ( std::false_type )

Definition at line 3053 of file StlVectorTest.cpp.

3053 {

template<class Vector >

void test_attach2 ( std::true_type )

Definition at line 3053 of file StlVectorTest.cpp.

3053 {

template<class Vector >

void test_attach3 ( )

Definition at line 3053 of file StlVectorTest.cpp.

3053 {

template<class Vector , typename T , typename Allocator >

void test_back ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2726 of file StlVectorTest.cpp.

                                                          {
   if (a.empty()) {
     return;
   }
 
   ASSERT_TRUE(addressof(a.back()) == a.data() + a.size() - 1);
 
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   if (false) {
     mutate(a.back());
     const Vector& ca = a;
     ca.back();
   }
 }

template<class Vector >

void test_back2 ( std::false_type )

Definition at line 2726 of file StlVectorTest.cpp.

2726 {

template<class Vector >

void test_back2 ( std::true_type )

Definition at line 2726 of file StlVectorTest.cpp.

2726 {

template<class Vector >

void test_back3 ( )

Definition at line 2726 of file StlVectorTest.cpp.

2726 {

template<class Vector , typename T , typename Allocator >

void test_clear ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2616 of file StlVectorTest.cpp.

                                                            {
   auto am = a.get_allocator();
 
   try {
     a.clear();
   } catch (...) {
     FAIL() << "clear must be noexcept";
   }
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_TRUE(a.empty());
 }

template<class Vector >

void test_clear2 ( std::false_type )

Definition at line 2616 of file StlVectorTest.cpp.

2616 {

template<class Vector >

void test_clear2 ( std::true_type )

Definition at line 2616 of file StlVectorTest.cpp.

2616 {

template<class Vector >

void test_clear3 ( )

Definition at line 2616 of file StlVectorTest.cpp.

2616 {

template<class Vector , typename T , typename Allocator >

void test_comparable ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2027 of file StlVectorTest.cpp.

                                                        {
   const Vector v1 = {1, 2, 3, 4};
   const Vector v2 = {1, 2, 3, 4, 5};
   const Vector v3 = {1, 2, 2};
   const Vector v4 = {1, 2, 2, 4, 5};
   const Vector v5 = {};
   const Vector v6 = {1, 2, 3, 4};
 
   ASSERT_TRUE(v1 < v2);
   ASSERT_TRUE(v1 > v3);
   ASSERT_TRUE(v1 > v4);
   ASSERT_TRUE(v1 > v5);
   ASSERT_TRUE(v1 <= v6);
   ASSERT_TRUE(v1 >= v6);
 }

template<class Vector >

void test_comparable2 ( std::false_type )

Definition at line 2027 of file StlVectorTest.cpp.

2027 {

template<class Vector >

void test_comparable2 ( std::true_type )

Definition at line 2027 of file StlVectorTest.cpp.

2027 {

template<class Vector >

void test_comparable3 ( )

Definition at line 2027 of file StlVectorTest.cpp.

2027 {

template<class Vector , typename T , typename Allocator >

void test_containerTypedefs ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 1652 of file StlVectorTest.cpp.

                                                                     {
   static_assert(
       is_same<T, typename Vector::value_type>::value,
       "T != Vector::value_type");
   static_assert(
       is_same<T&, typename Vector::reference>::value,
       "T& != Vector::reference");
   static_assert(
       is_same<const T&, typename Vector::const_reference>::value,
       "const T& != Vector::const_reference");
   static_assert(
       is_convertible<
           typename iterator_traits<
               typename Vector::iterator>::iterator_category,
           forward_iterator_tag>::value,
       "Vector::iterator is not a forward iterator");
   static_assert(
       is_same<
           T,
           typename iterator_traits<typename Vector::iterator>::value_type>::
           value,
       "Vector::iterator does not iterate over type T");
   static_assert(
       is_convertible<
           typename iterator_traits<
               typename Vector::const_iterator>::iterator_category,
           forward_iterator_tag>::value,
       "Vector::const_iterator is not a forward iterator");
   static_assert(
       is_same<
           T,
           typename iterator_traits<
               typename Vector::const_iterator>::value_type>::value,
       "Vector::const_iterator does not iterate over type T");
   static_assert(
       is_convertible<
           typename Vector::iterator,
           typename Vector::const_iterator>::value,
       "Vector::iterator is not convertible to Vector::const_iterator");
   static_assert(
       is_signed<typename Vector::difference_type>::value,
       "Vector::difference_type is not signed");
   static_assert(
       is_same<
           typename Vector::difference_type,
           typename iterator_traits<
               typename Vector::iterator>::difference_type>::value,
       "Vector::difference_type != Vector::iterator::difference_type");
   static_assert(
       is_same<
           typename Vector::difference_type,
           typename iterator_traits<
               typename Vector::const_iterator>::difference_type>::value,
       "Vector::difference_type != Vector::const_iterator::difference_type");
   static_assert(
       is_unsigned<typename Vector::size_type>::value,
       "Vector::size_type is not unsigned");
   static_assert(
       sizeof(typename Vector::size_type) >=
           sizeof(typename Vector::difference_type),
       "Vector::size_type is smaller than Vector::difference_type");
 }

template<class Vector >

void test_containerTypedefs2 ( std::false_type )

Definition at line 1652 of file StlVectorTest.cpp.

1652 {

template<class Vector >

void test_containerTypedefs2 ( std::true_type )

Definition at line 1652 of file StlVectorTest.cpp.

1652 {

template<class Vector >

void test_containerTypedefs3 ( )

Definition at line 1652 of file StlVectorTest.cpp.

1652 {

template<class Vector , typename T , typename Allocator >

void test_copyAssign ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a,b, ticks)))) )

Definition at line 1941 of file StlVectorTest.cpp.

        {
   // it is possible to make use of just the copy constructor.
 
 #ifdef USING_STD_VECTOR
   if (std::allocator_traits<
           Allocator>::propagate_on_container_copy_assignment::value &&
       convertToInt(a.get_allocator()) != convertToInt(b.get_allocator())) {
     // Bug. By the looks of things, in the above case, their bez is being
     // cleared and deallocated, but then the garbage pointers are being used.
     return;
   }
 #endif
 
   const auto& cb = b;
   DataState<Vector> dsb(cb);
   auto am = a.get_allocator();
   auto bm = b.get_allocator();
 
   Vector& ret = a = cb;
 
   if (std::allocator_traits<
           Allocator>::propagate_on_container_copy_assignment::value) {
     ASSERT_TRUE(bm == a.get_allocator());
   } else {
     ASSERT_TRUE(am == a.get_allocator());
   }
   ASSERT_TRUE(&ret == &a);
   ASSERT_TRUE(dsb == a) << "copy-assign not equal to original";
 }

template<class Vector >

void test_copyAssign2 ( std::false_type )

Definition at line 1941 of file StlVectorTest.cpp.

1941 {

template<class Vector >

void test_copyAssign2 ( std::true_type )

Definition at line 1941 of file StlVectorTest.cpp.

1941 {

template<class Vector >

void test_copyAssign3 ( )

Definition at line 1941 of file StlVectorTest.cpp.

1941 {

template<class Vector , typename T , typename Allocator >

void test_copyConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 1764 of file StlVectorTest.cpp.

                                                                               {
   const auto& ca = a;
   DataState<Vector> dsa(ca);
   auto am = a.get_allocator();
 
   Vector u(ca);
 
   ASSERT_TRUE(
       std::allocator_traits<Allocator>::select_on_container_copy_construction(
           am) == u.get_allocator());
   ASSERT_TRUE(dsa == u);
   ASSERT_TRUE(
       (ca.data() == nullptr && u.data() == nullptr) || (ca.data() != u.data()))
       << "only a shallow copy was made";
 
   if (false) {
     Vector(ca2);
     Vector u2 = ca2;
   }
 }

template<class Vector >

void test_copyConstruction2 ( std::false_type )

Definition at line 1764 of file StlVectorTest.cpp.

1764 {

template<class Vector >

void test_copyConstruction2 ( std::true_type )

Definition at line 1764 of file StlVectorTest.cpp.

1764 {

template<class Vector >

void test_copyConstruction3 ( )

Definition at line 1764 of file StlVectorTest.cpp.

1764 {

template<class Vector , typename T , typename Allocator >

void test_copyWithAllocator ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, m, ticks)))) )

Definition at line 2072 of file StlVectorTest.cpp.

                                                                               {
   DataState<Vector> dsa(a);
   const auto& ca = a;
   const auto& cm = m;
 
   Vector u(ca, cm);
 
   ASSERT_TRUE(u.get_allocator() == m);
   ASSERT_TRUE(dsa == u);
   ASSERT_TRUE(
       (ca.data() == nullptr && u.data() == nullptr) || (ca.data() != u.data()))
       << "only a shallow copy was made";
 }

template<class Vector >

void test_copyWithAllocator2 ( std::false_type )

Definition at line 2072 of file StlVectorTest.cpp.

2072 {

template<class Vector >

void test_copyWithAllocator2 ( std::true_type )

Definition at line 2072 of file StlVectorTest.cpp.

2072 {

template<class Vector >

void test_copyWithAllocator3 ( )

Definition at line 2072 of file StlVectorTest.cpp.

2072 {

template<class Vector , typename T , typename Allocator >

void test_customAllocator ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, m, ticks)))) )

Definition at line 2060 of file StlVectorTest.cpp.

                                                                    {
   const auto& cm = m;
 
   Vector u(cm);
 
   ASSERT_TRUE(u.get_allocator() == m);
 
   if (false) {
     Vector t(m);
   }
 }

template<class Vector >

void test_customAllocator2 ( std::false_type )

Definition at line 2060 of file StlVectorTest.cpp.

2060 {

template<class Vector >

void test_customAllocator2 ( std::true_type )

Definition at line 2060 of file StlVectorTest.cpp.

2060 {

template<class Vector >

void test_customAllocator3 ( )

Definition at line 2060 of file StlVectorTest.cpp.

2060 {

template<class Vector , typename T , typename Allocator >

void test_dataAndCapacity ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2900 of file StlVectorTest.cpp.

                                                        {
   // there isn't anything new to test here - data and capacity are used as the
   // backbone of DataState. The minimal testing we might want to do is already
   // done in the populate test
 }

template<class Vector >

void test_dataAndCapacity2 ( std::false_type )

Definition at line 2900 of file StlVectorTest.cpp.

2900 {

template<class Vector >

void test_dataAndCapacity2 ( std::true_type )

Definition at line 2900 of file StlVectorTest.cpp.

2900 {

template<class Vector >

void test_dataAndCapacity3 ( )

Definition at line 2900 of file StlVectorTest.cpp.

2900 {

template<class Vector , typename T , typename Allocator >

void test_dataRaces ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2199 of file StlVectorTest.cpp.

                                                {
   if (false) {
     const Vector* cv = nullptr;
     typename Vector::size_type* s = nullptr;
 
     cv->begin();
     cv->end();
     cv->rbegin();
     cv->rend();
     cv->front();
     cv->back();
     cv->data();
 
     (*cv).at(*s);
     (*cv)[*s];
   }
 
   // White-box: check that the non-const versions of each of the above
   // functions is implemented in terms of (or the same as) the const version
 }

template<class Vector >

void test_dataRaces2 ( std::true_type )

Definition at line 2199 of file StlVectorTest.cpp.

2199 {

template<class Vector >

void test_dataRaces2 ( std::false_type )

Definition at line 2199 of file StlVectorTest.cpp.

2199 {

template<class Vector >

void test_dataRaces3 ( )

Definition at line 2199 of file StlVectorTest.cpp.

2199 {

template<class Vector , typename T , typename Allocator >

void test_defaultAllocator ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2056 of file StlVectorTest.cpp.

                                                                  {
   // there is nothing new to test here
 }

template<class Vector >

void test_defaultAllocator2 ( std::false_type )

Definition at line 2056 of file StlVectorTest.cpp.

2056 {

template<class Vector >

void test_defaultAllocator2 ( std::true_type )

Definition at line 2056 of file StlVectorTest.cpp.

2056 {

template<class Vector >

void test_defaultAllocator3 ( )

Definition at line 2056 of file StlVectorTest.cpp.

2056 {

template<class Vector , typename T , typename Allocator >

void test_destructible ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 1819 of file StlVectorTest.cpp.

                                                               {
   // The test generators check this clause already.
 }

template<class Vector >

void test_destructible2 ( std::false_type )

Definition at line 1819 of file StlVectorTest.cpp.

1819 {

template<class Vector >

void test_destructible2 ( std::true_type )

Definition at line 1819 of file StlVectorTest.cpp.

1819 {

template<class Vector >

void test_destructible3 ( )

Definition at line 1819 of file StlVectorTest.cpp.

1819 {

template<class Vector , typename T , typename Allocator >

void test_ebo ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 3020 of file StlVectorTest.cpp.

                                       {
   static_assert(
       !is_same<Allocator, std::allocator<T>>::value ||
           sizeof(Vector) == 3 * sizeof(void*),
       "fbvector has default allocator, but has size != 3*sizeof(void*)");
 }

template<class Vector >

void test_ebo2 ( std::false_type )

Definition at line 3020 of file StlVectorTest.cpp.

3020 {

template<class Vector >

void test_ebo2 ( std::true_type )

Definition at line 3020 of file StlVectorTest.cpp.

3020 {

template<class Vector >

void test_ebo3 ( )

Definition at line 3020 of file StlVectorTest.cpp.

3020 {

template<class Vector , typename T , typename Allocator >

void test_emplaceBack ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2742 of file StlVectorTest.cpp.

                                                                       {
   DataState<Vector> dsa(a);
   auto adata = a.data();
   int excess = a.capacity() - a.size();
   auto am = a.get_allocator();
 
   try {
     a.emplace_back(44);
   } catch (...) {
     ASSERT_TRUE(dsa == a) << "failed strong exception guarantee";
     throw;
   }
 
   ASSERT_TRUE(am == a.get_allocator());
   if (excess > 0) {
     ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
   }
   ASSERT_EQ(dsa.size() + 1, a.size());
   size_t i = 0;
   auto it = a.begin();
   for (; i < dsa.size(); ++i, ++it) {
     ASSERT_EQ(dsa[i], convertToInt(*it));
   }
   ASSERT_EQ(44, convertToInt(a.back()));
 }

template<class Vector >

void test_emplaceBack2 ( std::false_type )

Definition at line 2742 of file StlVectorTest.cpp.

2742 {

template<class Vector >

void test_emplaceBack2 ( std::true_type )

Definition at line 2742 of file StlVectorTest.cpp.

2742 {

template<class Vector >

void test_emplaceBack3 ( )

Definition at line 2742 of file StlVectorTest.cpp.

2742 {

template<class Vector , typename T , typename Allocator >

void test_emptyConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 1715 of file StlVectorTest.cpp.

                                                                     {
   Vector u;
 
   ASSERT_TRUE(u.get_allocator() == Allocator());
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   ASSERT_TRUE(u.empty()) << u.size();
   ASSERT_EQ(0, u.capacity());
 
   if (false) {
     Vector();
   }
 }

template<class Vector >

void test_emptyConstruction2 ( std::true_type )

Definition at line 1715 of file StlVectorTest.cpp.

1715 {

template<class Vector >

void test_emptyConstruction2 ( std::false_type )

Definition at line 1715 of file StlVectorTest.cpp.

1715 {

template<class Vector >

void test_emptyConstruction3 ( )

Definition at line 1715 of file StlVectorTest.cpp.

1715 {

template<class Vector , typename T , typename Allocator >

void test_equitable ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))) )

Definition at line 1855 of file StlVectorTest.cpp.

                                                                   {
   const auto& ca = a;
   const auto& cb = b;
   DataState<Vector> dsa(a);
   DataState<Vector> dsb(b);
 
   ASSERT_TRUE((bool)(ca == cb) == (bool)(dsa == dsb))
       << "== does not return equality";
   ASSERT_TRUE((bool)(ca == cb) != (bool)(ca != cb))
       << "!= is not the opposite of ==";
 
   // Data is uncomparable, by design; therefore this test's restriction
   // is 'is_arithmetic'
 }

template<class Vector >

void test_equitable2 ( std::false_type )

Definition at line 1855 of file StlVectorTest.cpp.

1855 {

template<class Vector >

void test_equitable2 ( std::true_type )

Definition at line 1855 of file StlVectorTest.cpp.

1855 {

template<class Vector >

void test_equitable3 ( )

Definition at line 1855 of file StlVectorTest.cpp.

1855 {

template<class Vector , typename T , typename Allocator >

void test_forwardIteratorAllocConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, i,j,m, ticks)))) )

Definition at line 2148 of file StlVectorTest.cpp.

        {
   auto fi = makeForwardIterator(i);
   auto fj = makeForwardIterator(j);
   const auto& cfi = fi;
   const auto& cfj = fj;
   const auto& cm = m;
 
   Vector u(cfi, cfj, cm);
 
   ASSERT_TRUE(m == u.get_allocator());
 }

template<class Vector >

void test_forwardIteratorAllocConstruction2 ( std::false_type )

Definition at line 2148 of file StlVectorTest.cpp.

2148 {

template<class Vector >

void test_forwardIteratorAllocConstruction2 ( std::true_type )

Definition at line 2148 of file StlVectorTest.cpp.

2148 {

template<class Vector >

void test_forwardIteratorAllocConstruction3 ( )

Definition at line 2148 of file StlVectorTest.cpp.

2148 {

template<class Vector , typename T , typename Allocator >

void test_forwardIteratorConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, i,j, ticks)))) )

Definition at line 2249 of file StlVectorTest.cpp.

        {
   // All data is emplace-constructible from int, so we restrict to
   // is_destructible
 
   auto fi = makeForwardIterator(i);
   auto fj = makeForwardIterator(j);
   const auto& cfi = fi;
   const auto& cfj = fj;
 
   Vector u(cfi, cfj);
 
   ASSERT_TRUE(Allocator() == u.get_allocator());
   ASSERT_LE(Counter::CountTotalOps, j - i);
 
   ASSERT_EQ(j - i, u.size()) << "u(i,j).size() != j-i";
   for (auto it = u.begin(); it != u.end(); ++it, ++i) {
     ASSERT_EQ(*i, convertToInt(*it)) << "u(i,j) constructed incorrectly";
   }
 }

template<class Vector >

void test_forwardIteratorConstruction2 ( std::true_type )

Definition at line 2249 of file StlVectorTest.cpp.

2249 {

template<class Vector >

void test_forwardIteratorConstruction2 ( std::false_type )

Definition at line 2249 of file StlVectorTest.cpp.

2249 {

template<class Vector >

void test_forwardIteratorConstruction3 ( )

Definition at line 2249 of file StlVectorTest.cpp.

2249 {

template<class Vector , typename T , typename Allocator >

void test_front ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2710 of file StlVectorTest.cpp.

                                                           {
   if (a.empty()) {
     return;
   }
 
   ASSERT_TRUE(addressof(a.front()) == a.data());
 
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   if (false) {
     mutate(a.front());
     const Vector& ca = a;
     ca.front();
   }
 }

template<class Vector >

void test_front2 ( std::false_type )

Definition at line 2710 of file StlVectorTest.cpp.

2710 {

template<class Vector >

void test_front2 ( std::true_type )

Definition at line 2710 of file StlVectorTest.cpp.

2710 {

template<class Vector >

void test_front3 ( )

Definition at line 2710 of file StlVectorTest.cpp.

2710 {

template<class Vector , typename T , typename Allocator >

void test_getAllocator ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2052 of file StlVectorTest.cpp.

                                                              {
   // whitebox: ensure that a.get_allocator() returns a copy of its allocator
 }

template<class Vector >

void test_getAllocator2 ( std::false_type )

Definition at line 2052 of file StlVectorTest.cpp.

2052 {

template<class Vector >

void test_getAllocator2 ( std::true_type )

Definition at line 2052 of file StlVectorTest.cpp.

2052 {

template<class Vector >

void test_getAllocator3 ( )

Definition at line 2052 of file StlVectorTest.cpp.

2052 {

template<class Vector >

bool test_I_allocAssign2 ( std::false_type )

Definition at line 2119 of file StlVectorTest.cpp.

2119 {

template<class Vector >

bool test_I_allocAssign2 ( std::true_type )

Definition at line 2119 of file StlVectorTest.cpp.

2119 {

template<class Vector >

bool test_I_allocAssign3 ( )

Definition at line 2119 of file StlVectorTest.cpp.

2119 {

template<class Vector >

bool test_I_allocatorTypedefs2 ( std::false_type )

Definition at line 2046 of file StlVectorTest.cpp.

2046 {

template<class Vector >

bool test_I_allocatorTypedefs2 ( std::true_type )

Definition at line 2046 of file StlVectorTest.cpp.

2046 {

template<class Vector >

bool test_I_allocatorTypedefs3 ( )

Definition at line 2046 of file StlVectorTest.cpp.

References value.

2046 {

template<class Vector >

bool test_I_assignIL2 ( std::false_type )

Definition at line 2667 of file StlVectorTest.cpp.

2667 {

template<class Vector >

bool test_I_assignIL2 ( std::true_type )

Definition at line 2667 of file StlVectorTest.cpp.

2667 {

template<class Vector >

bool test_I_assignIL3 ( )

Definition at line 2667 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, STL_TEST, and Ticker::TicksLeft.

2667 {

template<class Vector >

bool test_I_assignInputRange2 ( std::false_type )

Definition at line 2651 of file StlVectorTest.cpp.

2651 {

template<class Vector >

bool test_I_assignInputRange2 ( std::true_type )

Definition at line 2651 of file StlVectorTest.cpp.

2651 {

template<class Vector >

bool test_I_assignInputRange3 ( )

Definition at line 2651 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, and makeInputIterator().

2651 {

template<class Vector >

bool test_I_assignN2 ( std::false_type )

Definition at line 2696 of file StlVectorTest.cpp.

2696 {

template<class Vector >

bool test_I_assignN2 ( std::true_type )

Definition at line 2696 of file StlVectorTest.cpp.

2696 {

template<class Vector >

bool test_I_assignN3 ( )

Definition at line 2696 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), and folly::pushmi::detail::t.

2696 {

template<class Vector >

bool test_I_assignRange2 ( std::false_type )

Definition at line 2629 of file StlVectorTest.cpp.

2629 {

template<class Vector >

bool test_I_assignRange2 ( std::true_type )

Definition at line 2629 of file StlVectorTest.cpp.

2629 {

template<class Vector >

bool test_I_assignRange3 ( )

Definition at line 2629 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, makeForwardIterator(), and STL_TEST.

2629 {

template<class Vector >

bool test_I_at2 ( std::false_type )

Definition at line 2855 of file StlVectorTest.cpp.

2855 {

template<class Vector >

bool test_I_at2 ( std::true_type )

Definition at line 2855 of file StlVectorTest.cpp.

2855 {

template<class Vector >

bool test_I_at3 ( )

Definition at line 2855 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, Counter::CountTotalOps, FAIL, i, and mutate().

2855 {

template<class Vector >

bool test_I_attach2 ( std::false_type )

Definition at line 3053 of file StlVectorTest.cpp.

3053 {

template<class Vector >

bool test_I_attach2 ( std::true_type )

Definition at line 3053 of file StlVectorTest.cpp.

3053 {

template<class Vector >

bool test_I_attach3 ( )

Definition at line 3053 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, folly::attach(), and folly::relinquish().

3053 {

template<class Vector >

bool test_I_back2 ( std::false_type )

Definition at line 2726 of file StlVectorTest.cpp.

2726 {

template<class Vector >

bool test_I_back2 ( std::true_type )

Definition at line 2726 of file StlVectorTest.cpp.

2726 {

template<class Vector >

bool test_I_back3 ( )

Definition at line 2726 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, Counter::CountTotalOps, and mutate().

2726 {

template<class Vector >

bool test_I_clear2 ( std::false_type )

Definition at line 2616 of file StlVectorTest.cpp.

2616 {

template<class Vector >

bool test_I_clear2 ( std::true_type )

Definition at line 2616 of file StlVectorTest.cpp.

2616 {

template<class Vector >

bool test_I_clear3 ( )

Definition at line 2616 of file StlVectorTest.cpp.

References a, ASSERT_TRUE, and FAIL.

2616 {

template<class Vector >

bool test_I_comparable2 ( std::false_type )

Definition at line 2027 of file StlVectorTest.cpp.

2027 {

template<class Vector >

bool test_I_comparable2 ( std::true_type )

Definition at line 2027 of file StlVectorTest.cpp.

2027 {

template<class Vector >

bool test_I_comparable3 ( )

Definition at line 2027 of file StlVectorTest.cpp.

References ASSERT_TRUE.

2027 {

template<class Vector >

bool test_I_containerTypedefs2 ( std::false_type )

Definition at line 1652 of file StlVectorTest.cpp.

1652 {

template<class Vector >

bool test_I_containerTypedefs2 ( std::true_type )

Definition at line 1652 of file StlVectorTest.cpp.

1652 {

template<class Vector >

bool test_I_containerTypedefs3 ( )

Definition at line 1652 of file StlVectorTest.cpp.

References T, and value.

1652 {

template<class Vector >

bool test_I_copyAssign2 ( std::false_type )

Definition at line 1941 of file StlVectorTest.cpp.

1941 {

template<class Vector >

bool test_I_copyAssign2 ( std::true_type )

Definition at line 1941 of file StlVectorTest.cpp.

1941 {

template<class Vector >

bool test_I_copyAssign3 ( )

Definition at line 1941 of file StlVectorTest.cpp.

References a, ASSERT_TRUE, b, convertToInt(), and value.

1941 {

template<class Vector >

bool test_I_copyConstruction2 ( std::false_type )

Definition at line 1764 of file StlVectorTest.cpp.

1764 {

template<class Vector >

bool test_I_copyConstruction2 ( std::true_type )

Definition at line 1764 of file StlVectorTest.cpp.

1764 {

template<class Vector >

bool test_I_copyConstruction3 ( )

Definition at line 1764 of file StlVectorTest.cpp.

References a, and ASSERT_TRUE.

1764 {

template<class Vector >

bool test_I_copyWithAllocator2 ( std::false_type )

Definition at line 2072 of file StlVectorTest.cpp.

2072 {

template<class Vector >

bool test_I_copyWithAllocator2 ( std::true_type )

Definition at line 2072 of file StlVectorTest.cpp.

2072 {

template<class Vector >

bool test_I_copyWithAllocator3 ( )

Definition at line 2072 of file StlVectorTest.cpp.

References a, ASSERT_TRUE, m, and STL_TEST.

2072 {

template<class Vector >

bool test_I_customAllocator2 ( std::false_type )

Definition at line 2060 of file StlVectorTest.cpp.

2060 {

template<class Vector >

bool test_I_customAllocator2 ( std::true_type )

Definition at line 2060 of file StlVectorTest.cpp.

2060 {

template<class Vector >

bool test_I_customAllocator3 ( )

Definition at line 2060 of file StlVectorTest.cpp.

References ASSERT_TRUE, m, and folly::pushmi::detail::t.

2060 {

template<class Vector >

bool test_I_dataAndCapacity2 ( std::false_type )

Definition at line 2900 of file StlVectorTest.cpp.

2900 {

template<class Vector >

bool test_I_dataAndCapacity2 ( std::true_type )

Definition at line 2900 of file StlVectorTest.cpp.

2900 {

template<class Vector >

bool test_I_dataAndCapacity3 ( )

Definition at line 2900 of file StlVectorTest.cpp.

2900 {

template<class Vector >

bool test_I_dataRaces2 ( std::false_type )

Definition at line 2199 of file StlVectorTest.cpp.

2199 {

template<class Vector >

bool test_I_dataRaces2 ( std::true_type )

Definition at line 2199 of file StlVectorTest.cpp.

2199 {

template<class Vector >

bool test_I_dataRaces3 ( )

Definition at line 2199 of file StlVectorTest.cpp.

References s.

2199 {

template<class Vector >

bool test_I_defaultAllocator2 ( std::true_type )

Definition at line 2056 of file StlVectorTest.cpp.

2056 {

template<class Vector >

bool test_I_defaultAllocator2 ( std::false_type )

Definition at line 2056 of file StlVectorTest.cpp.

2056 {

template<class Vector >

bool test_I_defaultAllocator3 ( )

Definition at line 2056 of file StlVectorTest.cpp.

2056 {

template<class Vector >

bool test_I_destructible2 ( std::false_type )

Definition at line 1819 of file StlVectorTest.cpp.

1819 {

template<class Vector >

bool test_I_destructible2 ( std::true_type )

Definition at line 1819 of file StlVectorTest.cpp.

1819 {

template<class Vector >

bool test_I_destructible3 ( )

Definition at line 1819 of file StlVectorTest.cpp.

1819 {

template<class Vector >

bool test_I_ebo2 ( std::false_type )

Definition at line 3020 of file StlVectorTest.cpp.

3020 {

template<class Vector >

bool test_I_ebo2 ( std::true_type )

Definition at line 3020 of file StlVectorTest.cpp.

3020 {

template<class Vector >

bool test_I_ebo3 ( )

Definition at line 3020 of file StlVectorTest.cpp.

References value.

3020 {

template<class Vector >

bool test_I_emplaceBack2 ( std::false_type )

Definition at line 2742 of file StlVectorTest.cpp.

2742 {

template<class Vector >

bool test_I_emplaceBack2 ( std::true_type )

Definition at line 2742 of file StlVectorTest.cpp.

2742 {

template<class Vector >

bool test_I_emplaceBack3 ( )

Definition at line 2742 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, and DataState< Vector >::size().

2742 {

template<class Vector >

bool test_I_emptyConstruction2 ( std::false_type )

Definition at line 1715 of file StlVectorTest.cpp.

1715 {

template<class Vector >

bool test_I_emptyConstruction2 ( std::true_type )

Definition at line 1715 of file StlVectorTest.cpp.

1715 {

template<class Vector >

bool test_I_emptyConstruction3 ( )

Definition at line 1715 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, and Counter::CountTotalOps.

1715 {

template<class Vector >

bool test_I_equitable2 ( std::false_type )

Definition at line 1855 of file StlVectorTest.cpp.

1855 {

template<class Vector >

bool test_I_equitable2 ( std::true_type )

Definition at line 1855 of file StlVectorTest.cpp.

1855 {

template<class Vector >

bool test_I_equitable3 ( )

Definition at line 1855 of file StlVectorTest.cpp.

References a, ASSERT_TRUE, and b.

1855 {

template<class Vector >

bool test_I_forwardIteratorAllocConstruction2 ( std::false_type )

Definition at line 2148 of file StlVectorTest.cpp.

2148 {

template<class Vector >

bool test_I_forwardIteratorAllocConstruction2 ( std::true_type )

Definition at line 2148 of file StlVectorTest.cpp.

2148 {

template<class Vector >

bool test_I_forwardIteratorAllocConstruction3 ( )

Definition at line 2148 of file StlVectorTest.cpp.

References ASSERT_TRUE, i, m, makeForwardIterator(), and STL_TEST.

2148 {

template<class Vector >

bool test_I_forwardIteratorConstruction2 ( std::true_type )

Definition at line 2249 of file StlVectorTest.cpp.

2249 {

template<class Vector >

bool test_I_forwardIteratorConstruction2 ( std::false_type )

Definition at line 2249 of file StlVectorTest.cpp.

2249 {

template<class Vector >

bool test_I_forwardIteratorConstruction3 ( )

Definition at line 2249 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_LE, ASSERT_TRUE, convertToInt(), Counter::CountTotalOps, i, makeForwardIterator(), and STL_TEST.

2249 {

template<class Vector >

bool test_I_front2 ( std::false_type )

Definition at line 2710 of file StlVectorTest.cpp.

2710 {

template<class Vector >

bool test_I_front2 ( std::true_type )

Definition at line 2710 of file StlVectorTest.cpp.

2710 {

template<class Vector >

bool test_I_front3 ( )

Definition at line 2710 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, Counter::CountTotalOps, and mutate().

2710 {

template<class Vector >

bool test_I_getAllocator2 ( std::false_type )

Definition at line 2052 of file StlVectorTest.cpp.

2052 {

template<class Vector >

bool test_I_getAllocator2 ( std::true_type )

Definition at line 2052 of file StlVectorTest.cpp.

2052 {

template<class Vector >

bool test_I_getAllocator3 ( )

Definition at line 2052 of file StlVectorTest.cpp.

2052 {

template<class Vector >

bool test_I_ilAllocConstruction2 ( std::false_type )

Definition at line 2183 of file StlVectorTest.cpp.

2183 {

template<class Vector >

bool test_I_ilAllocConstruction2 ( std::true_type )

Definition at line 2183 of file StlVectorTest.cpp.

2183 {

template<class Vector >

bool test_I_ilAllocConstruction3 ( )

Definition at line 2183 of file StlVectorTest.cpp.

2183 {

template<class Vector >

bool test_I_ilAssignment2 ( std::false_type )

Definition at line 2314 of file StlVectorTest.cpp.

2314 {

template<class Vector >

bool test_I_ilAssignment2 ( std::true_type )

Definition at line 2314 of file StlVectorTest.cpp.

2314 {

template<class Vector >

bool test_I_ilAssignment3 ( )

Definition at line 2314 of file StlVectorTest.cpp.

2314 {

template<class Vector >

bool test_I_ilConstruction2 ( std::false_type )

Definition at line 2294 of file StlVectorTest.cpp.

2294 {

template<class Vector >

bool test_I_ilConstruction2 ( std::true_type )

Definition at line 2294 of file StlVectorTest.cpp.

2294 {

template<class Vector >

bool test_I_ilConstruction3 ( )

Definition at line 2294 of file StlVectorTest.cpp.

2294 {

template<class Vector >

bool test_I_inputIteratorAllocConstruction2 ( std::false_type )

Definition at line 2166 of file StlVectorTest.cpp.

2166 {

template<class Vector >

bool test_I_inputIteratorAllocConstruction2 ( std::true_type )

Definition at line 2166 of file StlVectorTest.cpp.

2166 {

template<class Vector >

bool test_I_inputIteratorAllocConstruction3 ( )

Definition at line 2166 of file StlVectorTest.cpp.

2166 {

template<class Vector >

bool test_I_inputIteratorConstruction2 ( std::false_type )

Definition at line 2274 of file StlVectorTest.cpp.

2274 {

template<class Vector >

bool test_I_inputIteratorConstruction2 ( std::true_type )

Definition at line 2274 of file StlVectorTest.cpp.

2274 {

template<class Vector >

bool test_I_inputIteratorConstruction3 ( )

Definition at line 2274 of file StlVectorTest.cpp.

2274 {

template<class Vector >

bool test_I_iteratorEmplacement2 ( std::false_type )

Definition at line 2366 of file StlVectorTest.cpp.

2366 {

template<class Vector >

bool test_I_iteratorEmplacement2 ( std::true_type )

Definition at line 2366 of file StlVectorTest.cpp.

2366 {

template<class Vector >

bool test_I_iteratorEmplacement3 ( )

Definition at line 2366 of file StlVectorTest.cpp.

2366 {

template<class Vector >

bool test_I_iteratorErase2 ( std::false_type )

Definition at line 2575 of file StlVectorTest.cpp.

2575 {

template<class Vector >

bool test_I_iteratorErase2 ( std::true_type )

Definition at line 2575 of file StlVectorTest.cpp.

2575 {

template<class Vector >

bool test_I_iteratorErase3 ( )

Definition at line 2575 of file StlVectorTest.cpp.

2575 {

template<class Vector >

bool test_I_iteratorEraseRange2 ( std::false_type )

Definition at line 2597 of file StlVectorTest.cpp.

2597 {

template<class Vector >

bool test_I_iteratorEraseRange2 ( std::true_type )

Definition at line 2597 of file StlVectorTest.cpp.

2597 {

template<class Vector >

bool test_I_iteratorEraseRange3 ( )

Definition at line 2597 of file StlVectorTest.cpp.

2597 {

template<class Vector >

bool test_I_iteratorInsertIL2 ( std::false_type )

Definition at line 2532 of file StlVectorTest.cpp.

2532 {

template<class Vector >

bool test_I_iteratorInsertIL2 ( std::true_type )

Definition at line 2532 of file StlVectorTest.cpp.

2532 {

template<class Vector >

bool test_I_iteratorInsertIL3 ( )

Definition at line 2532 of file StlVectorTest.cpp.

2532 {

template<class Vector >

bool test_I_iteratorInsertion2 ( std::false_type )

Definition at line 2384 of file StlVectorTest.cpp.

2384 {

template<class Vector >

bool test_I_iteratorInsertion2 ( std::true_type )

Definition at line 2384 of file StlVectorTest.cpp.

2384 {

template<class Vector >

bool test_I_iteratorInsertion3 ( )

Definition at line 2384 of file StlVectorTest.cpp.

2384 {

template<class Vector >

bool test_I_iteratorInsertionInputIterator2 ( std::false_type )

Definition at line 2508 of file StlVectorTest.cpp.

2508 {

template<class Vector >

bool test_I_iteratorInsertionInputIterator2 ( std::true_type )

Definition at line 2508 of file StlVectorTest.cpp.

2508 {

template<class Vector >

bool test_I_iteratorInsertionInputIterator3 ( )

Definition at line 2508 of file StlVectorTest.cpp.

2508 {

template<class Vector >

bool test_I_iteratorInsertionIterator2 ( std::false_type )

Definition at line 2477 of file StlVectorTest.cpp.

2477 {

template<class Vector >

bool test_I_iteratorInsertionIterator2 ( std::true_type )

Definition at line 2477 of file StlVectorTest.cpp.

2477 {

template<class Vector >

bool test_I_iteratorInsertionIterator3 ( )

Definition at line 2477 of file StlVectorTest.cpp.

2477 {

template<class Vector >

bool test_I_iteratorInsertionN2 ( std::false_type )

Definition at line 2429 of file StlVectorTest.cpp.

2429 {

template<class Vector >

bool test_I_iteratorInsertionN2 ( std::true_type )

Definition at line 2429 of file StlVectorTest.cpp.

2429 {

template<class Vector >

bool test_I_iteratorInsertionN3 ( )

Definition at line 2429 of file StlVectorTest.cpp.

2429 {

template<class Vector >

bool test_I_iteratorInsertionRV2 ( std::false_type )

Definition at line 2404 of file StlVectorTest.cpp.

2404 {

template<class Vector >

bool test_I_iteratorInsertionRV2 ( std::true_type )

Definition at line 2404 of file StlVectorTest.cpp.

2404 {

template<class Vector >

bool test_I_iteratorInsertionRV3 ( )

Definition at line 2404 of file StlVectorTest.cpp.

2404 {

template<class Vector >

bool test_I_iterators2 ( std::false_type )

Definition at line 1823 of file StlVectorTest.cpp.

1823 {

template<class Vector >

bool test_I_iterators2 ( std::true_type )

Definition at line 1823 of file StlVectorTest.cpp.

1823 {

template<class Vector >

bool test_I_iterators3 ( )

Definition at line 1823 of file StlVectorTest.cpp.

1823 {

template<class Vector >

bool test_I_lengthError2 ( std::false_type )

Definition at line 2923 of file StlVectorTest.cpp.

2923 {

template<class Vector >

bool test_I_lengthError2 ( std::true_type )

Definition at line 2923 of file StlVectorTest.cpp.

2923 {

template<class Vector >

bool test_I_lengthError3 ( )

Definition at line 2923 of file StlVectorTest.cpp.

2923 {

template<class Vector >

bool test_I_memberSwappable2 ( std::false_type )

Definition at line 1870 of file StlVectorTest.cpp.

1870 {

template<class Vector >

bool test_I_memberSwappable2 ( std::true_type )

Definition at line 1870 of file StlVectorTest.cpp.

1870 {

template<class Vector >

bool test_I_memberSwappable3 ( )

Definition at line 1870 of file StlVectorTest.cpp.

1870 {

template<class Vector >

bool test_I_moveAssignment2 ( std::false_type )

Definition at line 1801 of file StlVectorTest.cpp.

1801 {

template<class Vector >

bool test_I_moveAssignment2 ( std::true_type )

Definition at line 1801 of file StlVectorTest.cpp.

1801 {

template<class Vector >

bool test_I_moveAssignment3 ( )

Definition at line 1801 of file StlVectorTest.cpp.

1801 {

template<class Vector >

bool test_I_moveConstruction2 ( std::false_type )

Definition at line 1785 of file StlVectorTest.cpp.

1785 {

template<class Vector >

bool test_I_moveConstruction2 ( std::true_type )

Definition at line 1785 of file StlVectorTest.cpp.

1785 {

template<class Vector >

bool test_I_moveConstruction3 ( )

Definition at line 1785 of file StlVectorTest.cpp.

1785 {

template<class Vector >

bool test_I_moveConstructionWithAllocator2 ( std::false_type )

Definition at line 2090 of file StlVectorTest.cpp.

2090 {

template<class Vector >

bool test_I_moveConstructionWithAllocator2 ( std::true_type )

Definition at line 2090 of file StlVectorTest.cpp.

2090 {

template<class Vector >

bool test_I_moveConstructionWithAllocator3 ( )

Definition at line 2090 of file StlVectorTest.cpp.

2090 {

template<class Vector >

bool test_I_moveConstructionWithAllocatorSupplied2 ( std::false_type )

Definition at line 2100 of file StlVectorTest.cpp.

2100 {

template<class Vector >

bool test_I_moveConstructionWithAllocatorSupplied2 ( std::true_type )

Definition at line 2100 of file StlVectorTest.cpp.

2100 {

template<class Vector >

bool test_I_moveConstructionWithAllocatorSupplied3 ( )

Definition at line 2100 of file StlVectorTest.cpp.

2100 {

template<class Vector >

bool test_I_moveIterators2 ( std::false_type )

Definition at line 2876 of file StlVectorTest.cpp.

2876 {

template<class Vector >

bool test_I_moveIterators2 ( std::true_type )

Definition at line 2876 of file StlVectorTest.cpp.

2876 {

template<class Vector >

bool test_I_moveIterators3 ( )

Definition at line 2876 of file StlVectorTest.cpp.

2876 {

template<class Vector >

bool test_I_nAllocConstruction2 ( std::true_type )

Definition at line 2123 of file StlVectorTest.cpp.

2123 {

template<class Vector >

bool test_I_nAllocConstruction2 ( std::false_type )

Definition at line 2123 of file StlVectorTest.cpp.

2123 {

template<class Vector >

bool test_I_nAllocConstruction3 ( )

Definition at line 2123 of file StlVectorTest.cpp.

2123 {

template<class Vector >

bool test_I_nConstruction2 ( std::false_type )

Definition at line 2223 of file StlVectorTest.cpp.

2223 {

template<class Vector >

bool test_I_nConstruction2 ( std::true_type )

Definition at line 2223 of file StlVectorTest.cpp.

2223 {

template<class Vector >

bool test_I_nConstruction3 ( )

Definition at line 2223 of file StlVectorTest.cpp.

2223 {

template<class Vector >

bool test_I_nCopyAllocConstruction2 ( std::false_type )

Definition at line 2133 of file StlVectorTest.cpp.

2133 {

template<class Vector >

bool test_I_nCopyAllocConstruction2 ( std::true_type )

Definition at line 2133 of file StlVectorTest.cpp.

2133 {

template<class Vector >

bool test_I_nCopyAllocConstruction3 ( )

Definition at line 2133 of file StlVectorTest.cpp.

2133 {

template<class Vector >

bool test_I_nCopyConstruction2 ( std::false_type )

Definition at line 2231 of file StlVectorTest.cpp.

2231 {

template<class Vector >

bool test_I_nCopyConstruction2 ( std::true_type )

Definition at line 2231 of file StlVectorTest.cpp.

2231 {

template<class Vector >

bool test_I_nCopyConstruction3 ( )

Definition at line 2231 of file StlVectorTest.cpp.

2231 {

template<class Vector >

bool test_I_nonmemberSwappable2 ( std::false_type )

Definition at line 1903 of file StlVectorTest.cpp.

1903 {

template<class Vector >

bool test_I_nonmemberSwappable2 ( std::true_type )

Definition at line 1903 of file StlVectorTest.cpp.

1903 {

template<class Vector >

bool test_I_nonmemberSwappable3 ( )

Definition at line 1903 of file StlVectorTest.cpp.

1903 {

template<class Vector >

bool test_I_operatorBrace2 ( std::false_type )

Definition at line 2842 of file StlVectorTest.cpp.

2842 {

template<class Vector >

bool test_I_operatorBrace2 ( std::true_type )

Definition at line 2842 of file StlVectorTest.cpp.

2842 {

template<class Vector >

bool test_I_operatorBrace3 ( )

Definition at line 2842 of file StlVectorTest.cpp.

2842 {

template<class Vector >

bool test_I_popBack2 ( std::false_type )

Definition at line 2823 of file StlVectorTest.cpp.

2823 {

template<class Vector >

bool test_I_popBack2 ( std::true_type )

Definition at line 2823 of file StlVectorTest.cpp.

2823 {

template<class Vector >

bool test_I_popBack3 ( )

Definition at line 2823 of file StlVectorTest.cpp.

2823 {

template<class Vector >

bool test_I_populate2 ( std::false_type )

Definition at line 1729 of file StlVectorTest.cpp.

1729 {

template<class Vector >

bool test_I_populate2 ( std::true_type )

Definition at line 1729 of file StlVectorTest.cpp.

1729 {

template<class Vector >

bool test_I_populate3 ( )

Definition at line 1729 of file StlVectorTest.cpp.

1729 {

template<class Vector >

bool test_I_pushBack2 ( std::false_type )

Definition at line 2768 of file StlVectorTest.cpp.

2768 {

template<class Vector >

bool test_I_pushBack2 ( std::true_type )

Definition at line 2768 of file StlVectorTest.cpp.

2768 {

template<class Vector >

bool test_I_pushBack3 ( )

Definition at line 2768 of file StlVectorTest.cpp.

2768 {

template<class Vector >

bool test_I_pushBackRV2 ( std::false_type )

Definition at line 2796 of file StlVectorTest.cpp.

2796 {

template<class Vector >

bool test_I_pushBackRV2 ( std::true_type )

Definition at line 2796 of file StlVectorTest.cpp.

2796 {

template<class Vector >

bool test_I_pushBackRV3 ( )

Definition at line 2796 of file StlVectorTest.cpp.

2796 {

template<class Vector >

bool test_I_relinquish2 ( std::false_type )

Definition at line 3027 of file StlVectorTest.cpp.

3027 {

template<class Vector >

bool test_I_relinquish2 ( std::true_type )

Definition at line 3027 of file StlVectorTest.cpp.

3027 {

template<class Vector >

bool test_I_relinquish3 ( )

Definition at line 3027 of file StlVectorTest.cpp.

3027 {

template<class Vector >

bool test_I_reserve2 ( std::true_type )

Definition at line 2906 of file StlVectorTest.cpp.

2906 {

template<class Vector >

bool test_I_reserve2 ( std::false_type )

Definition at line 2906 of file StlVectorTest.cpp.

2906 {

template<class Vector >

bool test_I_reserve3 ( )

Definition at line 2906 of file StlVectorTest.cpp.

2906 {

template<class Vector >

bool test_I_resize2 ( std::false_type )

Definition at line 2940 of file StlVectorTest.cpp.

2940 {

template<class Vector >

bool test_I_resize2 ( std::true_type )

Definition at line 2940 of file StlVectorTest.cpp.

2940 {

template<class Vector >

bool test_I_resize3 ( )

Definition at line 2940 of file StlVectorTest.cpp.

2940 {

template<class Vector >

bool test_I_resizeT2 ( std::true_type )

Definition at line 2961 of file StlVectorTest.cpp.

2961 {

template<class Vector >

bool test_I_resizeT2 ( std::false_type )

Definition at line 2961 of file StlVectorTest.cpp.

2961 {

template<class Vector >

bool test_I_resizeT3 ( )

Definition at line 2961 of file StlVectorTest.cpp.

2961 {

template<class Vector >

bool test_I_reversibleContainerTypedefs2 ( std::false_type )

Definition at line 1978 of file StlVectorTest.cpp.

1978 {

template<class Vector >

bool test_I_reversibleContainerTypedefs2 ( std::true_type )

Definition at line 1978 of file StlVectorTest.cpp.

1978 {

template<class Vector >

bool test_I_reversibleContainerTypedefs3 ( )

Definition at line 1978 of file StlVectorTest.cpp.

1978 {

template<class Vector >

bool test_I_reversibleIterators2 ( std::true_type )

Definition at line 1992 of file StlVectorTest.cpp.

1992 {

template<class Vector >

bool test_I_reversibleIterators2 ( std::false_type )

Definition at line 1992 of file StlVectorTest.cpp.

1992 {

template<class Vector >

bool test_I_reversibleIterators3 ( )

Definition at line 1992 of file StlVectorTest.cpp.

1992 {

template<class Vector >

bool test_I_shrinkToFit2 ( std::false_type )

Definition at line 2993 of file StlVectorTest.cpp.

2993 {

template<class Vector >

bool test_I_shrinkToFit2 ( std::true_type )

Definition at line 2993 of file StlVectorTest.cpp.

2993 {

template<class Vector >

bool test_I_shrinkToFit3 ( )

Definition at line 2993 of file StlVectorTest.cpp.

2993 {

template<class Vector >

bool test_I_sizeops2 ( std::false_type )

Definition at line 1971 of file StlVectorTest.cpp.

1971 {

template<class Vector >

bool test_I_sizeops2 ( std::true_type )

Definition at line 1971 of file StlVectorTest.cpp.

1971 {

template<class Vector >

bool test_I_sizeops3 ( )

Definition at line 1971 of file StlVectorTest.cpp.

1971 {

template<class Vector , typename T , typename Allocator >

void test_ilAllocConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, m, ticks)))) )

Definition at line 2183 of file StlVectorTest.cpp.

                                                             {
   // gcc fail
   if (Ticker::TicksLeft >= 0) {
     return;
   }
 
   const auto& cm = m;
 
   Vector u({1, 4, 7}, cm);
 
   ASSERT_TRUE(m == u.get_allocator());
 }

template<class Vector >

void test_ilAllocConstruction2 ( std::true_type )

Definition at line 2183 of file StlVectorTest.cpp.

2183 {

template<class Vector >

void test_ilAllocConstruction2 ( std::false_type )

Definition at line 2183 of file StlVectorTest.cpp.

2183 {

template<class Vector >

void test_ilAllocConstruction3 ( )

Definition at line 2183 of file StlVectorTest.cpp.

References ASSERT_TRUE, m, and Ticker::TicksLeft.

2183 {

template<class Vector , typename T , typename Allocator >

void test_ilAssignment ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2314 of file StlVectorTest.cpp.

                                                                {
   // whitebox: ensure that assign(il) is implemented in terms of
   // assign(il.begin(), il.end())
 
   // gcc fail
   if (Ticker::TicksLeft >= 0) {
     return;
   }
 
   auto am = a.get_allocator();
 
   Vector& b = a = {1, 4, 7};
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_TRUE(&b == &a) << "'a = ...' did not return *this";
 
   ASSERT_EQ(3, a.size()) << "u(il).size() fail";
   int i = 1;
   auto it = a.begin();
   for (; it != a.end(); ++it, i += 3) {
     ASSERT_EQ(i, convertToInt(*it)) << "u(il) constructed incorrectly";
   }
 }

template<class Vector >

void test_ilAssignment2 ( std::true_type )

Definition at line 2314 of file StlVectorTest.cpp.

2314 {

template<class Vector >

void test_ilAssignment2 ( std::false_type )

Definition at line 2314 of file StlVectorTest.cpp.

2314 {

template<class Vector >

void test_ilAssignment3 ( )

Definition at line 2314 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, b, convertToInt(), i, and Ticker::TicksLeft.

2314 {

template<class Vector , typename T , typename Allocator >

void test_ilConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2294 of file StlVectorTest.cpp.

                                                               {
   // whitebox: ensure that Vector(il) is implemented in terms of
   // Vector(il.begin(), il.end())
 
   // gcc fail
   if (Ticker::TicksLeft >= 0) {
     return;
   }
 
   Vector u = {1, 4, 7};
 
   ASSERT_TRUE(Allocator() == u.get_allocator());
   ASSERT_EQ(3, u.size()) << "u(il).size() fail";
   int i = 1;
   auto it = u.begin();
   for (; it != u.end(); ++it, i += 3) {
     ASSERT_EQ(i, convertToInt(*it)) << "u(il) constructed incorrectly";
   }
 }

template<class Vector >

void test_ilConstruction2 ( std::false_type )

Definition at line 2294 of file StlVectorTest.cpp.

2294 {

template<class Vector >

void test_ilConstruction2 ( std::true_type )

Definition at line 2294 of file StlVectorTest.cpp.

2294 {

template<class Vector >

void test_ilConstruction3 ( )

Definition at line 2294 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, and Ticker::TicksLeft.

2294 {

template<class Vector , typename T , typename Allocator >

void test_inputIteratorAllocConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, i,j,m, ticks)))) )

Definition at line 2166 of file StlVectorTest.cpp.

        {
 #ifdef USING_STD_VECTOR
   if (Ticker::TicksLeft >= 0)
     return;
 #endif
 
   auto ii = makeInputIterator(i);
   auto ij = makeInputIterator(j);
   const auto& cii = ii;
   const auto& cij = ij;
   const auto& cm = m;
 
   Vector u(cii, cij, cm);
 
   ASSERT_TRUE(m == u.get_allocator());
 }

template<class Vector >

void test_inputIteratorAllocConstruction2 ( std::false_type )

Definition at line 2166 of file StlVectorTest.cpp.

2166 {

template<class Vector >

void test_inputIteratorAllocConstruction2 ( std::true_type )

Definition at line 2166 of file StlVectorTest.cpp.

2166 {

template<class Vector >

void test_inputIteratorAllocConstruction3 ( )

Definition at line 2166 of file StlVectorTest.cpp.

References ASSERT_TRUE, i, m, makeInputIterator(), and Ticker::TicksLeft.

2166 {

template<class Vector , typename T , typename Allocator >

void test_inputIteratorConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, i,j, ticks)))) )

Definition at line 2274 of file StlVectorTest.cpp.

        {
 #ifdef USING_STD_VECTOR
   if (Ticker::TicksLeft >= 0)
     return;
 #endif
 
   auto ii = makeInputIterator(i);
   auto ij = makeInputIterator(j);
   const auto& cii = ii;
   const auto& cij = ij;
 
   Vector u(cii, cij);
 
   ASSERT_TRUE(Allocator() == u.get_allocator());
   ASSERT_EQ(j - i, u.size()) << "u(i,j).size() != j-i";
   for (auto it = u.begin(); it != u.end(); ++it, ++i) {
     ASSERT_EQ(*i, convertToInt(*it)) << "u(i,j) constructed incorrectly";
   }
 }

template<class Vector >

void test_inputIteratorConstruction2 ( std::true_type )

Definition at line 2274 of file StlVectorTest.cpp.

2274 {

template<class Vector >

void test_inputIteratorConstruction2 ( std::false_type )

Definition at line 2274 of file StlVectorTest.cpp.

2274 {

template<class Vector >

void test_inputIteratorConstruction3 ( )

Definition at line 2274 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, makeInputIterator(), and Ticker::TicksLeft.

2274 {

template<class Vector , typename T , typename Allocator >

void test_iteratorEmplacement ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a,p, ticks)))) )

Definition at line 2366 of file StlVectorTest.cpp.

        {
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
   auto am = a.get_allocator();
 
   auto q = a.emplace(p, 44);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(idx, distance(a.begin(), q)) << "incorrect iterator returned";
   insertNTCheck(a, dsa, idx, 1, 44);
 }

template<class Vector >

void test_iteratorEmplacement2 ( std::false_type )

Definition at line 2366 of file StlVectorTest.cpp.

2366 {

template<class Vector >

void test_iteratorEmplacement2 ( std::true_type )

Definition at line 2366 of file StlVectorTest.cpp.

2366 {

template<class Vector >

void test_iteratorEmplacement3 ( )

Definition at line 2366 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, insertNTCheck(), and STL_TEST.

2366 {

template<class Vector , typename T , typename Allocator >

void test_iteratorErase ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, p, ticks)))) )

Definition at line 2575 of file StlVectorTest.cpp.

                                                                          {
   if (p == a.end()) {
     return;
   }
 
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
   auto am = a.get_allocator();
 
   auto rit = a.erase(p);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(idx, distance(a.begin(), rit)) << "wrong iterator returned";
   eraseCheck(a, dsa, idx, 1);
 }

template<class Vector >

void test_iteratorErase2 ( std::true_type )

Definition at line 2575 of file StlVectorTest.cpp.

2575 {

template<class Vector >

void test_iteratorErase2 ( std::false_type )

Definition at line 2575 of file StlVectorTest.cpp.

2575 {

template<class Vector >

void test_iteratorErase3 ( )

Definition at line 2575 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, eraseCheck(), and STL_TEST.

2575 {

template<class Vector , typename T , typename Allocator >

void test_iteratorEraseRange ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a,p,q, ticks)))) )

Definition at line 2597 of file StlVectorTest.cpp.

        {
   if (p == a.end()) {
     return;
   }
 
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
   auto am = a.get_allocator();
 
   auto rit = a.erase(p, q);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(idx, distance(a.begin(), rit)) << "wrong iterator returned";
   eraseCheck(a, dsa, idx, distance(p, q));
 }

template<class Vector >

void test_iteratorEraseRange2 ( std::true_type )

Definition at line 2597 of file StlVectorTest.cpp.

2597 {

template<class Vector >

void test_iteratorEraseRange2 ( std::false_type )

Definition at line 2597 of file StlVectorTest.cpp.

2597 {

template<class Vector >

void test_iteratorEraseRange3 ( )

Definition at line 2597 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, and eraseCheck().

2597 {

template<class Vector , typename T , typename Allocator >

void test_iteratorInsertIL ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, p, ticks)))) )

Definition at line 2532 of file StlVectorTest.cpp.

                                                                        {
   // gcc fail
   if (Ticker::TicksLeft >= 0) {
     return;
   }
 
   // whitebox: ensure that insert(p, il) is implemented in terms of
   // insert(p, il.begin(), il.end())
 
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
   auto am = a.get_allocator();
 
 #ifndef USING_STD_VECTOR
   auto q =
 #endif
 
       a.insert(p, {1, 4, 7});
 
   ASSERT_TRUE(am == a.get_allocator());
 #ifndef USING_STD_VECTOR
   ASSERT_EQ(idx, distance(a.begin(), q)) << "incorrect iterator returned";
 #endif
 
   int ila[] = {1, 4, 7};
   int* i = ila;
   int* j = ila + 3;
   insertItCheck(a, dsa, idx, i, j);
 }

template<class Vector >

void test_iteratorInsertIL2 ( std::true_type )

Definition at line 2532 of file StlVectorTest.cpp.

2532 {

template<class Vector >

void test_iteratorInsertIL2 ( std::false_type )

Definition at line 2532 of file StlVectorTest.cpp.

2532 {

template<class Vector >

void test_iteratorInsertIL3 ( )

Definition at line 2532 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, i, insertItCheck(), and Ticker::TicksLeft.

2532 {

template<class Vector , typename T , typename Allocator >

void test_iteratorInsertion ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a,p,t, ticks)))) )

Definition at line 2384 of file StlVectorTest.cpp.

        {
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
   int tval = convertToInt(t);
   auto am = a.get_allocator();
   const auto& ct = t;
 
   auto q = a.insert(p, ct);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(idx, distance(a.begin(), q)) << "incorrect iterator returned";
   insertNTCheck(a, dsa, idx, 1, tval);
 }

template<class Vector >

void test_iteratorInsertion2 ( std::false_type )

Definition at line 2384 of file StlVectorTest.cpp.

2384 {

template<class Vector >

void test_iteratorInsertion2 ( std::true_type )

Definition at line 2384 of file StlVectorTest.cpp.

2384 {

template<class Vector >

void test_iteratorInsertion3 ( )

Definition at line 2384 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), insertNTCheck(), STL_TEST, and folly::pushmi::detail::t.

2384 {

template<class Vector , typename T , typename Allocator >

void test_iteratorInsertionInputIterator ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(6,(z, a,p,i,j, ticks)))) )

Definition at line 2508 of file StlVectorTest.cpp.

        {
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
 
   auto ii = makeInputIterator(i);
   auto ij = makeInputIterator(j);
   auto am = a.get_allocator();
   const auto& cii = ii;
   const auto& cij = ij;
 
 #ifndef USING_STD_VECTOR
   auto q =
 #endif
 
       a.insert(p, cii, cij);
 
   ASSERT_TRUE(am == a.get_allocator());
 #ifndef USING_STD_VECTOR
   ASSERT_EQ(idx, distance(a.begin(), q)) << "incorrect iterator returned";
 #endif
 
   insertItCheck(a, dsa, idx, i, j);
 }

template<class Vector >

void test_iteratorInsertionInputIterator2 ( std::true_type )

Definition at line 2508 of file StlVectorTest.cpp.

2508 {

template<class Vector >

void test_iteratorInsertionInputIterator2 ( std::false_type )

Definition at line 2508 of file StlVectorTest.cpp.

2508 {

template<class Vector >

void test_iteratorInsertionInputIterator3 ( )

Definition at line 2508 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, i, insertItCheck(), and makeInputIterator().

2508 {

template<class Vector , typename T , typename Allocator >

void test_iteratorInsertionIterator ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(6,(z, a,p,i,j, ticks)))) )

Definition at line 2477 of file StlVectorTest.cpp.

        {
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
 
   auto fi = makeForwardIterator(i);
   auto fj = makeForwardIterator(j);
   auto am = a.get_allocator();
   const auto& cfi = fi;
   const auto& cfj = fj;
 
 #ifndef USING_STD_VECTOR
   auto q =
 #endif
 
       a.insert(p, cfi, cfj);
 
   ASSERT_TRUE(am == a.get_allocator());
 #ifndef USING_STD_VECTOR
   ASSERT_EQ(idx, distance(a.begin(), q)) << "incorrect iterator returned";
 #endif
 
   insertItCheck(a, dsa, idx, i, j);
 }

template<class Vector >

void test_iteratorInsertionIterator2 ( std::true_type )

Definition at line 2477 of file StlVectorTest.cpp.

2477 {

template<class Vector >

void test_iteratorInsertionIterator2 ( std::false_type )

Definition at line 2477 of file StlVectorTest.cpp.

2477 {

template<class Vector >

void test_iteratorInsertionIterator3 ( )

Definition at line 2477 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, i, insertItCheck(), makeForwardIterator(), and STL_TEST.

2477 {

template<class Vector , typename T , typename Allocator >

void test_iteratorInsertionN ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(6,(z, a,p,n,t, ticks)))) )

Definition at line 2429 of file StlVectorTest.cpp.

        {
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
   int tval = convertToInt(t);
   auto am = a.get_allocator();
   const auto& ct = t;
 
 #ifndef USING_STD_VECTOR
   auto q =
 #endif
 
       a.insert(p, n, ct);
 
   ASSERT_TRUE(am == a.get_allocator());
 #ifndef USING_STD_VECTOR
   ASSERT_EQ(idx, distance(a.begin(), q)) << "incorrect iterator returned";
 #endif
 
   insertNTCheck(a, dsa, idx, n, tval);
 }

template<class Vector >

void test_iteratorInsertionN2 ( std::true_type )

Definition at line 2429 of file StlVectorTest.cpp.

2429 {

template<class Vector >

void test_iteratorInsertionN2 ( std::false_type )

Definition at line 2429 of file StlVectorTest.cpp.

2429 {

template<class Vector >

void test_iteratorInsertionN3 ( )

Definition at line 2429 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), insertNTCheck(), and folly::pushmi::detail::t.

2429 {

template<class Vector , typename T , typename Allocator >

void test_iteratorInsertionRV ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a,p,t, ticks)))) )

Definition at line 2404 of file StlVectorTest.cpp.

        {
   // rvalue-references cannot have their address checked for aliased inserts
   if (a.data() <= addressof(t) && addressof(t) < a.data() + a.size()) {
     return;
   }
 
   DataState<Vector> dsa(a);
   int idx = distance(a.begin(), p);
   int tval = convertToInt(t);
   auto am = a.get_allocator();
 
   auto q = a.insert(p, std::move(t));
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(idx, distance(a.begin(), q)) << "incorrect iterator returned";
   insertNTCheck(a, dsa, idx, 1, tval);
 }

template<class Vector >

void test_iteratorInsertionRV2 ( std::false_type )

Definition at line 2404 of file StlVectorTest.cpp.

2404 {

template<class Vector >

void test_iteratorInsertionRV2 ( std::true_type )

Definition at line 2404 of file StlVectorTest.cpp.

2404 {

template<class Vector >

void test_iteratorInsertionRV3 ( )

Definition at line 2404 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), insertNTCheck(), folly::gen::move, STL_TEST, and folly::pushmi::detail::t.

2404 {

template<class Vector , typename T , typename Allocator >

void test_iterators ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 1823 of file StlVectorTest.cpp.

                                                                  {
   DataState<Vector> dsa(a);
   const auto& ca = a;
 
   auto itb = a.begin();
   auto citb = ca.begin();
   auto Citb = a.cbegin();
   auto ite = a.end();
   auto cite = ca.end();
   auto Cite = a.cend();
 
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   ASSERT_TRUE(dsa == a) << "call to begin or end modified internal data";
 
   ASSERT_TRUE(citb == Citb) << "cv.begin != v.cbegin";
   ASSERT_TRUE(cite == Cite) << "cv.end != v.cend";
 
   if (ca.size() == 0) {
     ASSERT_TRUE(itb == ite) << "begin != end when empty";
     ASSERT_TRUE(Citb == Cite) << "cbegin != cend when empty";
   } else {
     ASSERT_TRUE(itb != ite) << "begin == end when non-empty";
     ASSERT_TRUE(Citb != Cite) << "cbegin == cend when non-empty";
   }
 
   auto dist = size_t(std::distance(itb, ite));
   auto Cdist = size_t(std::distance(Citb, Cite));
   ASSERT_TRUE(dist == ca.size()) << "distance(begin, end) != size";
   ASSERT_TRUE(Cdist == ca.size()) << "distance(cbegin, cend) != size";
 }

template<class Vector >

void test_iterators2 ( std::false_type )

Definition at line 1823 of file StlVectorTest.cpp.

1823 {

template<class Vector >

void test_iterators2 ( std::true_type )

Definition at line 1823 of file StlVectorTest.cpp.

1823 {

template<class Vector >

void test_iterators3 ( )

Definition at line 1823 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, Counter::CountTotalOps, and dist.

1823 {

template<class Vector , typename T , typename Allocator >

void test_lengthError ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2923 of file StlVectorTest.cpp.

                                                          {
   auto mx = Vector().max_size();
   auto big = mx + 1;
   if (mx >= big) {
     return; // max_size is the biggest size_type; overflowed
   }
 
   Vector u;
   try {
     u.reserve(big);
     FAIL() << "reserve(big) should have thrown an error";
   } catch (const std::length_error& e) {
   } catch (...) {
     FAIL() << "reserve(big) threw error other than length_error";
   }
 }

template<class Vector >

void test_lengthError2 ( std::true_type )

Definition at line 2923 of file StlVectorTest.cpp.

2923 {

template<class Vector >

void test_lengthError2 ( std::false_type )

Definition at line 2923 of file StlVectorTest.cpp.

2923 {

template<class Vector >

void test_lengthError3 ( )

Definition at line 2923 of file StlVectorTest.cpp.

References FAIL.

2923 {

template<class Vector , typename T , typename Allocator >

void test_memberSwappable ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))) )

Definition at line 1870 of file StlVectorTest.cpp.

                                                                        {
   if (!std::allocator_traits<Allocator>::propagate_on_container_swap::value &&
       convertToInt(a.get_allocator()) != convertToInt(b.get_allocator())) {
     // undefined behaviour
     return;
   }
 
   DataState<Vector> dsa(a);
   DataState<Vector> dsb(b);
   auto adata = a.data();
   auto bdata = b.data();
   auto am = a.get_allocator();
   auto bm = b.get_allocator();
 
   try {
     a.swap(b);
   } catch (...) {
     FAIL() << "swap is noexcept";
   }
 
   if (std::allocator_traits<Allocator>::propagate_on_container_swap::value) {
     ASSERT_TRUE(bm == a.get_allocator());
     ASSERT_TRUE(am == b.get_allocator());
   } else {
     ASSERT_TRUE(am == a.get_allocator());
     ASSERT_TRUE(bm == b.get_allocator());
   }
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   ASSERT_TRUE(adata == b.data() && bdata == a.data());
   ASSERT_TRUE(dsa == b && dsb == a) << "swap did not swap";
 }

template<class Vector >

void test_memberSwappable2 ( std::false_type )

Definition at line 1870 of file StlVectorTest.cpp.

1870 {

template<class Vector >

void test_memberSwappable2 ( std::true_type )

Definition at line 1870 of file StlVectorTest.cpp.

1870 {

template<class Vector >

void test_memberSwappable3 ( )

Definition at line 1870 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, b, convertToInt(), Counter::CountTotalOps, FAIL, and value.

1870 {

template<class Vector , typename T , typename Allocator >

void test_moveAssignment ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))) )

Definition at line 1801 of file StlVectorTest.cpp.

                                                                               {
   DataState<Vector> dsb(b);
   auto am = a.get_allocator();
   auto bm = b.get_allocator();
 
   Vector& ret = a = std::move(b);
 
   if (std::allocator_traits<
           Allocator>::propagate_on_container_move_assignment::value) {
     ASSERT_TRUE(bm == a.get_allocator());
   } else {
     ASSERT_TRUE(am == a.get_allocator());
   }
   ASSERT_TRUE(&ret == &a);
   ASSERT_TRUE(&a == &b || dsb == a) << "move assignment did not create a copy";
   // The source of the move may be left in any (albeit valid) state.
 }

template<class Vector >

void test_moveAssignment2 ( std::true_type )

Definition at line 1801 of file StlVectorTest.cpp.

1801 {

template<class Vector >

void test_moveAssignment2 ( std::false_type )

Definition at line 1801 of file StlVectorTest.cpp.

1801 {

template<class Vector >

void test_moveAssignment3 ( )

Definition at line 1801 of file StlVectorTest.cpp.

References a, ASSERT_TRUE, b, folly::gen::move, and value.

1801 {

template<class Vector , typename T , typename Allocator >

void test_moveConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 1785 of file StlVectorTest.cpp.

                                                                      {
   DataState<Vector> dsa(a);
   auto m = a.get_allocator();
 
   Vector u(move(a));
 
   ASSERT_TRUE(m == u.get_allocator());
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   ASSERT_TRUE(dsa == u);
 
   if (false) {
     Vector u2 = move(a);
   }
 }

template<class Vector >

void test_moveConstruction2 ( std::false_type )

Definition at line 1785 of file StlVectorTest.cpp.

1785 {

template<class Vector >

void test_moveConstruction2 ( std::true_type )

Definition at line 1785 of file StlVectorTest.cpp.

1785 {

template<class Vector >

void test_moveConstruction3 ( )

Definition at line 1785 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, Counter::CountTotalOps, m, and folly::gen::move.

1785 {

template<class Vector , typename T , typename Allocator >

void test_moveConstructionWithAllocator ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2090 of file StlVectorTest.cpp.

        {
   (void)a;
   // there is nothing new to test here
 }

template<class Vector >

void test_moveConstructionWithAllocator2 ( std::false_type )

Definition at line 2090 of file StlVectorTest.cpp.

2090 {

template<class Vector >

void test_moveConstructionWithAllocator2 ( std::true_type )

Definition at line 2090 of file StlVectorTest.cpp.

2090 {

template<class Vector >

void test_moveConstructionWithAllocator3 ( )

Definition at line 2090 of file StlVectorTest.cpp.

References a, and STL_TEST.

2090 {

template<class Vector , typename T , typename Allocator >

void test_moveConstructionWithAllocatorSupplied ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a,m, ticks)))) )

Definition at line 2100 of file StlVectorTest.cpp.

        {
   bool deep = m != a.get_allocator();
   auto osize = a.size();
   auto oalloc = AllocTracker::Constructed;
   const auto& cm = m;
 
   Vector u(std::move(a), cm);
 
   ASSERT_TRUE(u.get_allocator() == m);
 
   if (deep) {
     if (!AllocTracker::Allocated.empty()) {
       ASSERT_EQ(osize, AllocTracker::Constructed - oalloc);
     }
   } else {
     ASSERT_EQ(0, Counter::CountTotalOps);
   }
 }

template<class Vector >

void test_moveConstructionWithAllocatorSupplied2 ( std::false_type )

Definition at line 2100 of file StlVectorTest.cpp.

2100 {

template<class Vector >

void test_moveConstructionWithAllocatorSupplied2 ( std::true_type )

Definition at line 2100 of file StlVectorTest.cpp.

2100 {

template<class Vector >

void test_moveConstructionWithAllocatorSupplied3 ( )

Definition at line 2100 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, AllocTracker::Constructed, Counter::CountTotalOps, folly::empty(), m, and folly::gen::move.

2100 {

template<class Vector , typename T , typename Allocator >

void test_moveIterators ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 2876 of file StlVectorTest.cpp.

                                                                               {
   if (false) {
     int* i = nullptr;
     int* j = nullptr;
 
     auto mfi = make_move_iterator(makeForwardIterator(i));
     auto mfj = make_move_iterator(makeForwardIterator(j));
     auto mii = make_move_iterator(makeInputIterator(i));
     auto mij = make_move_iterator(makeInputIterator(j));
 
     Vector u1(mfi, mfj);
     Vector u2(mii, mij);
 
     u1.insert(u1.begin(), mfi, mfj);
     u1.insert(u1.begin(), mii, mij);
 
     u1.assign(mfi, mfj);
     u1.assign(mii, mij);
   }
 }

template<class Vector >

void test_moveIterators2 ( std::false_type )

Definition at line 2876 of file StlVectorTest.cpp.

2876 {

template<class Vector >

void test_moveIterators2 ( std::true_type )

Definition at line 2876 of file StlVectorTest.cpp.

2876 {

template<class Vector >

void test_moveIterators3 ( )

Definition at line 2876 of file StlVectorTest.cpp.

References i, makeForwardIterator(), and makeInputIterator().

2876 {

template<class Vector , typename T , typename Allocator >

void test_nAllocConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, n, m, ticks)))) )

Definition at line 2123 of file StlVectorTest.cpp.

                                                                       {
 #ifndef USING_STD_VECTOR
   const auto& cm = m;
 
   Vector u(n, cm);
 
   ASSERT_TRUE(m == u.get_allocator());
 #endif
 }

template<class Vector >

void test_nAllocConstruction2 ( std::false_type )

Definition at line 2123 of file StlVectorTest.cpp.

2123 {

template<class Vector >

void test_nAllocConstruction2 ( std::true_type )

Definition at line 2123 of file StlVectorTest.cpp.

2123 {

template<class Vector >

void test_nAllocConstruction3 ( )

Definition at line 2123 of file StlVectorTest.cpp.

References ASSERT_TRUE, and m.

2123 {

template<class Vector , typename T , typename Allocator >

void test_nConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, n, ticks)))) )

Definition at line 2223 of file StlVectorTest.cpp.

                                                                         {
   Vector u(n);
 
   ASSERT_TRUE(Allocator() == u.get_allocator());
   ASSERT_EQ(n, u.size());
   ASSERT_EQ(Counter::CountTotalOps, Counter::CountDC);
 }

template<class Vector >

void test_nConstruction2 ( std::true_type )

Definition at line 2223 of file StlVectorTest.cpp.

2223 {

template<class Vector >

void test_nConstruction2 ( std::false_type )

Definition at line 2223 of file StlVectorTest.cpp.

2223 {

template<class Vector >

void test_nConstruction3 ( )

Definition at line 2223 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, Counter::CountDC, and Counter::CountTotalOps.

2223 {

template<class Vector , typename T , typename Allocator >

void test_nCopyAllocConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, n, t, m, ticks)))) )

Definition at line 2133 of file StlVectorTest.cpp.

                                                                              {
   const auto& cm = m;
   const auto& ct = t;
 
   Vector u(n, ct, cm);
 
   ASSERT_TRUE(m == u.get_allocator());
 }

template<class Vector >

void test_nCopyAllocConstruction2 ( std::false_type )

Definition at line 2133 of file StlVectorTest.cpp.

2133 {

template<class Vector >

void test_nCopyAllocConstruction2 ( std::true_type )

Definition at line 2133 of file StlVectorTest.cpp.

2133 {

template<class Vector >

void test_nCopyAllocConstruction3 ( )

Definition at line 2133 of file StlVectorTest.cpp.

References ASSERT_TRUE, i, m, STL_TEST, and folly::pushmi::detail::t.

2133 {

template<class Vector , typename T , typename Allocator >

void test_nCopyConstruction ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, n, t, ticks)))) )

Definition at line 2231 of file StlVectorTest.cpp.

                                                                                {
   const auto& ct = t;
 
   Vector u(n, ct);
 
   ASSERT_TRUE(Allocator() == u.get_allocator());
   ASSERT_EQ(n, u.size()) << "Vector(n, t).size() != n" << endl;
   for (const auto& val : u) {
     ASSERT_EQ(convertToInt(t), convertToInt(val))
         << "not all elements of Vector(n, t) are equal to t";
   }
 }

template<class Vector >

void test_nCopyConstruction2 ( std::true_type )

Definition at line 2231 of file StlVectorTest.cpp.

2231 {

template<class Vector >

void test_nCopyConstruction2 ( std::false_type )

Definition at line 2231 of file StlVectorTest.cpp.

2231 {

template<class Vector >

void test_nCopyConstruction3 ( )

Definition at line 2231 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, STL_TEST, folly::pushmi::detail::t, and val.

2231 {

template<class Vector , typename T , typename Allocator >

void test_nonmemberSwappable ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, b, ticks)))) )

Definition at line 1903 of file StlVectorTest.cpp.

                                                                           {
   if (!std::allocator_traits<Allocator>::propagate_on_container_swap::value &&
       convertToInt(a.get_allocator()) != convertToInt(b.get_allocator())) {
     // undefined behaviour
     return;
   }
 
   DataState<Vector> dsa(a);
   DataState<Vector> dsb(b);
   auto adata = a.data();
   auto bdata = b.data();
   auto am = a.get_allocator();
   auto bm = b.get_allocator();
 
   try {
     swap(a, b);
   } catch (...) {
     FAIL() << "swap is noexcept";
   }
 
   if (std::allocator_traits<Allocator>::propagate_on_container_swap::value) {
     ASSERT_TRUE(bm == a.get_allocator());
     ASSERT_TRUE(am == b.get_allocator());
   } else {
     ASSERT_TRUE(am == a.get_allocator());
     ASSERT_TRUE(bm == b.get_allocator());
   }
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   ASSERT_TRUE(adata == b.data() && bdata == a.data());
   ASSERT_TRUE(dsa == b && dsb == a) << "swap did not swap";
 }

template<class Vector >

void test_nonmemberSwappable2 ( std::false_type )

Definition at line 1903 of file StlVectorTest.cpp.

1903 {

template<class Vector >

void test_nonmemberSwappable2 ( std::true_type )

Definition at line 1903 of file StlVectorTest.cpp.

1903 {

template<class Vector >

void test_nonmemberSwappable3 ( )

Definition at line 1903 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, b, convertToInt(), Counter::CountTotalOps, FAIL, STL_TEST, folly::f14::swap(), and value.

1903 {

template<class Vector , typename T , typename Allocator >

void test_operatorBrace ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2842 of file StlVectorTest.cpp.

                                                                    {
   const auto& ca = a;
   for (size_t i = 0; i < ca.size(); ++i) {
     ASSERT_TRUE(addressof(ca[i]) == ca.data() + i);
   }
 
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   if (false) {
     mutate(a[0]);
   }
 }

template<class Vector >

void test_operatorBrace2 ( std::true_type )

Definition at line 2842 of file StlVectorTest.cpp.

2842 {

template<class Vector >

void test_operatorBrace2 ( std::false_type )

Definition at line 2842 of file StlVectorTest.cpp.

2842 {

template<class Vector >

void test_operatorBrace3 ( )

Definition at line 2842 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, Counter::CountTotalOps, i, and mutate().

2842 {

template<class Vector , typename T , typename Allocator >

void test_popBack ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2823 of file StlVectorTest.cpp.

                                                              {
   if (a.empty()) {
     return;
   }
 
   DataState<Vector> dsa(a);
   auto am = a.get_allocator();
 
   a.pop_back();
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(dsa.size() - 1, a.size());
   size_t i = 0;
   auto it = a.begin();
   for (; it != a.end(); ++it, ++i) {
     ASSERT_EQ(dsa[i], convertToInt(*it));
   }
 }

template<class Vector >

void test_popBack2 ( std::true_type )

Definition at line 2823 of file StlVectorTest.cpp.

2823 {

template<class Vector >

void test_popBack2 ( std::false_type )

Definition at line 2823 of file StlVectorTest.cpp.

2823 {

template<class Vector >

void test_popBack3 ( )

Definition at line 2823 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, and DataState< Vector >::size().

2823 {

template<class Vector , typename T , typename Allocator >

void test_populate ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 1729 of file StlVectorTest.cpp.

                                                        {
   // We use emplace_back to construct vectors for testing, as well as size,
   // data, and capacity. We make sure these work before proceeding with tests.
 
   Vector u;
   ASSERT_EQ(0, u.size());
   ASSERT_EQ(nullptr, u.data());
 
   u.emplace_back(17);
   ASSERT_EQ(1, u.size());
   ASSERT_LT(u.capacity(), 100)
       << "single push_back increased capacity to " << u.capacity();
   ASSERT_NE(nullptr, u.data());
   ASSERT_EQ(17, convertToInt(u.data()[0]))
       << "first object did not get emplaced correctly";
 
   for (int i = 0; i < 3; ++i) {
     auto cap = u.capacity();
     while (u.size() < cap) {
       u.emplace_back(22);
       ASSERT_EQ(cap, u.capacity()) << "Vector grew when it did not need to";
       ASSERT_EQ(22, convertToInt(u.data()[u.size() - 1]))
           << "push_back with excess capacity failed";
     }
 
     ASSERT_EQ(cap, u.size());
 
     u.emplace_back(4);
     ASSERT_GT(u.capacity(), cap) << "capacity did not grow on overflow";
     ASSERT_EQ(cap + 1, u.size());
     ASSERT_EQ(4, convertToInt(u.data()[u.size() - 1]))
         << "grow object did not get emplaced correctly";
   }
 }

template<class Vector >

void test_populate2 ( std::true_type )

Definition at line 1729 of file StlVectorTest.cpp.

1729 {

template<class Vector >

void test_populate2 ( std::false_type )

Definition at line 1729 of file StlVectorTest.cpp.

1729 {

template<class Vector >

void test_populate3 ( )

Definition at line 1729 of file StlVectorTest.cpp.

References ASSERT_EQ, ASSERT_GT, ASSERT_LT, ASSERT_NE, convertToInt(), and i.

1729 {

template<class Vector , typename T , typename Allocator >

void test_pushBack ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, t, ticks)))) )

Definition at line 2768 of file StlVectorTest.cpp.

                                                                       {
   DataState<Vector> dsa(a);
   int tval = convertToInt(t);
   auto adata = a.data();
   int excess = a.capacity() - a.size();
   auto am = a.get_allocator();
   const auto& ct = t;
 
   try {
     a.push_back(ct);
   } catch (...) {
     ASSERT_TRUE(dsa == a) << "failed strong exception guarantee";
     throw;
   }
 
   ASSERT_TRUE(am == a.get_allocator());
   if (excess > 0) {
     ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
   }
   ASSERT_EQ(dsa.size() + 1, a.size());
   size_t i = 0;
   auto it = a.begin();
   for (; i < dsa.size(); ++i, ++it) {
     ASSERT_EQ(dsa[i], convertToInt(*it));
   }
   ASSERT_EQ(tval, convertToInt(a.back()));
 }

template<class Vector >

void test_pushBack2 ( std::false_type )

Definition at line 2768 of file StlVectorTest.cpp.

2768 {

template<class Vector >

void test_pushBack2 ( std::true_type )

Definition at line 2768 of file StlVectorTest.cpp.

2768 {

template<class Vector >

void test_pushBack3 ( )

Definition at line 2768 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, DataState< Vector >::size(), and folly::pushmi::detail::t.

2768 {

template<class Vector , typename T , typename Allocator >

void test_pushBackRV ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, t, ticks)))) )

Definition at line 2796 of file StlVectorTest.cpp.

                                                                         {
   DataState<Vector> dsa(a);
   int tval = convertToInt(t);
   auto adata = a.data();
   int excess = a.capacity() - a.size();
   auto am = a.get_allocator();
 
   try {
     a.push_back(move(t));
   } catch (...) {
     ASSERT_TRUE(dsa == a) << "failed strong exception guarantee";
     throw;
   }
 
   ASSERT_TRUE(am == a.get_allocator());
   if (excess > 0) {
     ASSERT_TRUE(a.data() == adata) << "unnecessary relocation";
   }
   ASSERT_EQ(dsa.size() + 1, a.size());
   size_t i = 0;
   auto it = a.begin();
   for (; i < dsa.size(); ++i, ++it) {
     ASSERT_EQ(dsa[i], convertToInt(*it));
   }
   ASSERT_EQ(tval, convertToInt(a.back()));
 }

template<class Vector >

void test_pushBackRV2 ( std::true_type )

Definition at line 2796 of file StlVectorTest.cpp.

2796 {

template<class Vector >

void test_pushBackRV2 ( std::false_type )

Definition at line 2796 of file StlVectorTest.cpp.

2796 {

template<class Vector >

void test_pushBackRV3 ( )

Definition at line 2796 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, folly::gen::move, DataState< Vector >::size(), and folly::pushmi::detail::t.

2796 {

template<class Vector , typename T , typename Allocator >

void test_relinquish ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 3027 of file StlVectorTest.cpp.

                                                        {
   auto sz = a.size();
   auto cap = a.capacity();
   auto data = a.data();
 
   auto guts = relinquish(a);
 
   ASSERT_EQ(data, guts);
   ASSERT_TRUE(a.empty());
   ASSERT_EQ(0, a.capacity());
 
   auto alloc = a.get_allocator();
   for (size_t i = 0; i < sz; ++i) {
     std::allocator_traits<decltype(alloc)>::destroy(alloc, guts + i);
   }
   if (guts != nullptr) {
     if (std::is_same<
             decltype(alloc),
             std::allocator<typename decltype(alloc)::value_type>>::value) {
       free(guts);
     } else {
       std::allocator_traits<decltype(alloc)>::deallocate(alloc, guts, cap);
     }
   }
 }

template<class Vector >

void test_relinquish2 ( std::true_type )

Definition at line 3027 of file StlVectorTest.cpp.

3027 {

template<class Vector >

void test_relinquish2 ( std::false_type )

Definition at line 3027 of file StlVectorTest.cpp.

3027 {

template<class Vector >

void test_relinquish3 ( )

Definition at line 3027 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, data, destroy(), bm::free(), i, folly::relinquish(), and value.

3027 {

template<class Vector , typename T , typename Allocator >

void test_reserve ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, n, ticks)))) )

Definition at line 2906 of file StlVectorTest.cpp.

                                                            {
   auto adata = a.data();
   auto ocap = a.capacity();
   auto am = a.get_allocator();
 
   a.reserve(n);
 
   ASSERT_TRUE(am == a.get_allocator());
   if (size_t(n) <= ocap) {
     ASSERT_EQ(0, Counter::CountTotalOps);
     ASSERT_TRUE(adata == a.data());
   } else {
     ASSERT_TRUE(a.capacity() >= size_t(n));
     ASSERT_LE(Counter::CountTotalOps, 2 * a.size()); // move and delete
   }
 }

template<class Vector >

void test_reserve2 ( std::true_type )

Definition at line 2906 of file StlVectorTest.cpp.

2906 {

template<class Vector >

void test_reserve2 ( std::false_type )

Definition at line 2906 of file StlVectorTest.cpp.

2906 {

template<class Vector >

void test_reserve3 ( )

Definition at line 2906 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_LE, ASSERT_TRUE, and Counter::CountTotalOps.

2906 {

template<class Vector , typename T , typename Allocator >

void test_resize ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(4,(z, a, n, ticks)))) )

Definition at line 2940 of file StlVectorTest.cpp.

                                                           {
   DataState<Vector> dsa(a);
   int sz = a.size();
   auto am = a.get_allocator();
 
   a.resize(n);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(n, a.size());
 
   if (n <= sz) {
     for (int i = 0; i < n; ++i) {
       ASSERT_EQ(dsa[i], convertToInt(a[i]));
     }
   } else {
     for (int i = 0; i < sz; ++i) {
       ASSERT_EQ(dsa[i], convertToInt(a[i]));
     }
   }
 }

template<class Vector >

void test_resize2 ( std::true_type )

Definition at line 2940 of file StlVectorTest.cpp.

2940 {

template<class Vector >

void test_resize2 ( std::false_type )

Definition at line 2940 of file StlVectorTest.cpp.

2940 {

template<class Vector >

void test_resize3 ( )

Definition at line 2940 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), and i.

2940 {

template<class Vector , typename T , typename Allocator >

void test_resizeT ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(5,(z, a, n, t, ticks)))) )

Definition at line 2961 of file StlVectorTest.cpp.

                                                                            {
 #ifdef USING_STD_VECTOR
   if (a.data() <= addressof(t) && addressof(t) < a.data() + a.size())
     return;
 #endif
 
   DataState<Vector> dsa(a);
   int sz = a.size();
   auto am = a.get_allocator();
   const auto& ct = t;
   int val = convertToInt(t);
 
   a.resize(n, ct);
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_EQ(n, a.size());
 
   if (n <= sz) {
     for (int i = 0; i < n; ++i) {
       ASSERT_EQ(dsa[i], convertToInt(a[i]));
     }
   } else {
     int i = 0;
     for (; i < sz; ++i) {
       ASSERT_EQ(dsa[i], convertToInt(a[i]));
     }
     for (; i < n; ++i) {
       ASSERT_EQ(val, convertToInt(a[i]));
     }
   }
 }

template<class Vector >

void test_resizeT2 ( std::true_type )

Definition at line 2961 of file StlVectorTest.cpp.

2961 {

template<class Vector >

void test_resizeT2 ( std::false_type )

Definition at line 2961 of file StlVectorTest.cpp.

2961 {

template<class Vector >

void test_resizeT3 ( )

Definition at line 2961 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, convertToInt(), i, folly::pushmi::detail::t, and val.

2961 {

template<class Vector , typename T , typename Allocator >

void test_reversibleContainerTypedefs ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 1978 of file StlVectorTest.cpp.

                                                                               {
   static_assert(
       is_same<
           typename Vector::reverse_iterator,
           std::reverse_iterator<typename Vector::iterator>>::value,
       "Vector::reverse_iterator != reverse_iterator<Vector:iterator");
   static_assert(
       is_same<
           typename Vector::const_reverse_iterator,
           std::reverse_iterator<typename Vector::const_iterator>>::value,
       "Vector::const_reverse_iterator != "
       "const_reverse_iterator<Vector::iterator");
 }

template<class Vector >

void test_reversibleContainerTypedefs2 ( std::true_type )

Definition at line 1978 of file StlVectorTest.cpp.

1978 {

template<class Vector >

void test_reversibleContainerTypedefs2 ( std::false_type )

Definition at line 1978 of file StlVectorTest.cpp.

1978 {

template<class Vector >

void test_reversibleContainerTypedefs3 ( )

Definition at line 1978 of file StlVectorTest.cpp.

References value.

1978 {

template<class Vector , typename T , typename Allocator >

void test_reversibleIterators ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 1992 of file StlVectorTest.cpp.

                                                                          {
   const auto& ca = a;
   DataState<Vector> ds(a);
 
   auto ritb = a.rbegin();
   auto critb = ca.rbegin();
   auto Critb = a.crbegin();
   auto rite = a.rend();
   auto crite = ca.rend();
   auto Crite = a.crend();
 
   ASSERT_EQ(0, Counter::CountTotalOps);
 
   ASSERT_TRUE(ds == a) << "call to rbegin or rend modified internal data";
 
   ASSERT_TRUE(critb == Critb) << "cv.rbegin != v.crbegin";
   ASSERT_TRUE(crite == Crite) << "cv.rend != v.crend";
 
   if (ca.size() == 0) {
     ASSERT_TRUE(ritb == rite) << "rbegin != rend when empty";
     ASSERT_TRUE(Critb == Crite) << "crbegin != crend when empty";
   } else {
     ASSERT_TRUE(ritb != rite) << "rbegin == rend when non-empty";
     ASSERT_TRUE(Critb != Crite) << "crbegin == crend when non-empty";
   }
 
   auto dist = size_t(std::distance(ritb, rite));
   auto Cdist = size_t(std::distance(Critb, Crite));
   ASSERT_TRUE(dist == ca.size()) << "distance(rbegin, rend) != size";
   ASSERT_TRUE(Cdist == ca.size()) << "distance(crbegin, crend) != size";
 }

template<class Vector >

void test_reversibleIterators2 ( std::false_type )

Definition at line 1992 of file StlVectorTest.cpp.

1992 {

template<class Vector >

void test_reversibleIterators2 ( std::true_type )

Definition at line 1992 of file StlVectorTest.cpp.

1992 {

template<class Vector >

void test_reversibleIterators3 ( )

Definition at line 1992 of file StlVectorTest.cpp.

References a, ASSERT_EQ, ASSERT_TRUE, Counter::CountTotalOps, and dist.

1992 {

template<class Vector , typename T , typename Allocator >

void test_shrinkToFit ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z, a, ticks)))) )

Definition at line 2993 of file StlVectorTest.cpp.

                                                             {
   bool willThrow = Ticker::TicksLeft >= 0;
 
   a.reserve(a.capacity() * 11);
 
   auto ocap = a.capacity();
   DataState<Vector> dsa(a);
 
   auto am = a.get_allocator();
 
   try {
     a.shrink_to_fit();
   } catch (...) {
     FAIL() << "shrink_to_fit should swallow errors";
   }
 
   ASSERT_TRUE(am == a.get_allocator());
   ASSERT_TRUE(dsa == a);
   if (willThrow) {
     // ASSERT_EQ(ocap, a.capacity()); might shrink in place
     throw TickException("I swallowed the error");
   } else {
     ASSERT_TRUE(a.capacity() == 0 || a.capacity() < ocap) << "Look into this";
   }
 }

template<class Vector >

void test_shrinkToFit2 ( std::true_type )

Definition at line 2993 of file StlVectorTest.cpp.

2993 {

template<class Vector >

void test_shrinkToFit2 ( std::false_type )

Definition at line 2993 of file StlVectorTest.cpp.

2993 {

template<class Vector >

void test_shrinkToFit3 ( )

Definition at line 2993 of file StlVectorTest.cpp.

References a, ASSERT_TRUE, FAIL, and Ticker::TicksLeft.

2993 {

template<class Vector , typename T , typename Allocator >

void test_sizeops ( BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(ARGIFY, _, BOOST_PP_TUPLE_TO_SEQ(3,(z,, ticks)))) )

Definition at line 1971 of file StlVectorTest.cpp.

                                                             {
   // This check generators check this clause already.
 }

template<class Vector >

void test_sizeops2 ( std::true_type )

Definition at line 1971 of file StlVectorTest.cpp.

1971 {

template<class Vector >

void test_sizeops2 ( std::false_type )

Definition at line 1971 of file StlVectorTest.cpp.

1971 {

template<class Vector >

void test_sizeops3 ( )

Definition at line 1971 of file StlVectorTest.cpp.

1971 {

template<class Vector >

void verify ( int extras )

Definition at line 1475 of file StlVectorTest.cpp.

References ASSERT_EQ, getTotal(), testing::Test::HasFatalFailure(), isSane(), value, and verifyAllocator().

Referenced by fizz::test::TestMessages::certificateVerify(), wangle::FizzConfigUtil::createFizzContext(), fizz::DefaultCertificateVerifier::DefaultCertificateVerifier(), fizz::tool::fizzClientCommand(), fizz::sm::getCertificateVerify(), fizz::sm::handleCertMsg(), fizz::JavaCryptoCertificateVerifier::JavaCryptoCertificateVerifier(), fizz::ExportedAuthenticator::makeAuthenticator(), TEST(), fizz::test::TEST_F(), fizz::client::test::TEST_F(), fizz::server::test::TEST_F(), and fizz::extensions::Validator::validateTokenBinding().

                         {
   if (!is_arithmetic<typename Vector::value_type>::value) {
     ASSERT_EQ(0 + extras, getTotal()) << "there exist Data but no vectors";
   }
   isSane();
   if (::testing::Test::HasFatalFailure()) {
     return;
   }
   if (customAllocator<Vector>::value) {
     verifyAllocator(0, 0);
   }
 }

template<class Vector >

void verify	(	int	extras,
		const Vector &	v
	)

Definition at line 1488 of file StlVectorTest.cpp.

References ASSERT_EQ, getTotal(), testing::Test::HasFatalFailure(), isSane(), value, verifyAllocator(), and verifyVector().

                                          {
   verifyVector(v);
   if (!is_arithmetic<typename Vector::value_type>::value) {
     ASSERT_EQ(v.size() + extras, getTotal())
         << "not all Data are in the vector";
   }
   isSane();
   if (::testing::Test::HasFatalFailure()) {
     return;
   }
   if (customAllocator<Vector>::value) {
     verifyAllocator(v.size(), v.capacity());
   }
 }

template<class Vector >

void verify	(	int	extras,
		const Vector &	v1,
		const Vector &	v2
	)

Definition at line 1503 of file StlVectorTest.cpp.

References ASSERT_EQ, getTotal(), testing::Test::HasFatalFailure(), isSane(), folly::size(), value, verifyAllocator(), and verifyVector().

                                                             {
   verifyVector(v1);
   verifyVector(v2);
   auto size = v1.size();
   auto cap = v1.capacity();
   if (&v1 != &v2) {
     size += v2.size();
     cap += v2.capacity();
   }
   if (!is_arithmetic<typename Vector::value_type>::value) {
     ASSERT_EQ(size + extras, getTotal()) << "not all Data are in the vector(s)";
   }
   isSane();
   if (::testing::Test::HasFatalFailure()) {
     return;
   }
   if (customAllocator<Vector>::value) {
     verifyAllocator(size, cap);
   }
 }

void verifyAllocator	(	int	ele,
		int	cap
	)

Definition at line 1458 of file StlVectorTest.cpp.

References ASSERT_EQ, AllocTracker::Constructed, and AllocTracker::Destroyed.

Referenced by verify().

                                        {
   ASSERT_EQ(ele, AllocTracker::Constructed - AllocTracker::Destroyed);
 
   int tot = 0;
   for (auto kv : AllocTracker::Allocated) {
     if (kv.second != size_t(-1)) {
       tot += kv.second;
     }
   }
   ASSERT_EQ(cap, tot) << "the allocator counts " << tot
                       << " space, "
                          "but the vector(s) have (combined) capacity "
                       << cap;
 }

template<class Vector >

void verifyVector ( const Vector & v )

Definition at line 1446 of file StlVectorTest.cpp.

References ASSERT_TRUE.

Referenced by verify().

                                    {
   ASSERT_TRUE(v.begin() <= v.end()) << "end is before begin";
   ASSERT_TRUE(v.empty() == (v.begin() == v.end())) << "empty != (begin == end)";
   ASSERT_TRUE(v.size() == size_t(distance(v.begin(), v.end())))
       << "size != end - begin";
   ASSERT_TRUE(v.size() <= v.capacity()) << "size > capacity";
   ASSERT_TRUE(v.capacity() <= v.max_size()) << "capacity > max_size";
   ASSERT_TRUE(v.data() || true); // message won't print - it will just crash
   ASSERT_TRUE(v.size() == 0 || v.data() != nullptr)
       << "nullptr data points to at least one element";
 }

Variable Documentation

int ijarC[12] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89}

static

Definition at line 1321 of file StlVectorTest.cpp.

int ijarr[12] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89}

static

Definition at line 1320 of file StlVectorTest.cpp.

const vector<int> nSizes = {0, 1, 2, 9, 10, 11}

static

Definition at line 1307 of file StlVectorTest.cpp.

int populateIndex = 1426

Definition at line 1236 of file StlVectorTest.cpp.

Referenced by populate().

const vector<int> tVals = {0, 1, 2, 3, 17, 66, 521}

static

Definition at line 1408 of file StlVectorTest.cpp.

const vector<pair<int, int> > VectorSizes

static

Definition at line 1202 of file StlVectorTest.cpp.

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation