Function Documentation

◆ all_elements_are()

template<class Range, class T>

auto arene::base::testing::all_elements_are	(	Range const &	range,
		T const &	value ) -> bool

constexpr

Check if all element of range are equal to value.

Template Parameters

Range	The type of the range to check
T	The type of the value to compare against

Parameters

range	The range to check
value	The value to compare against

This helper is an alternative to GTest matchers Each(Eq(value)), which require the value to be copy constructible.

◆ ARENE_IGNORE_ALL()

arene::base::testing::ARENE_IGNORE_ALL	(	"-Wfloat-equal"	,
		"These tests don't perform	arithmetic,
		so equality is OK even for floating point"	)

◆ ARENE_IGNORE_END()

arene::base::testing::ARENE_IGNORE_END ( )

◆ ARENE_IGNORE_START()

arene::base::testing::ARENE_IGNORE_START ( )

◆ assert_default_constructible_properties()

template<class T>

auto arene::base::testing::assert_default_constructible_properties ( ) -> void

constexpr

Assert default constructible types have the expected properties.

Template Parameters

T	The type to check

For types that are default constructible, two default constructed instances must compare equal. For types that are also copy constructible, a copy of a default constructed instance must compare equal to the original.

◆ bubble_sort_helper()

template<typename Container>

auto arene::base::testing::bubble_sort_helper ( Container container ) -> Container

constexprnoexcept

Inefficiently bubble sorts the argument because std::sort is not constexpr in C++14.

Template Parameters

Container The type of a container

Parameters

container A container to be sorted

Returns: An instance of Container with copies of the elements of container , but sorted

◆ CONDITIONAL_TYPED_TEST_P() [1/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorDeathTest	,
		ConstructingWithOutOfRangeSizeIsPreconditionViolation	,
		std::is_default_constructible< TypeParam >{}	)

Test: Invoking the external_vector constructor with a count larger than the capacity terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [2/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorDeathTest	,
		ConstructWithExcessiveSizeViaNormalConstructIsAlwaysPreconditionViolation	,
		std::is_default_constructible< TypeParam >{}	)

Test: Specifying a number of elements larger than the capacity of an external_vector when invoking the constructor terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [3/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		CanCompareForOrdering	,
		is_fully_comparable_v< TypeParam >	)

Test: Two instances of external_vector can be compared for ordering using operator< and operator>. One vector compares less than another if the first has a smaller size than the second, and all elements are equal to the corresponding element in the second vector with the same index or they have the same size, and there is an element such that all elements with a lower index compare equal to the corresponding element in the second vector, and that element compares less than the corresponding element of the second vector.

◆ CONDITIONAL_TYPED_TEST_P() [4/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		CanConstructWithSize	,
		std::is_default_constructible< TypeParam >{}	)

Test: Constructing with just a size creates a vector with that many default-constructed elements

◆ CONDITIONAL_TYPED_TEST_P() [5/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		CanConstructWithSizeViaTryConstruct	,
		std::is_default_constructible< TypeParam >{}	)

Test: try_construct can be used to construct an external_vector with a specified number of elements

◆ CONDITIONAL_TYPED_TEST_P() [6/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		ConstructWithExcessiveSizeViaTryConstructFails	,
		std::is_default_constructible< TypeParam >{}	)

Test: try_construct can be used to attempt to construct an external_vector with a specified number of elements that exceeds the capacity of the vector, in which case the result is an empty optional.

◆ CONDITIONAL_TYPED_TEST_P() [7/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		ConstructWithSizeViaNormalConstructWithDefaultConstructorNotNoexceptIsNotNoexcept	,
		std::is_default_constructible< TypeParam >{}	)

Test: The constructor of external_vector that takes a number of elements is not noexcept if the default constructor of the stored element type is not noexcept

◆ CONDITIONAL_TYPED_TEST_P() [8/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		ConstructWithSizeViaTryConstructNotNoexceptIfDefaultConstructorNotNoexcept	,
		std::is_default_constructible< TypeParam >{}	)

Test: The try_construct function of external_vector that takes a number of elements is not noexcept if the default constructor of the stored element type is not noexcept

◆ CONDITIONAL_TYPED_TEST_P() [9/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		DefaultEmplaceIsConditionallyNoexcept	,
		std::is_default_constructible< TypeParam >{}	)

Test: Emplacing using the default constructor has the right exception specification. This test is separate from the ones above due to a bug in GCC8 which tries to instantiate the emplace_back and emplace functions before checking their exception specifications, which fails for types that are not default-constructible.

◆ CONDITIONAL_TYPED_TEST_P() [10/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	ExternalVectorTest	,
		ResizeIsConditionallyNoexcept	,
		std::is_default_constructible< TypeParam >{}	)

Test: resize is noexcept if and only if the default constructor of the element type is noexcept

◆ CONDITIONAL_TYPED_TEST_P() [11/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorDeathTest	,
		AssignIsPreconditionViolationIfSizeOverCapacity	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: Invoking the assign member function with a count and a value where the count is larger than the capacity of the vector terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [12/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorDeathTest	,
		ConstructingWithOutOfRangeSizeAndSourceIsPreconditionViolation	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking the inline_vector constructor with a count and value where the count is larger than the capacity terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [13/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorDeathTest	,
		ConstructingWithOutOfRangeSizeIsPreconditionViolation	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: Invoking the inline_vector constructor with a count larger than the capacity terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [14/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorDeathTest	,
		ConstructingWithTooManyInitializersIsPreconditionViolation	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking the inline_vector constructor with an initializer list with more elements than the capacity terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [15/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorDeathTest	,
		ConstructWithExcessiveSizeViaNormalConstructIsAlwaysPreconditionViolation	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: Specifying a number of elements larger than the capacity of an inline_vector when invoking the constructor terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [16/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorDeathTest	,
		InsertNIsPreconditionViolationIfTooManyItems	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: Invoking insert with a count and a value to insert more elements than there are remaining spaces in the vector before it exceeds capacity terminates the program with a precondition violation.

◆ CONDITIONAL_TYPED_TEST_P() [17/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorDeathTest	,
		InsertWhenAtCapacityIsPreconditionViolation	,
		std::is_default_constructible< typename TypeParam::value_type >::value	)

Test: Invoking insert on an inline_vector with size equal to the capacity terminates the program with a precondition violation

◆ CONDITIONAL_TYPED_TEST_P() [18/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		AssignFromSizeAndValueIsConditionallyNoexcept	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: The assign member function taking a size and a value is not noexcept if the value type is not nothrow-copy-constructible

◆ CONDITIONAL_TYPED_TEST_P() [19/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanAccessMultipleValuesWithAt	,
		TypeParam::capacity >=	2 )

Test: The at member function returns the corresponding value stored when invoked with an index of 0 or 1 on an inline_vector into which two elements have been stored via push_back

◆ CONDITIONAL_TYPED_TEST_P() [20/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanAccessMultipleValuesWithAtWithConstVec	,
		TypeParam::capacity >=	2 )

Test: The at member function returns the corresponding value stored when invoked via a const reference to a vector with an index of 0 or 1 on an inline_vector into which two elements have been stored via push_back.

◆ CONDITIONAL_TYPED_TEST_P() [21/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanAccessMultipleValuesWithIndexOperator	,
		TypeParam::capacity >=	2 )

Test: Given an inline_vector with multiple elements, the index operator can be used with appropriate index values to access each element, returning a reference to the element at that index

◆ CONDITIONAL_TYPED_TEST_P() [22/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanAssignFromBiggerCapacityVector	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: An inline_vector can be assigned from an inline_vector with a larger capacity, provided the number of elements in the source vector is less than the capacity of the target vector

◆ CONDITIONAL_TYPED_TEST_P() [23/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanAssignFromInitListUsingAssignFunction	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: Invoking the assign member function with an initializer list sets the vector to have a size equal to the number of elements in the initializer list, and each element to be a copy of the corresponding element in the initializer list

◆ CONDITIONAL_TYPED_TEST_P() [24/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanAssignFromSizeAndValue	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: Invoking the assign member function with a count and a value sets the size of the vector to the specified count, where each element is a copy of the supplied value

◆ CONDITIONAL_TYPED_TEST_P() [25/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCompareForEquality	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&TypeParam::capacity >=	4 )

Test: Two instances of inline_vector can be compared for equality using operator== and operator!=. Two vectors are the same if and only if they have the same size, and each element from one vector compares equal to the element with the same index in the other vector.

◆ CONDITIONAL_TYPED_TEST_P() [26/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCompareForOrdering	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&is_fully_comparable_v< typename TypeParam::value_type > &&TypeParam::capacity >=	4 )

Test: Two instances of inline_vector can be compared for ordering using operator< and operator>. One vector compares less than another if the first has a smaller size than the second, and all elements are equal to the corresponding element in the second vector with the same index or they have the same size, and there is an element such that all elements with a lower index compare equal to the corresponding element in the second vector, and that element compares less than the corresponding element of the second vector.

◆ CONDITIONAL_TYPED_TEST_P() [27/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructFromBiggerCapacityVector	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: An inline_vector can be constructed from an inline_vector with a larger capacity, provided the number of elements in the source vector is less than the capacity of the target vector

◆ CONDITIONAL_TYPED_TEST_P() [28/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructFromInitializerList	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: An inline_vector can be constructed from a std::initializer_list without throwing exceptions, and the size and values stored in the vector are the same as the size and values of the initializer list.

◆ CONDITIONAL_TYPED_TEST_P() [29/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructFromInitializerListConstexpr	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: An inline_vector can be constructed from a std::initializer_list in a constexpr context, and the elements are those from the initializer list

◆ CONDITIONAL_TYPED_TEST_P() [30/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructFromIteratorRangeConstexpr	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: In a constexpr context, an inline_vector can be constructed from an iterator range, creating a vector holding copies of the elements from the source range, with a size equal to the number of elements in the source range

◆ CONDITIONAL_TYPED_TEST_P() [31/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructWithSize	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: Constructing with just a size creates a vector with that many default-constructed elements

◆ CONDITIONAL_TYPED_TEST_P() [32/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructWithSizeAndValue	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Constructing an inline_vector with a count and a value creates the specified number of elements copy-constructed from the supplied value, and sets the size of the vector to that count.

◆ CONDITIONAL_TYPED_TEST_P() [33/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructWithSizeViaTryConstruct	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: try_construct can be used to construct an inline_vector with a specified number of elements

◆ CONDITIONAL_TYPED_TEST_P() [34/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCopyViaConstruct	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Constructing an inline_vector with an existing inline_vector copies the elements from the source vector

◆ CONDITIONAL_TYPED_TEST_P() [35/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCopyViaConstructFromLargerWithFewerElements	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Constructing an inline_vector from an existing inline_vector with a larger capacity but a size that is less than or equal to the capacity of the destination type copies elements from the source vector

◆ CONDITIONAL_TYPED_TEST_P() [36/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCopyViaConstructFromSmaller	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Constructing an inline_vector from an existing inline_vector with a smaller capacity returns an inline_vector with the same elements as the source vector

◆ CONDITIONAL_TYPED_TEST_P() [37/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCopyViaTryConstruct	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking try_construct with an existing inline_vector returns a copy of that source vector

◆ CONDITIONAL_TYPED_TEST_P() [38/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCopyViaTryConstructFromLargerWithFewerElements	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking try_construct with an existing inline_vector with a larger capacity but a size that is less than or equal to the capacity of the destination type returns an inline_vector with the same elements as the source vector

◆ CONDITIONAL_TYPED_TEST_P() [39/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanCopyViaTryConstructFromSmaller	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking try_construct with an existing inline_vector with a smaller capacity returns an inline_vector with the same elements as the source vector

◆ CONDITIONAL_TYPED_TEST_P() [40/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanEmplace	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&TypeParam::capacity >=	3 )

Test: emplace can be invoked in a constexpr context to construct an element at a specified index.

◆ CONDITIONAL_TYPED_TEST_P() [41/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanEmplaceBackConstexpr	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: In a constexpr context, the emplace_back member function can be used to add an element to an inline_vector. The new element is constructed with the arguments supplied to emplace_back

◆ CONDITIONAL_TYPED_TEST_P() [42/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanErase	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&TypeParam::capacity >=	4 )

Test: In a constexpr context, given a non-empty inline_vector, invoking erase with an iterator referring to an element that is neither the first or last element removes that element, moves the following elements to one lower index, reduces the size by one.

◆ CONDITIONAL_TYPED_TEST_P() [43/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanEraseInMiddle	,
		TypeParam::capacity >=	2 )

Test: Given a non-empty inline_vector, invoking erase with an iterator referring to an element that is neither the first or last element removes that element, moves the following elements to one lower index, reduces the size by one, and returns an iterator to the element that replaced the erased element.

◆ CONDITIONAL_TYPED_TEST_P() [44/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanEraseRange	,
		TypeParam::capacity >=	5 )

Test: Invoking erase with an iterator range referring to elements in the same inline_vector, removes those elements, moves the following elements to take their place, and returns an iterator with the same offset from the beginning of the vector as the first erased element

◆ CONDITIONAL_TYPED_TEST_P() [45/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanInitializeWithSizeAndValue	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: In a constexpr context, invoking the inline_vector constructor with a count and a value constructs a vector holding the specified number of elements copied from the source value

◆ CONDITIONAL_TYPED_TEST_P() [46/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanInsert	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&TypeParam::capacity >=	3 )

Test: In a constexpr context, invoking insert with an iterator referring to an existing element, moves the referred to element and subsequent elements to make room for the new element, inserts the new element, and increases the size by one.

◆ CONDITIONAL_TYPED_TEST_P() [47/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanInsertAtEndOfExistingVector	,
		TypeParam::capacity >=	2 )

Test: Given an inline_vector with existing elements, and the iterator returned from end, insert can add an element to the end of the vector, increasing the size by one

◆ CONDITIONAL_TYPED_TEST_P() [48/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanInsertInMiddleOfExistingVector	,
		TypeParam::capacity >=	3 )

Test: Given an inline_vector with existing elements, and an iterator to an existing element in the vector, insert can add an element at the iterator position, increasing the vector size by one. The existing element at the location referenced by the iterator, and the subsequent elements, are moved to make room for the new element.

◆ CONDITIONAL_TYPED_TEST_P() [49/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanPushBack	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: In a constexpr context, an inline_vector can be default-constructed, and a new value inserted via push_back, such that the size of the container is now 1, and the value can be retrieved via at(0)

◆ CONDITIONAL_TYPED_TEST_P() [50/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanSwap	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: In a constexpr context, two inline_vector instances can be swapped with an unqualified call to swap.

◆ CONDITIONAL_TYPED_TEST_P() [51/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanTryConstructFromInitializerList	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking try_construct with an initializer list constructs an inline_vector holding copies of the elements from the initializer list

◆ CONDITIONAL_TYPED_TEST_P() [52/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CanUseBack	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: Given a constexpr inline_vector constructed by pushing back values, back can be used in a constexpr context to retrieve the last value in the vector, which must therefore equal the last value pushed back

◆ CONDITIONAL_TYPED_TEST_P() [53/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ClearWorks	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: In a constexpr context, given an inline_vector which is not empty, invoking the clear method makes the vector empty

◆ CONDITIONAL_TYPED_TEST_P() [54/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ConstIteration	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: It is possible to iterate over the values in a const inline_vector using a ranged-for loop in a constexpr context.

◆ CONDITIONAL_TYPED_TEST_P() [55/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ConstructWithExcessiveSizeViaTryConstructFails	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: try_construct can be used to attempt to construct an inline_vector with a specified number of elements that exceeds the capacity of the vector, in which case the result is an empty optional.

◆ CONDITIONAL_TYPED_TEST_P() [56/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ConstructWithSizeViaNormalConstructWithDefaultConstructorNotNoexceptIsNotNoexcept	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: The constructor of inline_vector that takes a number of elements is not noexcept if the default constructor of the stored element type is not noexcept

◆ CONDITIONAL_TYPED_TEST_P() [57/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ConstructWithSizeViaTryConstructNotNoexceptIfDefaultConstructorNotNoexcept	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: The try_construct function of inline_vector that takes a number of elements is not noexcept if the default constructor of the stored element type is not noexcept

◆ CONDITIONAL_TYPED_TEST_P() [58/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CopyAssignOverLargerVectorDestroysExcess	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: The inline_vector copy-assignment operator destroys the excess elements in the destination when the source vector has fewer elements than the destination vector

◆ CONDITIONAL_TYPED_TEST_P() [59/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CopyAssignOverLargerVectorFromInitListDestroysExcess	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: Given an inline_vector holding existing elements, assigning to that vector with an initializer list holding fewer elements copy assigns over the existing elements up to the size of the initializer list, and then destroys a number of elements equal to the difference between the old size of the vector and the size of the initializer list

◆ CONDITIONAL_TYPED_TEST_P() [60/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CopyAssignOverSmallerVectorCopiesElements	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: The inline_vector copy-assignment operator uses copy assignment for elements from the source where there is already a corresponding element in the destination, and copy construction for elements that do not have a corresponding element in the destination

◆ CONDITIONAL_TYPED_TEST_P() [61/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CopyAssignOverSmallerVectorFromInitListCopiesElements	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: Given an inline_vector holding existing elements, assigning to that vector with an initializer list holding more elements copy assigns over the existing elements, and then copy-constructs new elements to increase the size of the vector to that of the initializer list

◆ CONDITIONAL_TYPED_TEST_P() [62/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		CopyingVectorCopiesElements	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: The inline_vector copy constructor copies the stored elements and size from the original vector.

◆ CONDITIONAL_TYPED_TEST_P() [63/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		DefaultEmplaceIsConditionallyNoexcept	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: Emplacing using the default constructor has the right exception specification. This test is separate from the ones above due to a bug in GCC8 which tries to instantiate the emplace_back and emplace functions before checking their exception specifications, which fails for types that are not default-constructible.

◆ CONDITIONAL_TYPED_TEST_P() [64/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		EmplaceAtPositionIsConditionallyNoexceptLvalue	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: emplace with a position is noexcept if and only if the element type of the vector is nothrow-move-constructible, nothrow-move-assignable, and nothrow-constructible from an lvalue argument

◆ CONDITIONAL_TYPED_TEST_P() [65/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		EmplaceBackIsConditionallyNoexceptLvalue	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: emplace_back is noexcept if and only if the element type of the vector is nothrow-constructible from the supplied arguments

◆ CONDITIONAL_TYPED_TEST_P() [66/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		FailToCopyViaTryConstructFromLargerWithMoreElements	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking try_construct with an existing inline_vector with a larger capacity and a size that is larger than the capacity of the destination type returns an empty optional

◆ CONDITIONAL_TYPED_TEST_P() [67/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		Front	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: Given an instance of inline_vector by pushing back values in a constexpr context, the front member function can be used in a constexpr context to retrieve the first value, which must be equal to the first value of the pushed back

◆ CONDITIONAL_TYPED_TEST_P() [68/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		IndexOperator	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&TypeParam::capacity >=	2 )

Test: The index operator can be used to access the elements of an inline_vector in a constexpr context.

◆ CONDITIONAL_TYPED_TEST_P() [69/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InputIteratorRangeAssignmentIsConditionallyNoexcept	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: Assignment of an inline_vector from an input iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible from the value type of the iterator

◆ CONDITIONAL_TYPED_TEST_P() [70/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InputIteratorRangeTryConstructionIsConditionallyNoexcept	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: try_construct from an input iterator range is noexcept if the element type of the vector is nothrow-constructible from the iterator's reference type

◆ CONDITIONAL_TYPED_TEST_P() [71/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InsertFromIteratorRangeInMiddle	,
		TypeParam::capacity >=	11 )

Test: Invoking insert with an iterator referring to an existing element of an inline_vector and a source iterator range denoted by a pair of iterators moves the referred to element and subsequent elements to make room, and inserts the elements from the source iterator range prior to the existing element.

◆ CONDITIONAL_TYPED_TEST_P() [72/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InsertFromIteratorRangeIsConditionallyNoexcept	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: insert is noexcept if the element type of the vector is nothrow-constructible from the supplied iterator's reference type, and is nothrow-move-constructible and nothrow-move-assignable

◆ CONDITIONAL_TYPED_TEST_P() [73/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InsertLvalueIsConditionallyNoexcept	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: insert of an lvalue is noexcept if the element type of the vector is nothrow-constructible from the supplied value, and is nothrow-move-constructible and nothrow-move-assignable

◆ CONDITIONAL_TYPED_TEST_P() [74/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InsertNAtEndInsertsElements	,
		is_copyable_v< typename TypeParam::value_type > &&TypeParam::capacity >=	7 )

Test: Invoking insert with the end iterator of the inline_vector and a count and value appends the specified number of copies of the supplied value to the end of the vector.

◆ CONDITIONAL_TYPED_TEST_P() [75/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InsertNInMiddleInsertsElements	,
		is_copyable_v< typename TypeParam::value_type > &&TypeParam::capacity >=	7 )

Test: Invoking insert with an iterator referring to an existing element of an inline_vector and a count and value moves the referred to element and subsequent elements to make room, and inserts the specified number of copies of the supplied value prior to the existing element.

◆ CONDITIONAL_TYPED_TEST_P() [76/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		InsertWithCountIsConditionallyNoexcept	,
		is_copyable_v< typename TypeParam::value_type >	)

Test: insert is noexcept if the element type of the vector is nothrow-copy-constructible, and is nothrow-move-constructible and nothrow-move-assignable

◆ CONDITIONAL_TYPED_TEST_P() [77/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		Iteration	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: It is possible to iterate over the values in a mutable inline_vector using a ranged-for loop in a constexpr context.

◆ CONDITIONAL_TYPED_TEST_P() [78/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		IteratorRangeTryConstructionIsConditionallyNoexcept	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: try_construct from an iterator range is noexcept if the element type of the vector is nothrow-constructible from the iterator's reference type

◆ CONDITIONAL_TYPED_TEST_P() [79/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		PopBackIsUsable	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: In a constexpr context, pop_back removes the last element of a non-empty vector

◆ CONDITIONAL_TYPED_TEST_P() [80/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		PushBackIsConditionallyNoexceptLvalue	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: push_back of an lvalue is noexcept if and only if the value type can be constructed without throwing from an lvalue

◆ CONDITIONAL_TYPED_TEST_P() [81/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ResizeIsConditionallyNoexcept	,
		std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: resize is noexcept if and only if the default constructor of the element type is noexcept

◆ CONDITIONAL_TYPED_TEST_P() [82/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ResizeNonZeroCapacityVecToOtherIsOk	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: In a constexpr context, invoking resize with a non-zero count on an inline_vector with a non-zero capacity and different size sets the size to the specified size

◆ CONDITIONAL_TYPED_TEST_P() [83/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ResizeNonZeroCapacityVecToZeroIsOk	,
		InlineVectorTest< TypeParam >::constexpr_compatible &&std::is_default_constructible< typename TypeParam::value_type >{}	)

Test: In a constexpr context, invoking resize with a count of zero on an inline_vector with a non-zero capacity and size sets the size to zero

◆ CONDITIONAL_TYPED_TEST_P() [84/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ResizeWithValueIsConditionallyNoexcept	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: resize with a value to copy is noexcept if and only if the copy constructor of the element type is noexcept

◆ CONDITIONAL_TYPED_TEST_P() [85/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ResizeZeroCapacityVecToZeroIsOk	,
		InlineVectorTest< TypeParam >::constexpr_compatible	)

Test: In a constexpr context, invoking resize with a count of zero on an inline_vector with a capacity of zero does nothing

◆ CONDITIONAL_TYPED_TEST_P() [86/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ResizingFromLargeToSmallLeavesElements	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking the resize member function with a size and a value on a vector with more elements than the specified size sets the size of the vector to the specified count and does not construct new elements

◆ CONDITIONAL_TYPED_TEST_P() [87/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		ResizingFromSmallToLargeConstructsElementsAsCopiesOfSpecified	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking the resize member function with a size and a value on a vector with fewer elements than the specified size sets the size of the vector to the specified count, and constructs a number of new elements equal to the difference between the specified size and the previous size by copy-construction from the specified value

◆ CONDITIONAL_TYPED_TEST_P() [88/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		SecondPushBackChangesLastValue	,
		TypeParam::capacity >=	2 )

Test: After using push_back twice to add two items to a default-constructed inline_vector, the size is incremented to 2, and the second item can be retrieved via the back member function

◆ CONDITIONAL_TYPED_TEST_P() [89/89]

arene::base::testing::CONDITIONAL_TYPED_TEST_P	(	InlineVectorTest	,
		TryConstructFromTooLargeInitializerListReturnsEmpty	,
		std::is_copy_constructible< typename TypeParam::value_type >::value	)

Test: Invoking try_construct with an initializer list holding more elements than the capacity of the inline_vector returns an empty optional

◆ constexpr_clear()

template<typename Vec>

auto arene::base::testing::constexpr_clear ( Vec vec ) -> Vec

constexpr

◆ constexpr_emplace()

template<typename Vec, typename Arg>

auto arene::base::testing::constexpr_emplace	(	Vec &&	vec,
		std::ptrdiff_t	pos,
		Arg &&	arg ) -> Vec

constexpr

◆ constexpr_emplace_back()

template<typename Container, typename... Args>

auto arene::base::testing::constexpr_emplace_back ( Args &&... args ) -> Container

constexpr

◆ constexpr_erase()

template<typename Vec, typename... Args>

auto arene::base::testing::constexpr_erase	(	std::size_t	index,
		Args &&...	args ) -> Vec

constexpr

◆ constexpr_insert()

template<typename Vec, typename T>

auto arene::base::testing::constexpr_insert	(	Vec &&	vec,
		std::ptrdiff_t	offset,
		T &&	value ) -> Vec

constexpr

◆ constexpr_iterate() [1/2]

template<typename Vec, typename... Args>

auto arene::base::testing::constexpr_iterate ( Args &&... args ) -> bool

constexpr

◆ constexpr_iterate() [2/2]

template<typename Vec>

auto arene::base::testing::constexpr_iterate	(	std::initializer_list< typename Vec::value_type > const	values,
		Vec	vec ) -> bool

constexpr

Check that iteration works when taking a vector with the given type.

Template Parameters

Vec	The type to take the vector as; intended to be a value type either with const or without

Parameters

values	The values expected to be included in the vector
vec	The vector to check

Returns: true if values and vec have the same contents, false if not

◆ constexpr_non_const_back()

template<typename Vec>

auto arene::base::testing::constexpr_non_const_back ( Vec && vec ) -> typename Vec::value_type

constexpr

◆ constexpr_non_const_front()

template<typename Vec>

auto arene::base::testing::constexpr_non_const_front ( Vec && vec ) -> typename Vec::value_type

constexpr

◆ constexpr_pop_back()

template<typename Vec>

auto arene::base::testing::constexpr_pop_back ( Vec && vec ) -> Vec

constexpr

◆ constexpr_resize()

template<typename Vec>

auto arene::base::testing::constexpr_resize	(	Vec	vec,
		std::size_t	size ) -> Vec

constexpr

◆ constexpr_swap()

template<typename Vec>

auto arene::base::testing::constexpr_swap	(	Vec	lhs,
		Vec	rhs ) -> std::pair<Vec, Vec>

constexpr

◆ contains_duplicates()

template<typename Container>

auto arene::base::testing::contains_duplicates ( Container const & container ) -> bool

constexprnoexcept

Checks whether or not the given container has any duplicates, which we need to assert for test logic.

Template Parameters

Container The type of the container to check

Parameters

container The container to check

Returns: true if container has any duplicate entries, false if every entry is unique

◆ elements_are_array()

template<class Range1, class Range2>

auto arene::base::testing::elements_are_array	(	Range1 const &	range,
		Range2 const &	values ) -> bool

constexpr

Check if all element of range are equal to the elements in values.

Template Parameters

Range1	The type of the range to check
Range2	The type of the value to compare against

Parameters

range	The range to check
values	The values to compare against

This helper is an alternative to GTest matcher ElementsAreArray, which require the values to be copy constructible.

◆ erase_front()

template<class Vec>

auto arene::base::testing::erase_front	(	Vec &&	vec,
		std::size_t	count )

constexpr

◆ MATCHER_P()

arene::base::testing::MATCHER_P	(	elements_match_function	,
		function	,
		""	)

◆ REGISTER_TYPED_TEST_SUITE_P() [1/4]

arene::base::testing::REGISTER_TYPED_TEST_SUITE_P	(	ExternalVectorDeathTest	,
		AddingToInvalidIteratorIsPreconditionViolation	,
		AssignIsPreconditionViolationIfSizeOverCapacity	,
		ConstructWithExcessiveSizeViaNormalConstructIsAlwaysPreconditionViolation	,
		ConstructingWithOutOfRangeSizeAndSourceIsPreconditionViolation	,
		ConstructingWithOutOfRangeSizeIsPreconditionViolation	,
		ConstructingWithTooManyInitializersIsPreconditionViolation	,
		DereferencingInvalidIteratorIsPreconditionViolation	,
		EmplaceBackIsPreconditionViolationIfFull	,
		IndexOperatorOutOfRange	,
		InsertNIsPreconditionViolationIfTooManyItems	,
		InsertWhenAtCapacityIsPreconditionViolation	,
		PushBackBeyondMaxSizeIsPreconditionViolation	,
		PushBackOnZeroSizeVectorIsPreconditionViolation	)

◆ REGISTER_TYPED_TEST_SUITE_P() [2/4]

arene::base::testing::REGISTER_TYPED_TEST_SUITE_P	(	ExternalVectorTest	,
		ADLSwapSwapsContentsForBasicTypes	,
		AfterClearVectorIsEmpty	,
		AfterPushBackCanGetLastElement	,
		AfterPushBackVectorIsNotEmpty	,
		AssignFromInitListUsingAssignFunctionIsConditionallyNoexcept	,
		AssignFromSizeAndValueIsConditionallyNoexcept	,
		AtIndexSizeOrLargerThrows	,
		AtIndexSizeOrLargerThrowsWithConstVec	,
		AtOnConstVectorReturnsConstReference	,
		AtReturnsReference	,
		BackIsNoexcept	,
		BackReturnsReference	,
		CanAccessMultipleValuesWithAt	,
		CanAccessMultipleValuesWithAtWithConstVec	,
		CanAccessMultipleValuesWithIndexOperator	,
		CanAssignFromBiggerCapacityVector	,
		CanAssignFromInitListUsingAssignFunction	,
		CanAssignFromInputIteratorRange	,
		CanAssignFromIteratorRange	,
		CanAssignFromSizeAndValue	,
		CanCompareForOrdering	,
		CanConstructAnEmptyVector	,
		CanConstructFromInitializerList	,
		CanConstructFromIteratorRange	,
		CanConstructWithSize	,
		CanConstructWithSizeAndValue	,
		CanConstructWithSizeViaTryConstruct	,
		CanCopyViaConstruct	,
		CanCopyViaConstructFromLargerWithFewerElements	,
		CanCopyViaConstructFromSmaller	,
		CanCopyViaTryConstruct	,
		CanCopyViaTryConstructFromLargerWithFewerElements	,
		CanCopyViaTryConstructFromSmaller	,
		CanDefaultConstructViaTryConstruct	,
		CanEmplaceBack	,
		CanEraseAtBeginning	,
		CanEraseInMiddle	,
		CanEraseRange	,
		CanGetCBeginAndEnd	,
		CanGetFront	,
		CanGetIterator	,
		CanInsertAtEndOfExistingVector	,
		CanInsertInEmptyVector	,
		CanInsertInMiddleOfExistingVector	,
		CanIterateOverConstValues	,
		CanIterateOverValues	,
		CanMoveViaConstruct	,
		CanMoveViaTryConstruct	,
		CanPopBack	,
		CanPushBackAValue	,
		CanTryConstructFromInitializerList	,
		CanTryConstructFromIteratorRange	,
		CannotConstructWithSizeForANonDefaultConstructibleType	,
		CannotTryConstructWithSizeForANonDefaultConstructibleType	,
		CapacityIsAsSpecified	,
		CapacityIsNoexcept	,
		ConstBackReturnsConstReference	,
		ConstructWithExcessiveSizeViaTryConstructFails	,
		ConstructWithSizeViaNormalConstructWithDefaultConstructorNotNoexceptIsNotNoexcept	,
		ConstructWithSizeViaTryConstructNotNoexceptIfDefaultConstructorNotNoexcept	,
		CopyAssignOverLargerVectorDestroysExcess	,
		CopyAssignOverLargerVectorFromInitListDestroysExcess	,
		CopyAssignOverSmallerVectorCopiesElements	,
		CopyAssignOverSmallerVectorFromInitListCopiesElements	,
		CopyAssignmentIsConditionallyNoexcept	,
		CopyingVectorCopiesElements	,
		Data	,
		DefaultEmplaceIsConditionallyNoexcept	,
		DefaultTryConstructNoexceptEvenIfDefaultConstructorNotNoexcept	,
		EmplaceAtPositionIsConditionallyNoexcept	,
		EmplaceBackIsConditionallyNoexcept	,
		EmplaceInsert	,
		EmptyIfJustStorage	,
		EmptyIsNoexcept	,
		EmptybyDefault	,
		EraseIsNoexceptIfTypeHasNoexceptMove	,
		FailToCopyViaTryConstructFromLargerWithMoreElements	,
		FailToMoveViaTryConstructFromLargerWithMoreElements	,
		IndexOperatorIsNoexcept	,
		IndexOperatorOnConstVectorIsNoexcept	,
		IndexOperatorOnConstVectorReturnsConstReference	,
		IndexOperatorReturnsReference	,
		InitialSizeIsZero	,
		InputIteratorRangeAssignmentIsConditionallyNoexcept	,
		InputIteratorRangeConstructionIsConditionallyNoexcept	,
		InputIteratorRangeTryConstructionIsConditionallyNoexcept	,
		InsertFromIteratorRangeInMiddle	,
		InsertFromIteratorRangeIsConditionallyNoexcept	,
		InsertIsConditionallyNoexcept	,
		InsertNAtEndInsertsElements	,
		InsertNInMiddleInsertsElements	,
		InsertWithCountIsConditionallyNoexcept	,
		IteratorRangeAssignmentIsConditionallyNoexcept	,
		IteratorRangeConstructionIsConditionallyNoexcept	,
		IteratorRangeTryConstructionIsConditionallyNoexcept	,
		IteratorTypedefs	,
		MaxSizeEqualsCapacity	,
		MoveAssignOverLargerVectorDestroysExcess	,
		MoveAssignOverSmallerVectorMovesElements	,
		MoveAssignmentIsConditionallyNoexcept	,
		MovingVectorMovesElements	,
		MovingVectorWithNewStorageMovesElements	,
		NoStorageDataIsNull	,
		NotConstructibleWithSizeAndSourceIfDataNotCopyable	,
		NotCopyConstructible	,
		NotCopyConstructibleIfDataTypeNotCopyConstructible	,
		NotMoveConstructibleIfDataTypeNotMoveConstructible	,
		PopBackIsNoexcept	,
		PushBackIsConditionallyNoexcept	,
		ResizeIsConditionallyNoexcept	,
		ResizeWithValueIsConditionallyNoexcept	,
		ResizingFromLargeToSmallLeavesElements	,
		ResizingFromSmallToLargeConstructsElementsAsCopiesOfSpecified	,
		RetrievingAValueWithAtReturnsValueAfterPushBack	,
		RetrievingAValueWithAtThrowsOnEmpty	,
		ReverseIteration	,
		SecondPushBackChangesLastValue	,
		SizeIsCorrect	,
		SizeIsNoexcept	,
		StorageOnlyTryConstructNoexceptEvenIfDefaultConstructorNotNoexcept	,
		SwapNoexceptMatchesElementType	,
		TryConstructFromTooLargeInitializerListReturnsEmpty	,
		Typedefs	,
		ZeroSizeVectorIsEmpty	)

◆ REGISTER_TYPED_TEST_SUITE_P() [3/4]

arene::base::testing::REGISTER_TYPED_TEST_SUITE_P	(	InlineVectorDeathTest	,
		PushBackBeyondMaxSizeIsPreconditionViolation	,
		PushBackOnZeroSizeVectorIsPreconditionViolation	,
		InsertWhenAtCapacityIsPreconditionViolation	,
		ConstructingWithOutOfRangeSizeIsPreconditionViolation	,
		ConstructingWithOutOfRangeSizeAndSourceIsPreconditionViolation	,
		ConstructingWithTooManyInitializersIsPreconditionViolation	,
		AssignIsPreconditionViolationIfSizeOverCapacity	,
		IndexOperatorOutOfRange	,
		EmplaceBackIsPreconditionViolationIfFull	,
		InsertNIsPreconditionViolationIfTooManyItems	,
		ConstructWithExcessiveSizeViaNormalConstructIsAlwaysPreconditionViolation	,
		DereferencingInvalidIteratorIsPreconditionViolation	,
		AddingToInvalidIteratorIsPreconditionViolation	)

◆ REGISTER_TYPED_TEST_SUITE_P() [4/4]

arene::base::testing::REGISTER_TYPED_TEST_SUITE_P	(	InlineVectorTest	,
		CanConstructAnEmptyVector	,
		CapacityIsAsSpecified	,
		CapacityIsNoexcept	,
		InitialSizeIsZero	,
		SizeIsConstexpr	,
		SizeIsNoexcept	,
		CanPushBackAValue	,
		AfterPushBackCanGetLastElement	,
		AfterPushBackVectorIsNotEmpty	,
		SecondPushBackChangesLastValue	,
		PushBackIsConditionallyNoexceptRvalue	,
		PushBackIsConditionallyNoexceptLvalue	,
		EmptyIsConstexpr	,
		EmptyIsNoexcept	,
		RetrievingAValueWithAtThrowsOnEmpty	,
		RetrievingAValueWithAtReturnsValueAfterPushBack	,
		AtReturnsReference	,
		AtOnConstVectorReturnsConstReference	,
		CanAccessMultipleValuesWithAt	,
		AtIndexSizeOrLargerThrows	,
		CanAccessMultipleValuesWithAtWithConstVec	,
		AtIndexSizeOrLargerThrowsWithConstVec	,
		MaxSizeEqualsCapacity	,
		ZeroSizeVectorIsEmpty	,
		BackReturnsReference	,
		ConstBackReturnsConstReference	,
		BackIsNoexcept	,
		CanPushBack	,
		CanConstructFromInitializerList	,
		CanConstructFromInitializerListConstexpr	,
		CanUseBack	,
		CanGetFront	,
		Front	,
		CanGetIterator	,
		CanIterateOverValues	,
		CanIterateOverConstValues	,
		IteratorTypedefs	,
		Typedefs	,
		Iteration	,
		ConstIteration	,
		CanEraseAtBeginning	,
		CanEraseInMiddle	,
		CanErase	,
		CanEraseRange	,
		CanConstructWithSize	,
		CanConstructWithSizeAndValue	,
		CopyingVectorCopiesElements	,
		MovingVectorMovesElements	,
		CopyAssignOverSmallerVectorCopiesElements	,
		CopyAssignOverLargerVectorDestroysExcess	,
		CopyingIsConditionallyDefined	,
		MoveAssignOverSmallerVectorMovesElements	,
		MoveAssignOverLargerVectorDestroysExcess	,
		MovingIsConditionallyDefined	,
		CanPopBack	,
		PopBackIsNoexcept	,
		PopBackIsUsable	,
		EraseIsNoexceptIfTypeHasNoexceptMove	,
		CanInsertInEmptyVector	,
		CanInsertAtEndOfExistingVector	,
		CanInsertInMiddleOfExistingVector	,
		ResizeZeroCapacityVecToZeroIsOk	,
		ResizeNonZeroCapacityVecToZeroIsOk	,
		ResizeNonZeroCapacityVecToOtherIsOk	,
		ResizeIsConditionallyNoexcept	,
		ResizeWithValueIsConditionallyNoexcept	,
		ResizingFromLargeToSmallLeavesElements	,
		ResizingFromSmallToLargeConstructsElementsAsCopiesOfSpecified	,
		CanInitializeWithSizeAndValue	,
		CanInsert	,
		CanConstructFromIteratorRange	,
		IteratorRangeConstructionIsConditionallyNoexcept	,
		InputIteratorRangeConstructionIsConditionallyNoexcept	,
		CanConstructFromIteratorRangeConstexpr	,
		CopyAssignOverSmallerVectorFromInitListCopiesElements	,
		CopyAssignOverLargerVectorFromInitListDestroysExcess	,
		CanAssignFromIteratorRange	,
		IteratorRangeAssignmentIsConditionallyNoexcept	,
		CanAssignFromInputIteratorRange	,
		InputIteratorRangeAssignmentIsConditionallyNoexcept	,
		CanAssignFromInitListUsingAssignFunction	,
		AssignFromInitListUsingAssignFunctionIsConditionallyNoexcept	,
		CanAssignFromSizeAndValue	,
		AssignFromSizeAndValueIsConditionallyNoexcept	,
		IndexOperatorReturnsReference	,
		IndexOperatorOnConstVectorReturnsConstReference	,
		CanAccessMultipleValuesWithIndexOperator	,
		IndexOperatorIsNoexcept	,
		IndexOperatorOnConstVectorIsNoexcept	,
		IndexOperator	,
		Data	,
		AfterClearVectorIsEmpty	,
		ClearWorks	,
		CanCompareForEquality	,
		CanCompareForOrdering	,
		CanEmplaceBack	,
		CanEmplaceBackConstexpr	,
		EmplaceBackIsConditionallyNoexceptRvalue	,
		EmplaceBackIsConditionallyNoexceptLvalue	,
		EmplaceInsert	,
		CanEmplace	,
		EmplaceAtPositionIsConditionallyNoexceptRvalue	,
		EmplaceAtPositionIsConditionallyNoexceptLvalue	,
		DefaultEmplaceIsConditionallyNoexcept	,
		ADLSwapSwapsContentsForBasicTypes	,
		CanSwap	,
		SwapNoexceptMatchesElementType	,
		InsertRvalueIsConditionallyNoexcept	,
		InsertLvalueIsConditionallyNoexcept	,
		InsertWithCountIsConditionallyNoexcept	,
		InsertNAtEndInsertsElements	,
		InsertNInMiddleInsertsElements	,
		InsertFromIteratorRangeInMiddle	,
		InsertFromIteratorRangeIsConditionallyNoexcept	,
		CanGetCBeginAndEnd	,
		ReverseIteration	,
		CanConstructFromBiggerCapacityVector	,
		CanAssignFromBiggerCapacityVector	,
		CanDefaultConstructViaTryConstruct	,
		CanConstructWithSizeViaTryConstruct	,
		ConstructWithExcessiveSizeViaTryConstructFails	,
		CannotTryConstructWithSizeForANonDefaultConstructibleType	,
		CannotConstructWithSizeForANonDefaultConstructibleType	,
		DefaultTryConstructNoexceptEvenIfDefaultConstructorNotNoexcept	,
		ConstructWithSizeViaTryConstructNotNoexceptIfDefaultConstructorNotNoexcept	,
		ConstructWithSizeViaNormalConstructWithDefaultConstructorNotNoexceptIsNotNoexcept	,
		NotConstructibleWithSizeAndSourceIfDataNotCopyable	,
		NotConstructibleFromInitializerListIfDataTypeNotCopyConstructible	,
		CanTryConstructFromInitializerList	,
		TryConstructFromTooLargeInitializerListReturnsEmpty	,
		CanCopyViaTryConstruct	,
		CanCopyViaConstruct	,
		CanCopyViaTryConstructFromSmaller	,
		CanCopyViaConstructFromSmaller	,
		CanCopyViaTryConstructFromLargerWithFewerElements	,
		FailToCopyViaTryConstructFromLargerWithMoreElements	,
		CanCopyViaConstructFromLargerWithFewerElements	,
		NotCopyConstructibleIfDataTypeNotCopyConstructible	,
		CanMoveViaTryConstruct	,
		CanMoveViaConstruct	,
		FailToMoveViaTryConstructFromLargerWithMoreElements	,
		NotMoveConstructibleIfDataTypeNotMoveConstructible	,
		CanTryConstructFromIteratorRange	,
		IteratorRangeTryConstructionIsConditionallyNoexcept	,
		InputIteratorRangeTryConstructionIsConditionallyNoexcept	)

◆ run_property()

template<class Callable>

auto arene::base::testing::run_property	(	Callable	callable,
		property_config const	config ) -> property_summary

run a property callable against a battery of trials with generated arguments

Template Parameters

Callable function object with a call operator where the first parameter is a reference to the PRNG and whose remaining parameters are generated with generator<T>

Parameters

callable	property to exercise
config	seed and stopping criteria for a property run

Repeatedly invokes callable with generated arguments until one of the following terminal conditions is reached:

a trial reports property_status::failure – the run stops immediately and the failing property_error is captured in property_summary::first_failure;
the number of discarded trials exceeds property_config::max_discards – the run is reported as failed;
property_config::required_successes successful trials have been observed – the run is reported as passing.

Returns: A property_summary describing the outcome: number of successes and discards, whether the property failed, the seed actually used, and (on failure) the first failed property assertion.

Note: Callable is synthesized by the ARENE_PROPERTY or ARENE_TYPED_PROPERTY macro. It is not typically user provided.

◆ sort_helper()

template<typename Container>

auto arene::base::testing::sort_helper ( Container container ) -> Container

constexprnoexcept

sorts the container and then returns it

Template Parameters

Container The type of a container

Parameters

container A container to be sorted

Returns: container with sorted elements

Note: std::sort is not constexpr in C++14; use of arene::base::sort introduces coverage misses

◆ test_deque()

template<typename T>

auto arene::base::testing::test_deque	(	std::size_t	begin,
		std::size_t	end ) -> T

constexprnoexcept

Create a test deque containing a range of test values.

Template Parameters

T	The deque type to create an instance of

Parameters

begin	The first index of test value to put in the deque
end	The after-end index of test value to put in the deque

Returns: An inline_deque<T, Capacity> containing [test_value(begin), test_value(end))

◆ test_external_vector()

template<typename T>

auto arene::base::testing::test_external_vector	(	arene::base::span< arene::base::byte >	storage,
		std::size_t	begin,
		std::size_t	end ) -> ::arene::base::external_vector<T>

constexprnoexcept

Create a test external vector containing a range of test values.

Template Parameters

T	The type to contain in the test vector

Parameters

storage	The storage space to use for the values stored in the vector
begin	The first index of test value to put in the vector
end	The after-end index of test value to put in the vector

Returns: An external_vector<T> containing [test_value(begin), test_value(end))

◆ test_value()

template<typename T>

auto arene::base::testing::test_value ( std::size_t idx ) -> T

constexprnoexcept

Get the idx 'th test value of type T.

Note: The default implementation copies the idx 'th element of test_value_array , wrapping to stay in bounds; For non-copyable types, this function can be specialized to construct the test value without copying

Template Parameters

T	The type to return test values of

Parameters

idx	The index of the test value to be generated

Returns: A test value of type T ; test values with different idx may be different from each other, but may not

◆ test_vector()

template<typename T, std::size_t Capacity>

auto arene::base::testing::test_vector	(	std::size_t	begin,
		std::size_t	end ) -> ::arene::base::inline_vector<T, Capacity>

constexprnoexcept

Create a test vector containing a range of test values.

Template Parameters

T	The type to contain in the test vector
Capacity	The capacity of inline_vector to populate (note: this is not the size / number of actual entries)

Parameters

begin	The first index of test value to put in the vector
end	The after-end index of test value to put in the vector

Returns: An inline_vector<T, Capacity> containing [test_value(begin), test_value(end))

◆ to_array_cast()

template<typename OutType, typename InType, std::size_t Size, constraints< std::enable_if_t<!std::is_array< InType >::value >, std::enable_if_t< std::is_constructible< OutType, InType && >::value > > = nullptr>

auto arene::base::testing::to_array_cast ( InType(&&) arr[Size] ) -> array<base::remove_cvref_t<OutType>, Size>

constexprnoexcept

A version of arene::base::to_array where the individual elements are cast to the specified type.

Template Parameters

OutType	The element type of the output array, specified by the caller
InType	The element type of the input C-array, deduced from the argument
Size	The size of the input and output arrays, deduced from the argument

Parameters

arr	A C-Array containing the values as instances of some type `InType`

Returns: An arene::base::array<OutType, Size> where the elements are constructed from the elements of arr

◆ TYPED_TEST_P() [1/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		AddingToInvalidIteratorIsPreconditionViolation	)

Test: Iterator arithmetic on a default-constructed external_vector iterator terminates the program with a precondition violation

◆ TYPED_TEST_P() [2/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		AssignIsPreconditionViolationIfSizeOverCapacity	)

Test: Invoking the assign member function with a count and a value where the count is larger than the capacity of the vector terminates the program with a precondition violation

◆ TYPED_TEST_P() [3/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		ConstructingWithOutOfRangeSizeAndSourceIsPreconditionViolation	)

Test: Invoking the external_vector constructor with a count and value where the count is larger than the capacity terminates the program with a precondition violation

◆ TYPED_TEST_P() [4/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		ConstructingWithTooManyInitializersIsPreconditionViolation	)

Test: Invoking the external_vector constructor with an initializer list with more elements than the capacity terminates the program with a precondition violation

◆ TYPED_TEST_P() [5/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		DereferencingInvalidIteratorIsPreconditionViolation	)

Test: Dereferencing a default-constructed external_vector iterator terminates the program with a precondition violation

◆ TYPED_TEST_P() [6/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		EmplaceBackIsPreconditionViolationIfFull	)

Test: Invoking emplace_back on an external_vector<T> which has a size equal to its capacity terminates the program with a precondition violation

◆ TYPED_TEST_P() [7/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		IndexOperatorOutOfRange	)

Test: Passing an index that is equal to or larger than the size of the vector terminates the program with a precondition violation

◆ TYPED_TEST_P() [8/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		InsertNIsPreconditionViolationIfTooManyItems	)

Test: Invoking insert with a count and a value to insert more elements than there are remaining spaces in the vector before it exceeds capacity terminates the program with a precondition violation.

◆ TYPED_TEST_P() [9/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		InsertWhenAtCapacityIsPreconditionViolation	)

Test: Invoking insert on an external_vector with size equal to the capacity terminates the program with a precondition violation

◆ TYPED_TEST_P() [10/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		PushBackBeyondMaxSizeIsPreconditionViolation	)

Test: Invoking push_back on a vector that is at capacity terminates the program with a precondition violation.

◆ TYPED_TEST_P() [11/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorDeathTest	,
		PushBackOnZeroSizeVectorIsPreconditionViolation	)

Test: Invoking push_back on a zero-capacity vector terminates the program with a precondition violation

◆ TYPED_TEST_P() [12/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		ADLSwapSwapsContentsForBasicTypes	)

Test: Invoking swap without a namespace qualification on two external_vector instances exchanges the contents, so the elements from one have been moved to the other, and vice-versa.

◆ TYPED_TEST_P() [13/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AfterClearVectorIsEmpty	)

Test: Given an external_vector which is not empty, invoking the clear method makes the vector empty

◆ TYPED_TEST_P() [14/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AfterPushBackCanGetLastElement	)

Test: After using push_back to add an item to a default-constructed external_vector, that item can be retrieved via the back member function

◆ TYPED_TEST_P() [15/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AfterPushBackVectorIsNotEmpty	)

Test: After using push_back to add an item to a default-constructed external_vector, the vector is no longer empty

◆ TYPED_TEST_P() [16/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AssignFromInitListUsingAssignFunctionIsConditionallyNoexcept	)

Test: Assignment of an external_vector from an initializer list is noexcept if the element type of the vector is nothrow-copy-constructible

◆ TYPED_TEST_P() [17/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AssignFromSizeAndValueIsConditionallyNoexcept	)

Test: The assign member function taking a size and a value is not noexcept if the value type is not nothrow-copy-constructible

◆ TYPED_TEST_P() [18/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AtIndexSizeOrLargerThrows	)

Test: The at member function throws when invoked with an index that is equal to or larger than the size of the vector on an external_vector into which two elements have been stored via push_back

◆ TYPED_TEST_P() [19/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AtIndexSizeOrLargerThrowsWithConstVec	)

Test: The at member function throws when invoked via a const reference to a vector with an index that is equal to or larger than the size of an external_vector into which two elements have been stored via push_back

◆ TYPED_TEST_P() [20/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AtOnConstVectorReturnsConstReference	)

Test: The return type of the at member function on a const external_vector is a const reference to value_type

◆ TYPED_TEST_P() [21/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		AtReturnsReference	)

Test: The return type of the at member function on a non-const external_vector is a non-const reference to value_type

◆ TYPED_TEST_P() [22/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		BackIsNoexcept	)

Test: Invoking back cannot throw

◆ TYPED_TEST_P() [23/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		BackReturnsReference	)

Test: Given a default-constructed external_vector, after one element has been added via push_back, back returns a reference to that element. After a second element has been added via push_back, back now returns a reference to the second element.

◆ TYPED_TEST_P() [24/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAccessMultipleValuesWithAt	)

Test: The at member function returns the corresponding value stored when invoked with an index of 0 or 1 on an external_vector into which two elements have been stored via push_back

◆ TYPED_TEST_P() [25/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAccessMultipleValuesWithAtWithConstVec	)

Test: The at member function returns the corresponding value stored when invoked via a const reference to a vector with an index of 0 or 1 on an external_vector into which two elements have been stored via push_back.

◆ TYPED_TEST_P() [26/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAccessMultipleValuesWithIndexOperator	)

Test: Given an external_vector with multiple elements, the index operator can be used with appropriate index values to access each element, and the returned reference is the same as that returned by at given the same index

◆ TYPED_TEST_P() [27/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAssignFromBiggerCapacityVector	)

Test: An external_vector can be assigned from an external_vector with a larger capacity, provided the number of elements in the source vector is less than the capacity of the target vector

◆ TYPED_TEST_P() [28/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAssignFromInitListUsingAssignFunction	)

Test: Invoking the assign member function with an initializer list sets the vector to have a size equal to the number of elements in the initializer list, and each element to be a copy of the corresponding element in the initializer list

◆ TYPED_TEST_P() [29/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAssignFromInputIteratorRange	)

Test: Invoking the assign member function with an iterator range specified using input iterators sets the vector to have a size equal to the number of elements in the range, and each element to be a copy of the corresponding element in the range

◆ TYPED_TEST_P() [30/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAssignFromIteratorRange	)

Test: Invoking the assign member function with an iterator range sets the vector to have a size equal to the number of elements in the range, and each element to be a copy of the corresponding element in the range

◆ TYPED_TEST_P() [31/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanAssignFromSizeAndValue	)

Test: Invoking the assign member function with a count and a value sets the size of the vector to the specified count, where each element is a copy of the supplied value

◆ TYPED_TEST_P() [32/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanConstructAnEmptyVector	)

Test: A default-constructed external_vector is empty

◆ TYPED_TEST_P() [33/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanConstructFromInitializerList	)

Test: An external_vector can be constructed from a std::initializer_list without throwing exceptions, and the size and values stored in the vector are the same as the size and values of the initializer list.

◆ TYPED_TEST_P() [34/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanConstructFromIteratorRange	)

Test: An external_vector can be constructed from an iterator range, creating a vector holding copies of the elements from the source range, with a size equal to the number of elements in the source range

◆ TYPED_TEST_P() [35/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanConstructWithSizeAndValue	)

Test: Constructing an external_vector with a count and a value creates the specified number of elements copy-constructed from the supplied value, and sets the size of the vector to that count.

◆ TYPED_TEST_P() [36/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanCopyViaConstruct	)

Test: Constructing an external_vector with an existing external_vector copies the elements from the source vector

◆ TYPED_TEST_P() [37/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanCopyViaConstructFromLargerWithFewerElements	)

Test: Constructing an external_vector from an existing external_vector with a larger capacity but a size that is less than or equal to the capacity of the destination type copies elements from the source vector

◆ TYPED_TEST_P() [38/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanCopyViaConstructFromSmaller	)

Test: Constructing an external_vector from an existing external_vector with a smaller capacity returns an external_vector with the same elements as the source vector

◆ TYPED_TEST_P() [39/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanCopyViaTryConstruct	)

Test: Invoking try_construct with an existing external_vector returns a copy of that source vector

◆ TYPED_TEST_P() [40/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanCopyViaTryConstructFromLargerWithFewerElements	)

Test: Invoking try_construct with an existing external_vector with a larger capacity but a size that is less than or equal to the capacity of the destination type returns an external_vector with the same elements as the source vector

◆ TYPED_TEST_P() [41/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanCopyViaTryConstructFromSmaller	)

Test: Invoking try_construct with an existing external_vector with a smaller capacity returns an external_vector with the same elements as the source vector

◆ TYPED_TEST_P() [42/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanDefaultConstructViaTryConstruct	)

Test: try_construct can be used to construct an empty external_vector.

◆ TYPED_TEST_P() [43/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanEmplaceBack	)

Test: The emplace_back member function can be used to add an element to an external_vector. The new element is constructed with the arguments supplied to emplace_back

◆ TYPED_TEST_P() [44/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanEraseAtBeginning	)

Test: Given a non-empty external_vector, invoking erase with the iterator returned from begin removes the first element, moving the remaining elements to one lower index and decreasing the size by one, and returns an iterator to the new first element.

◆ TYPED_TEST_P() [45/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanEraseInMiddle	)

Test: Given a non-empty external_vector, invoking erase with an iterator referring to an element that is neither the first or last element removes that element, moves the following elements to one lower index, reduces the size by one, and returns an iterator to the element that replaced the erased element.

◆ TYPED_TEST_P() [46/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanEraseRange	)

Test: Invoking erase with an iterator range referring to elements in the same external_vector, removes those elements, moves the following elements to take their place, and returns an iterator with the same offset from the beginning of the vector as the first erased element

◆ TYPED_TEST_P() [47/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanGetCBeginAndEnd	)

Test: cbegin and cend return const_iterators to the corresponding locations of the external_vector.

◆ TYPED_TEST_P() [48/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanGetFront	)

Test: Given an external_vector initialized from an initializer list, the front member function can be used to retrieve the first value, which must be equal to the first value of the vector as retrieved via at(0)

◆ TYPED_TEST_P() [49/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanGetIterator	)

Test: The begin and end member functions of an external_vector must return an iterator, and they must be equal for a default-constructed vector

◆ TYPED_TEST_P() [50/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanInsertAtEndOfExistingVector	)

Test: Given an external_vector with existing elements, and the iterator returned from end, insert can add an element to the end of the vector, increasing the size by one

◆ TYPED_TEST_P() [51/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanInsertInEmptyVector	)

Test: Given an empty external_vector, and the iterator returned from begin, insert can add an element to the vector, setting the size to one.

◆ TYPED_TEST_P() [52/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanInsertInMiddleOfExistingVector	)

Test: Given an external_vector with existing elements, and an iterator to an existing element in the vector, insert can add an element at the iterator position, increasing the vector size by one. The existing element at the location referenced by the iterator, and the subsequent elements, are moved to make room for the new element.

◆ TYPED_TEST_P() [53/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanIterateOverConstValues	)

Test: Given a const external_vector constructed from an initializer list, the iterators returned from begin and end can be passed as an iterator pair to std::mismatch to compare the values in the vector to those in the initializer list, and the return value of the call to std::mismatch must be the end iterators of the vector and initializer list, to indicate that the values are the same.

◆ TYPED_TEST_P() [54/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanIterateOverValues	)

Test: Given an external_vector constructed from an initializer list, the iterators returned from begin and end can be passed as an iterator pair to std::mismatch to compare the values in the vector to those in the initializer list, and the return value of the call to std::mismatch must be the end iterators of the vector and initializer list, to indicate that the values are the same.

◆ TYPED_TEST_P() [55/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanMoveViaConstruct	)

Test: Constructing an external_vector from an rvalue external_vector move-constructs the elements from the source to the new vector.

◆ TYPED_TEST_P() [56/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanMoveViaTryConstruct	)

Test: Invoking try_construct with an rvalue external_vector constructs a new external_vector, and move-constructs the elements from the source to the new vector.

◆ TYPED_TEST_P() [57/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CannotConstructWithSizeForANonDefaultConstructibleType	)

Test: The external_vector constructor with a number of elements is not considered for overload resolution if the element type of the external_vector<T> is not default-constructible.

◆ TYPED_TEST_P() [58/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CannotTryConstructWithSizeForANonDefaultConstructibleType	)

Test: try_construct with a number of elements is not considered for overload resolution if the element type of the external_vector<T> is not default-constructible.

◆ TYPED_TEST_P() [59/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanPopBack	)

Test: Invoking pop_back on a non-empty external_vector destroys the last element and reduces the size by one.

◆ TYPED_TEST_P() [60/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanPushBackAValue	)

Test: Using push_back to add an item to a default-constructed external_vector increases the size

◆ TYPED_TEST_P() [61/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanTryConstructFromInitializerList	)

Test: Invoking try_construct with an initializer list constructs an external_vector holding copies of the elements from the initializer list

◆ TYPED_TEST_P() [62/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CanTryConstructFromIteratorRange	)

Test: Invoking try_construct with an iterator range returns an external_vector with the same elements as the source range

◆ TYPED_TEST_P() [63/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CapacityIsAsSpecified	)

Test: The capacity of a default-constructed external_vector is equal to the supplied template parameter

◆ TYPED_TEST_P() [64/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CapacityIsNoexcept	)

Test: The capacity member function of external_vector is declared noexcept

◆ TYPED_TEST_P() [65/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		ConstBackReturnsConstReference	)

Test: Given a default-constructed external_vector, after one element has been added via push_back, back called via a const reference to the vector returns a const reference to that element. After a second element has been added via push_back, back called via a const reference to the vector now returns a const reference to the second element.

◆ TYPED_TEST_P() [66/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CopyAssignmentIsConditionallyNoexcept	)

Test: Copy-assignment for external_vector is noexcept if and only if the stored element type is both nothrow-copy-constructible and nothrow-copy-assignable

◆ TYPED_TEST_P() [67/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CopyAssignOverLargerVectorDestroysExcess	)

Test: The external_vector copy-assignment operator destroys the excess elements in the destination when the source vector has fewer elements than the destination vector

◆ TYPED_TEST_P() [68/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CopyAssignOverLargerVectorFromInitListDestroysExcess	)

Test: Given an external_vector holding existing elements, assigning to that vector with an initializer list holding fewer elements copy assigns over the existing elements up to the size of the initializer list, and then destroys a number of elements equal to the difference between the old size of the vector and the size of the initializer list

◆ TYPED_TEST_P() [69/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CopyAssignOverSmallerVectorCopiesElements	)

Test: The external_vector copy-assignment operator uses copy assignment for elements from the source where there is already a corresponding element in the destination, and copy construction for elements that do not have a corresponding element in the destination

◆ TYPED_TEST_P() [70/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CopyAssignOverSmallerVectorFromInitListCopiesElements	)

Test: Given an external_vector holding existing elements, assigning to that vector with an initializer list holding more elements copy assigns over the existing elements, and then copy-constructs new elements to increase the size of the vector to that of the initializer list

◆ TYPED_TEST_P() [71/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		CopyingVectorCopiesElements	)

Test: The external_vector copy constructor copies the stored elements and size from the original vector.

◆ TYPED_TEST_P() [72/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		Data	)

Test: The data member function is noexcept and returns a pointer to the first element of a non-empty vector

◆ TYPED_TEST_P() [73/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		DefaultTryConstructNoexceptEvenIfDefaultConstructorNotNoexcept	)

Test: The default constructor and corresponding try_construct function of external_vector<T> is always noexcept, even if the stored element type's default constructor can throw

◆ TYPED_TEST_P() [74/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		EmplaceAtPositionIsConditionallyNoexcept	)

Test: emplace with a position is noexcept if and only if the element type of the vector is nothrow-move-constructible, nothrow-move-assignable, and nothrow-constructible from the supplied arguments

◆ TYPED_TEST_P() [75/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		EmplaceBackIsConditionallyNoexcept	)

Test: emplace_back is noexcept if and only if the element type of the vector is nothrow-constructible from the supplied arguments

◆ TYPED_TEST_P() [76/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		EmplaceInsert	)

Test: Invoking emplace inserts a new value at the position indicated, constructing the new value with the supplied arguments, and returning an iterator referencing the new value

◆ TYPED_TEST_P() [77/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		EmptybyDefault	)

Test: A default-constructed external_vector is empty

◆ TYPED_TEST_P() [78/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		EmptyIfJustStorage	)

Test: A external_vector constructed with just storage is empty

◆ TYPED_TEST_P() [79/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		EmptyIsNoexcept	)

Test: The empty member function of external_vector is noexcept

◆ TYPED_TEST_P() [80/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		EraseIsNoexceptIfTypeHasNoexceptMove	)

Test: erase is noexcept if and only if the element type has noexcept move operations

◆ TYPED_TEST_P() [81/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		FailToCopyViaTryConstructFromLargerWithMoreElements	)

Test: Invoking try_construct with an existing external_vector with a larger capacity and a size that is larger than the capacity of the destination type returns an empty optional

◆ TYPED_TEST_P() [82/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		FailToMoveViaTryConstructFromLargerWithMoreElements	)

Test: Invoking try_construct with an rvalue external_vector with a larger capacity and a size that is larger than the capacity of the destination storage returns an empty optional

◆ TYPED_TEST_P() [83/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IndexOperatorIsNoexcept	)

Test: The index operator is noexcept

◆ TYPED_TEST_P() [84/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IndexOperatorOnConstVectorIsNoexcept	)

Test: The index operator is noexcept for a const vector

◆ TYPED_TEST_P() [85/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IndexOperatorOnConstVectorReturnsConstReference	)

Test: The index operator for a const vector returns a const reference to the element type of the vector

◆ TYPED_TEST_P() [86/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IndexOperatorReturnsReference	)

Test: The index operator returns a reference to the element type of the vector

◆ TYPED_TEST_P() [87/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InitialSizeIsZero	)

Test: The size of a default-constructed external_vector is zero

◆ TYPED_TEST_P() [88/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InputIteratorRangeAssignmentIsConditionallyNoexcept	)

Test: Assignment of an external_vector from an input iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible from the value type of the iterator

◆ TYPED_TEST_P() [89/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InputIteratorRangeConstructionIsConditionallyNoexcept	)

Test: Construction of an external_vector from an input iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible from the reference type of the iterator

◆ TYPED_TEST_P() [90/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InputIteratorRangeTryConstructionIsConditionallyNoexcept	)

Test: try_construct from an input iterator range is noexcept if the element type of the vector is nothrow-constructible from the iterator's reference type

◆ TYPED_TEST_P() [91/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InsertFromIteratorRangeInMiddle	)

Test: Invoking insert with an iterator referring to an existing element of an external_vector and a source iterator range denoted by a pair of iterators moves the referred to element and subsequent elements to make room, and inserts the elements from the source iterator range prior to the existing element.

◆ TYPED_TEST_P() [92/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InsertFromIteratorRangeIsConditionallyNoexcept	)

Test: insert is noexcept if the element type of the vector is nothrow-constructible from the supplied iterator's reference type, and is nothrow-move-constructible and nothrow-move-assignable

◆ TYPED_TEST_P() [93/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InsertIsConditionallyNoexcept	)

Test: insert is noexcept if the element type of the vector is nothrow-constructible from the supplied value, and is nothrow-move-constructible and nothrow-move-assignable

◆ TYPED_TEST_P() [94/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InsertNAtEndInsertsElements	)

Test: Invoking insert with the end iterator of the external_vector and a count and value appends the specified number of copies of the supplied value to the end of the vector.

◆ TYPED_TEST_P() [95/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InsertNInMiddleInsertsElements	)

Test: Invoking insert with an iterator referring to an existing element of an external_vector and a count and value moves the referred to element and subsequent elements to make room, and inserts the specified number of copies of the supplied value prior to the existing element.

◆ TYPED_TEST_P() [96/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		InsertWithCountIsConditionallyNoexcept	)

Test: insert is noexcept if the element type of the vector is nothrow-copy-constructible, and is nothrow-move-constructible and nothrow-move-assignable

◆ TYPED_TEST_P() [97/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IteratorRangeAssignmentIsConditionallyNoexcept	)

Test: Assignment of an external_vector from an iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible from the reference type of the iterator

◆ TYPED_TEST_P() [98/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IteratorRangeConstructionIsConditionallyNoexcept	)

Test: Construction of an external_vector from an iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible from the reference type of the iterator

◆ TYPED_TEST_P() [99/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IteratorRangeTryConstructionIsConditionallyNoexcept	)

Test: try_construct from an iterator range is noexcept if the element type of the vector is nothrow-constructible from the iterator's reference type

◆ TYPED_TEST_P() [100/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		IteratorTypedefs	)

Test: The iterator type of an external_vector must have the required type aliases for a random-access iterator.

◆ TYPED_TEST_P() [101/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		MaxSizeEqualsCapacity	)

Test: The max_size member function of external_vector returns the capacity of the storage

◆ TYPED_TEST_P() [102/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		MoveAssignmentIsConditionallyNoexcept	)

Test: Move-assignment for external_vector is noexcept if and only if the value type is nothrow-move-constructible and nothrow-move-assignable

◆ TYPED_TEST_P() [103/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		MoveAssignOverLargerVectorDestroysExcess	)

Test: The external_vector move-assignment operator destroys the excess elements in the destination when the source vector has fewer elements than the destination vector

◆ TYPED_TEST_P() [104/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		MoveAssignOverSmallerVectorMovesElements	)

Test: The external_vector move-assignment operator uses move assignment for elements from the source where there is already a corresponding element in the destination, and move construction for elements that do not have a corresponding element in the destination

◆ TYPED_TEST_P() [105/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		MovingVectorMovesElements	)

Test: The external_vector move constructor moves the stored elements from the original vector

◆ TYPED_TEST_P() [106/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		MovingVectorWithNewStorageMovesElements	)

Test: The external_vector move constructor with new storage moves the stored elements from the original vector

◆ TYPED_TEST_P() [107/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		NoStorageDataIsNull	)

Test: With no storage, data returns a null pointer

◆ TYPED_TEST_P() [108/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		NotConstructibleWithSizeAndSourceIfDataNotCopyable	)

Test: The overload of try_construct that takes a size and source value is not considered for overload resolution if the element type of the external_vector<T> is not copy-constructible.

◆ TYPED_TEST_P() [109/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		NotCopyConstructible	)

Test: external_vector is not copy-constructible

◆ TYPED_TEST_P() [110/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		NotCopyConstructibleIfDataTypeNotCopyConstructible	)

Test: external_vector is constructible with storage and an old vector if and only if the data type is copy-constructible

◆ TYPED_TEST_P() [111/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		NotMoveConstructibleIfDataTypeNotMoveConstructible	)

Test: external_vector is not move constructible if the element type is not move constructible

◆ TYPED_TEST_P() [112/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		PopBackIsNoexcept	)

Test: pop_back is declared noexcept

◆ TYPED_TEST_P() [113/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		PushBackIsConditionallyNoexcept	)

Test: push_back is noexcept if and only if the value type can be constructed without throwing

◆ TYPED_TEST_P() [114/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		ResizeWithValueIsConditionallyNoexcept	)

Test: resize with a value to copy is noexcept if and only if the copy constructor of the element type is noexcept

◆ TYPED_TEST_P() [115/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		ResizingFromLargeToSmallLeavesElements	)

Test: Invoking the resize member function with a size and a value on a vector with more elements than the specified size sets the size of the vector to the specified count and does not construct new elements

◆ TYPED_TEST_P() [116/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		ResizingFromSmallToLargeConstructsElementsAsCopiesOfSpecified	)

Test: Invoking the resize member function with a size and a value on a vector with fewer elements than the specified size sets the size of the vector to the specified count, and constructs a number of new elements equal to the difference between the specified size and the previous size by copy-construction from the specified value

◆ TYPED_TEST_P() [117/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		RetrievingAValueWithAtReturnsValueAfterPushBack	)

Test: The at member function returns the value stored when invoked with an index of 0 on a external_vector into which one element has been stored via push_back

◆ TYPED_TEST_P() [118/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		RetrievingAValueWithAtThrowsOnEmpty	)

Test: The at member function throws a std::out_of_range exception when invoked with an index of 0 on a default-constructed external_vector

◆ TYPED_TEST_P() [119/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		ReverseIteration	)

Test: rbegin, rend, crbegin and crend return reverse iterators to the appropriate locations in the external_vector, such that iteration forwards from rbegin or crbegin iterates through the elements of the external_vector in reverse order.

◆ TYPED_TEST_P() [120/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		SecondPushBackChangesLastValue	)

Test: After using push_back twice to add two items to a default-constructed external_vector, the size is incremented to 2, and the second item can be retrieved via the back member function

◆ TYPED_TEST_P() [121/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		SizeIsCorrect	)

Test: The size of an external_vector initialized from a list of values is correct

◆ TYPED_TEST_P() [122/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		SizeIsNoexcept	)

Test: The size member function of external_vector is declared noexcept

◆ TYPED_TEST_P() [123/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		StorageOnlyTryConstructNoexceptEvenIfDefaultConstructorNotNoexcept	)

Test: The constructor with just storage and corresponding try_construct function of external_vector<T> is always noexcept, even if the stored element type's default constructor can throw

◆ TYPED_TEST_P() [124/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		SwapNoexceptMatchesElementType	)

Test: Swapping two external_vectors is noexcept if and only if the element type is nothrow swappable

◆ TYPED_TEST_P() [125/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		TryConstructFromTooLargeInitializerListReturnsEmpty	)

Test: Invoking try_construct with an initializer list holding more elements than the capacity of the external_vector returns an empty optional

◆ TYPED_TEST_P() [126/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		Typedefs	)

Test: external_vector must have the required type aliases for a sequence container

◆ TYPED_TEST_P() [127/206]

arene::base::testing::TYPED_TEST_P	(	ExternalVectorTest	,
		ZeroSizeVectorIsEmpty	)

Test: The size of a default-constructed vector with a capacity of zero is zero, when obtained via the size member function, and via comparing the iterators returned from begin and end

◆ TYPED_TEST_P() [128/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorDeathTest	,
		AddingToInvalidIteratorIsPreconditionViolation	)

Test: Iterator arithmetic on a default-constructed inline_vector iterator terminates the program with a precondition violation

◆ TYPED_TEST_P() [129/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorDeathTest	,
		DereferencingInvalidIteratorIsPreconditionViolation	)

Test: Dereferencing a default-constructed inline_vector iterator terminates the program with a precondition violation

◆ TYPED_TEST_P() [130/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorDeathTest	,
		EmplaceBackIsPreconditionViolationIfFull	)

Test: Invoking emplace_back on an inline_vector<T> which has a size equal to its capacity terminates the program with a precondition violation

◆ TYPED_TEST_P() [131/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorDeathTest	,
		IndexOperatorOutOfRange	)

Test: Passing an index that is equal to or larger than the size of the vector terminates the program with a precondition violation

◆ TYPED_TEST_P() [132/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorDeathTest	,
		PushBackBeyondMaxSizeIsPreconditionViolation	)

Test: Invoking push_back on a vector that is at capacity terminates the program with a precondition violation.

◆ TYPED_TEST_P() [133/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorDeathTest	,
		PushBackOnZeroSizeVectorIsPreconditionViolation	)

Test: Invoking push_back on a zero-capacity vector terminates the program with a precondition violation

◆ TYPED_TEST_P() [134/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		ADLSwapSwapsContentsForBasicTypes	)

Test: Invoking swap without a namespace qualification on two inline_vector instances exchanges the contents, so the elements from one have been moved to the other, and vice-versa.

◆ TYPED_TEST_P() [135/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AfterClearVectorIsEmpty	)

Test: Given an inline_vector which is not empty, invoking the clear method makes the vector empty

◆ TYPED_TEST_P() [136/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AfterPushBackCanGetLastElement	)

Test: After using push_back to add an item to a default-constructed inline_vector, that item can be retrieved via the back member function

◆ TYPED_TEST_P() [137/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AfterPushBackVectorIsNotEmpty	)

Test: After using push_back to add an item to a default-constructed inline_vector, the vector is no longer empty

◆ TYPED_TEST_P() [138/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AssignFromInitListUsingAssignFunctionIsConditionallyNoexcept	)

Test: Assignment of an inline_vector from an initializer list is noexcept if the element type of the vector is nothrow-copy-constructible

◆ TYPED_TEST_P() [139/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AtIndexSizeOrLargerThrows	)

Test: The at member function throws when invoked with an index that is equal to or larger than the size of the vector on an inline_vector into which two elements have been stored via push_back

◆ TYPED_TEST_P() [140/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AtIndexSizeOrLargerThrowsWithConstVec	)

Test: The at member function throws when invoked via a const reference to a vector with an index that is equal to or larger than the size of an inline_vector into which two elements have been stored via push_back

◆ TYPED_TEST_P() [141/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AtOnConstVectorReturnsConstReference	)

Test: The return type of the at member function on a const inline_vector is a const reference to value_type

◆ TYPED_TEST_P() [142/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		AtReturnsReference	)

Test: The return type of the at member function on a non-const inline_vector is a non-const reference to value_type

◆ TYPED_TEST_P() [143/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		BackIsNoexcept	)

Test: Invoking back cannot throw

◆ TYPED_TEST_P() [144/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		BackReturnsReference	)

Test: Given a default-constructed inline_vector, after one element has been added via push_back, back returns a reference to that element. After a second element has been added via push_back, back now returns a reference to the second element.

◆ TYPED_TEST_P() [145/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanAssignFromInputIteratorRange	)

Test: Invoking the assign member function with an iterator range specified using input iterators sets the vector to have a size equal to the number of elements in the range, and each element to be a copy of the corresponding element in the range

◆ TYPED_TEST_P() [146/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanAssignFromIteratorRange	)

Test: Invoking the assign member function with an iterator range sets the vector to have a size equal to the number of elements in the range, and each element to be a copy of the corresponding element in the range

◆ TYPED_TEST_P() [147/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructAnEmptyVector	)

Test: A default-constructed inline_vector is empty

◆ TYPED_TEST_P() [148/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanConstructFromIteratorRange	)

Test: An inline_vector can be constructed from an iterator range, creating a vector by moving the elements from the source range, with a size equal to the number of elements in the source range

◆ TYPED_TEST_P() [149/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanDefaultConstructViaTryConstruct	)

Test: try_construct can be used to construct an empty inline_vector.

◆ TYPED_TEST_P() [150/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanEmplaceBack	)

Test: The emplace_back member function can be used to add an element to an inline_vector. The new element is constructed with the arguments supplied to emplace_back

◆ TYPED_TEST_P() [151/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanEraseAtBeginning	)

Test: Given a non-empty inline_vector, invoking erase with the iterator returned from begin removes the first element, moving the remaining elements to one lower index and decreasing the size by one, and returns an iterator to the new first element.

◆ TYPED_TEST_P() [152/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanGetCBeginAndEnd	)

Test: cbegin and cend return const_iterators to the corresponding locations of the inline_vector.

◆ TYPED_TEST_P() [153/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanGetFront	)

Test: Given an inline_vector initialized by pushing back values, the front member function can be used to retrieve the first value, which must be equal to the first value of the vector as retrieved via at(0)

◆ TYPED_TEST_P() [154/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanGetIterator	)

Test: The begin and end member functions of an inline_vector must return an iterator, and they must be equal for a default-constructed vector

◆ TYPED_TEST_P() [155/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanInsertInEmptyVector	)

Test: Given an empty inline_vector, and the iterator returned from begin, insert can add an element to the vector, setting the size to one.

◆ TYPED_TEST_P() [156/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanIterateOverConstValues	)

Test: Given a const inline_vector constructed by pushing back values, the iterators returned from begin and end can be passed as an iterator pair to arene::base::equal to compare the values in the vector to those in the initializer list, which must return true, to indicate that the values are the same.

◆ TYPED_TEST_P() [157/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanIterateOverValues	)

Test: Given an inline_vector constructed by pushing back values, the iterators returned from begin and end can be passed as an iterator pair to arene::base::equal to compare the values in the vector to those in the initializer list, which must return true, to indicate that the values are the same.

◆ TYPED_TEST_P() [158/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanMoveViaConstruct	)

Test: Constructing an inline_vector from an rvalue inline_vector move-constructs the elements from the source to the new vector.

◆ TYPED_TEST_P() [159/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanMoveViaTryConstruct	)

Test: Invoking try_construct with an rvalue inline_vector constructs a new inline_vector, and move-constructs the elements from the source to the new vector.

◆ TYPED_TEST_P() [160/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CannotConstructWithSizeForANonDefaultConstructibleType	)

Test: The inline_vector constructor with a number of elements is not considered for overload resolution if the element type of the inline_vector<T> is not default-constructible.

◆ TYPED_TEST_P() [161/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CannotTryConstructWithSizeForANonDefaultConstructibleType	)

Test: try_construct with a number of elements is not considered for overload resolution if the element type of the inline_vector<T> is not default-constructible.

◆ TYPED_TEST_P() [162/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanPopBack	)

Test: Invoking pop_back on a non-empty inline_vector destroys the last element and reduces the size by one.

◆ TYPED_TEST_P() [163/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanPushBackAValue	)

Test: Using push_back to add an item to a default-constructed inline_vector increases the size

◆ TYPED_TEST_P() [164/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CanTryConstructFromIteratorRange	)

Test: Invoking try_construct with an iterator range returns an inline_vector with the same elements as the source range

◆ TYPED_TEST_P() [165/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CapacityIsAsSpecified	)

Test: The capacity of a default-constructed inline_vector is equal to the supplied template parameter

◆ TYPED_TEST_P() [166/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CapacityIsNoexcept	)

Test: The capacity member function of inline_vector is declared noexcept

◆ TYPED_TEST_P() [167/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		ConstBackReturnsConstReference	)

Test: Given a default-constructed inline_vector, after one element has been added via push_back, back called via a const reference to the vector returns a const reference to that element. After a second element has been added via push_back, back called via a const reference to the vector now returns a const reference to the second element.

◆ TYPED_TEST_P() [168/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		CopyingIsConditionallyDefined	)

Test: Copy-assignment for inline_vector is noexcept if and only if the stored element type is both nothrow-copy-constructible and nothrow-copy-assignable

◆ TYPED_TEST_P() [169/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		Data	)

Test: The data member function is noexcept and returns a pointer to the first element of a non-empty vector

◆ TYPED_TEST_P() [170/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		DefaultTryConstructNoexceptEvenIfDefaultConstructorNotNoexcept	)

Test: The default constructor and corresponding try_construct function of inline_vector<T> is always noexcept, even if the stored element type's default constructor can throw

◆ TYPED_TEST_P() [171/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		EmplaceAtPositionIsConditionallyNoexceptRvalue	)

Test: emplace with a position is noexcept if and only if the element type of the vector is nothrow-move-constructible, nothrow-move-assignable, and nothrow-constructible from the supplied arguments

◆ TYPED_TEST_P() [172/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		EmplaceBackIsConditionallyNoexceptRvalue	)

Test: emplace_back is noexcept if and only if the element type of the vector is nothrow-constructible from the supplied arguments

◆ TYPED_TEST_P() [173/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		EmplaceInsert	)

Test: Invoking emplace inserts a new value at the position indicated, constructing the new value with the supplied arguments, and returning an iterator referencing the new value

◆ TYPED_TEST_P() [174/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		EmptyIsConstexpr	)

Test: A default-constructed inline_vector is empty in a constexpr context

◆ TYPED_TEST_P() [175/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		EmptyIsNoexcept	)

Test: The empty member function of inline_vector is noexcept

◆ TYPED_TEST_P() [176/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		EraseIsNoexceptIfTypeHasNoexceptMove	)

Test: erase is noexcept if and only if the element type has noexcept move assignment

◆ TYPED_TEST_P() [177/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		FailToMoveViaTryConstructFromLargerWithMoreElements	)

Test: Invoking try_construct with an rvalue inline_vector with a larger capacity and a size that is larger than the capacity of the destination type returns an empty optional

◆ TYPED_TEST_P() [178/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		IndexOperatorIsNoexcept	)

Test: The index operator is noexcept

◆ TYPED_TEST_P() [179/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		IndexOperatorOnConstVectorIsNoexcept	)

Test: The index operator is noexcept for a const vector

◆ TYPED_TEST_P() [180/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		IndexOperatorOnConstVectorReturnsConstReference	)

Test: The index operator for a const vector returns a const reference to the element type of the vector

◆ TYPED_TEST_P() [181/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		IndexOperatorReturnsReference	)

Test: The index operator returns a reference to the element type of the vector

◆ TYPED_TEST_P() [182/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		InitialSizeIsZero	)

Test: The size of a default-constructed inline_vector is zero

◆ TYPED_TEST_P() [183/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		InputIteratorRangeConstructionIsConditionallyNoexcept	)

Test: Construction of an inline_vector from an input iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible from the reference type of the iterator

◆ TYPED_TEST_P() [184/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		InsertRvalueIsConditionallyNoexcept	)

Test: insert of an rvalue is noexcept if the element type of the vector is nothrow-constructible from the supplied value, and is nothrow-move-constructible and nothrow-move-assignable

◆ TYPED_TEST_P() [185/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		IteratorRangeAssignmentIsConditionallyNoexcept	)

Test: Assignment of an inline_vector from an iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible and nothrow-assignable from the reference type of the iterator

◆ TYPED_TEST_P() [186/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		IteratorRangeConstructionIsConditionallyNoexcept	)

Test: Construction of an inline_vector from an iterator range is noexcept if operations on the iterator are noexcept and the element type of the vector is nothrow-constructible from the reference type of the iterator

◆ TYPED_TEST_P() [187/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		IteratorTypedefs	)

Test: The iterator type of an inline_vector must have the required type aliases for a random-access iterator.

◆ TYPED_TEST_P() [188/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		MaxSizeEqualsCapacity	)

Test: The max_size member function of inline_vector returns the capacity specified as a template parameter.

◆ TYPED_TEST_P() [189/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		MoveAssignOverLargerVectorDestroysExcess	)

Test: The inline_vector move-assignment operator destroys the excess elements in the destination when the source vector has fewer elements than the destination vector

◆ TYPED_TEST_P() [190/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		MoveAssignOverSmallerVectorMovesElements	)

Test: The inline_vector move-assignment operator uses move assignment for elements from the source where there is already a corresponding element in the destination, and move construction for elements that do not have a corresponding element in the destination

◆ TYPED_TEST_P() [191/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		MovingIsConditionallyDefined	)

Test: Move-assignment for inline_vector is noexcept if and only if the value type is nothrow-move-constructible and nothrow-move-assignable

◆ TYPED_TEST_P() [192/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		MovingVectorMovesElements	)

Test: The inline_vector move constructor moves the stored elements from the original vector

◆ TYPED_TEST_P() [193/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		NotConstructibleFromInitializerListIfDataTypeNotCopyConstructible	)

Test: The overload of try_construct that takes an initializer list is not considered for overload resolution if the element type of the inline_vector is not copy-constructible.

◆ TYPED_TEST_P() [194/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		NotConstructibleWithSizeAndSourceIfDataNotCopyable	)

Test: The overload of try_construct that takes a size and source value is not considered for overload resolution if the element type of the inline_vector<T> is not copy-constructible.

◆ TYPED_TEST_P() [195/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		NotCopyConstructibleIfDataTypeNotCopyConstructible	)

Test: inline_vector is not copy-constructible if the data type is not copy-constructible

◆ TYPED_TEST_P() [196/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		NotMoveConstructibleIfDataTypeNotMoveConstructible	)

Test: inline_vector is not move constructible if the element type is not move constructible

◆ TYPED_TEST_P() [197/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		PopBackIsNoexcept	)

Test: pop_back is declared noexcept

◆ TYPED_TEST_P() [198/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		PushBackIsConditionallyNoexceptRvalue	)

Test: push_back of an rvalue is noexcept if and only if the value type can be constructed without throwing from an rvalue

◆ TYPED_TEST_P() [199/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		RetrievingAValueWithAtReturnsValueAfterPushBack	)

Test: The at member function returns the value stored when invoked with an index of 0 on a inline_vector into which one element has been stored via push_back

◆ TYPED_TEST_P() [200/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		RetrievingAValueWithAtThrowsOnEmpty	)

Test: The at member function throws a std::out_of_range exception when invoked with an index of 0 on a default-constructed inline_vector

◆ TYPED_TEST_P() [201/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		ReverseIteration	)

Test: rbegin, rend, crbegin and crend return reverse iterators to the appropriate locations in the inline_vector, such that iteration forwards from rbegin or crbegin iterates through the elements of the inline_vector in reverse order.

◆ TYPED_TEST_P() [202/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		SizeIsConstexpr	)

Test: The size of an inline_vector initialized from a list of values is correct in a constexpr context

◆ TYPED_TEST_P() [203/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		SizeIsNoexcept	)

Test: The size member function of inline_vector is declared noexcept

◆ TYPED_TEST_P() [204/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		SwapNoexceptMatchesElementType	)

Test: Swapping two inline_vectors is noexcept if and only if the element type is nothrow swappable AND the element type is nothrow move constructible

◆ TYPED_TEST_P() [205/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		Typedefs	)

Test: inline_vector must have the required type aliases for a sequence container

◆ TYPED_TEST_P() [206/206]

arene::base::testing::TYPED_TEST_P	(	InlineVectorTest	,
		ZeroSizeVectorIsEmpty	)

Test: The size of a default-constructed vector with a capacity of zero is zero, when obtained via the size member function, and via comparing the iterators returned from begin and end

◆ TYPED_TEST_SUITE_P() [1/4]

arene::base::testing::TYPED_TEST_SUITE_P ( ExternalVectorDeathTest )

◆ TYPED_TEST_SUITE_P() [2/4]

arene::base::testing::TYPED_TEST_SUITE_P ( ExternalVectorTest )

◆ TYPED_TEST_SUITE_P() [3/4]

arene::base::testing::TYPED_TEST_SUITE_P ( InlineVectorDeathTest )

◆ TYPED_TEST_SUITE_P() [4/4]

arene::base::testing::TYPED_TEST_SUITE_P ( InlineVectorTest )

◆ unique_test_value()

template<class T, std::size_t N>

auto arene::base::testing::unique_test_value ( ) ->

constexprnoexcept

obtain the nth unique arene::base::testing::test_value

Template Parameters

T	the type to return the test values of
N	the index of the test value to obtain

Returns: arene::base::testing::test_value<T>(n)

Obtains test_value<T>(n) and ensures that the values test_value<T>(0), ..., test_value<T>(n) are unique.

If the values are not unique and this can be determined at compile-time, this function fails to compile.

If the values are not unique and this cannot be determined at compile-time, a call to this function calls std::terminate.

Note: Requires test_value<T> to be regular invocable

◆ vector_push_back()

template<class Vector, class... Values>

auto arene::base::testing::vector_push_back	(	Vector &	vec,
		Values &&...	values ) -> void

constexpr

Push back multiple values into a vector.

Template Parameters

Vector	The type of the vector
Values	The type of the values

Parameters

vec	The vector to push back into
values	the values to push back

Variable Documentation

◆ ExternalVectorTest< T >::capacity

template<typename T>

std::size_t arene::base::testing::ExternalVectorTest< T >::capacity

constexpr

◆ has_constexpr_test_value

template<typename T, typename = std::integral_constant<bool, true>>

bool arene::base::testing::has_constexpr_test_value = false

constexpr

Check whether or not a given type's test_value function works in constexpr contexts.

Template Parameters

T	The type to check

◆ has_constexpr_test_value< T, std::integral_constant< bool,(test_value< T >(0), true)> >

template<typename T>

bool arene::base::testing::has_constexpr_test_value< T, std::integral_constant< bool,(test_value< T >(0), true)> > = true

constexpr

Check whether or not a given type's test_value function works in constexpr contexts.

Template Parameters

T	The type to check

◆ is_copyable_v

template<class T>

auto arene::base::testing::is_copyable_v = std::is_copy_assignable<T>::value && std::is_copy_constructible<T>::value

constexpr

True if a type is copy constructible and copy assignable, false otherwise.

Parameters

T	the type to check

◆ is_fully_comparable_v

template<typename T>

bool arene::base::testing::is_fully_comparable_v

constexpr

Initial value:

= is_less_than_comparable_v<T> && is_less_than_or_equal_comparable_v<T> &&

is_greater_than_comparable_v<T> && is_greater_than_or_equal_comparable_v<T>

arene::base::is_greater_than_or_equal_comparable_v

constexpr bool is_greater_than_or_equal_comparable_v

arene::base::is_less_than_comparable_v

constexpr bool is_less_than_comparable_v

arene::base::is_less_than_or_equal_comparable_v

constexpr bool is_less_than_or_equal_comparable_v

arene::base::is_greater_than_comparable_v

constexpr bool is_greater_than_comparable_v

A type trait to tell if the given type parameter is fully comparable or not for the purposes of these tests

Template Parameters

T	The type to check

◆ is_list_initializable_v

template<typename T, typename ElementType, typename = constraints<>>

bool arene::base::testing::is_list_initializable_v {false}

constexpr

A type trait to check if a type is list-initializable using a brace-enclosed list of values with a given type.

Template Parameters

T	Type to check
ElementType	Type to use for the elements of the brace-enclosed initializer list

◆ test_initializer_list

template<typename T, std::size_t... Indices>

customization_detail::init_list_holder<T, has_constexpr_test_value<T>, Indices...> arene::base::testing::test_initializer_list {}

externconstexpr

A function object returning a std::initializer_list of one test_value per index in the given pack.

Template Parameters

T	The type for which an initializer list is requested
Indices	A pack of indices, one for each test value in the initializer list

Returns: A copy of a statically-allocated std::initializer_list<T> containing one test value per index

◆ test_value_array

template<typename T, typename = ::arene::base::constraints<>>

::arene::base::array<T, 0UL> arene::base::testing::test_value_array {}

extern

An array used in the default implementation of test_value ; by default it's empty and unusable.

Note: This must be explicitly specialized to be usable; specializations can use different array sizes

Template Parameters

T	The type of which this is an array of test values

◆ test_value_array< T, ::arene::base::constraints< std::enable_if_t< std::is_floating_point< T >::value > > >

template<typename T>

auto arene::base::testing::test_value_array< T, ::arene::base::constraints< std::enable_if_t< std::is_floating_point< T >::value > > >

externconstexpr

Initial value:

=

to_array_cast<T>({0.0, -1.0, 3.14, 2.72, 1.41, 0.577})

arene::base::testing::to_array_cast

constexpr auto to_array_cast(InType(&&arr)[Size]) noexcept(std::is_nothrow_constructible< OutType, InType && >::value) -> array< base::remove_cvref_t< OutType >, Size >

A version of arene::base::to_array where the individual elements are cast to the specified type.

Definition customization.hpp:73

A partial specialization of test_value_array for built-in floating point numbers to make it easier to use.

Template Parameters

T	The type of which this is an array of test values

◆ test_value_array< T, ::arene::base::constraints< std::enable_if_t< std::is_integral< T >::value >, std::enable_if_t< std::is_signed< T >::value > > >

template<typename T>

auto arene::base::testing::test_value_array< T, ::arene::base::constraints< std::enable_if_t< std::is_integral< T >::value >, std::enable_if_t< std::is_signed< T >::value > > >

externconstexpr

Initial value:

=

to_array_cast<T>({1, -2, 6, -24, 120, -720, 5'040, -40'320, 362'880, -3'628'800})

A partial specialization of test_value_array for built-in signed integers to make it easier to use.

Template Parameters

T	The type of which this is an array of test values

◆ test_value_array< T, ::arene::base::constraints< std::enable_if_t< std::is_integral< T >::value >, std::enable_if_t< std::is_unsigned< T >::value > > >

template<typename T>

auto arene::base::testing::test_value_array< T, ::arene::base::constraints< std::enable_if_t< std::is_integral< T >::value >, std::enable_if_t< std::is_unsigned< T >::value > > >

externconstexpr

Initial value:

=

to_array_cast<T>({0U, 8U, 19U, 6612U, 777124U, 7U, 609124U, 1224545862U, 2561U, 976173U})

A partial specialization of test_value_array for built-in unsigned integers to make it easier to use.

Template Parameters

T	The type of which this is an array of test values