diff options
Diffstat (limited to 'test/source/TestExtra.cpp')
| -rw-r--r-- | test/source/TestExtra.cpp | 1554 |
1 files changed, 0 insertions, 1554 deletions
diff --git a/test/source/TestExtra.cpp b/test/source/TestExtra.cpp deleted file mode 100644 index 52fbd62..0000000 --- a/test/source/TestExtra.cpp +++ /dev/null @@ -1,1554 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// Copyright (c) Electronic Arts Inc. All rights reserved. -///////////////////////////////////////////////////////////////////////////// - - -///////////////////////////////////////////////////////////////////////////// -// Test forward delcarations -///////////////////////////////////////////////////////////////////////////// - -namespace eastl -{ - class allocator; - - template <typename T, typename Allocator> class basic_string; - typedef basic_string<char, allocator> local_string8; // collides with eastl::string8 in bulkbuilds - - template <typename T> struct local_less {}; - - static void UseForwardDeclaredString(local_string8*) - { - } - - - template <typename T, typename Allocator> class vector; - typedef vector<char, allocator> vector8; - - static void UseForwardDeclaredVector(vector8*) - { - } - - - template <typename Value, typename Hash, typename Predicate, typename Allocator, bool bCacheHashCode> class hash_set; - typedef hash_set<char, char, local_less<char>, allocator, false> hash_set8; - - static void UseForwardDeclaredHashSet(hash_set8*) - { - } - - - template <typename Key, typename T, typename Compare, typename Allocator> class map; - typedef map<char, char, local_less<char>, allocator> map8; - - static void UseForwardDeclaredMap(map8*) - { - } -} - - -#include "EASTLTest.h" -#include <EASTL/functional.h> -#include <EASTL/utility.h> -#include <EASTL/memory.h> -#include <EASTL/allocator.h> -#include <EASTL/allocator_malloc.h> -#include <EASTL/fixed_allocator.h> -#include <EASTL/intrusive_list.h> -#include <EASTL/numeric.h> -#include <EASTL/queue.h> -#include <EASTL/priority_queue.h> -#include <EASTL/stack.h> -#include <EASTL/heap.h> -#include <EASTL/vector.h> -#include <EASTL/deque.h> -#include <EASTL/list.h> -#include <EASTL/map.h> -#include <EASTL/string.h> -#include <EASTL/hash_set.h> -#include <EASTL/random.h> -#include <EASTL/bit.h> -#include <EASTL/core_allocator_adapter.h> -#include <EASTL/bonus/call_traits.h> -#include <EASTL/bonus/compressed_pair.h> -#include <EASTL/bonus/adaptors.h> -#include <EAStdC/EAAlignment.h> -#include <EAStdC/EAMemory.h> -#include <EAStdC/EAString.h> - -#ifdef _MSC_VER - #pragma warning(push, 0) -#endif - -#include <stdio.h> -#include <string.h> - -#ifndef EA_COMPILER_NO_STANDARD_CPP_LIBRARY - #include <algorithm> - #include <utility> - #include <stack> - #include <queue> - #include <vector> - #include <deque> - #include <math.h> -#endif - -#if defined(_MSC_VER) - #pragma warning(pop) -#endif - - - -using namespace eastl; - - - -namespace -{ - /// IntNode - /// - /// Test intrusive_list node. - /// - struct IntNode : public eastl::intrusive_list_node - { - int mX; - - IntNode(int x = 0) - : mX(x) { } - - operator int() const - { return mX; } - }; - - bool operator<(const IntNode& a, const IntNode& b) - { return a.mX < b.mX; } -} - - - - - - -struct TestClass -{ - mutable int mX; - - TestClass() : mX(37) { } - - void Increment() - { - mX++; - } - - void IncrementConst() const - { - mX++; - } - - int MultiplyBy(int x) - { - return mX * x; - } - - int MultiplyByConst(int x) const - { - return mX * x; - } -}; - - - - -/////////////////////////////////////////////////////////////////////////////// -// TestForwardDeclarations -// -static int TestForwardDeclarations() -{ - int nErrorCount = 0; - - eastl::local_string8 s8; - UseForwardDeclaredString(&s8); - - eastl::vector8 v8; - UseForwardDeclaredVector(&v8); - - eastl::hash_set8 h8; - UseForwardDeclaredHashSet(&h8); - - eastl::map8 m8; - UseForwardDeclaredMap(&m8); - - return nErrorCount; -} - - - - -/////////////////////////////////////////////////////////////////////////////// -// fixed_pool_reference -// -struct fixed_pool_reference -{ -public: - fixed_pool_reference(const char* = NULL) - { - mpFixedPool = NULL; - } - - fixed_pool_reference(eastl::fixed_pool& fixedPool) - { - mpFixedPool = &fixedPool; - } - - fixed_pool_reference(const fixed_pool_reference& x) - { - mpFixedPool = x.mpFixedPool; - } - - fixed_pool_reference& operator=(const fixed_pool_reference& x) - { - mpFixedPool = x.mpFixedPool; - return *this; - } - - void* allocate(size_t /*n*/, int /*flags*/ = 0) - { - return mpFixedPool->allocate(); - } - - void* allocate(size_t /*n*/, size_t /*alignment*/, size_t /*offset*/, int /*flags*/ = 0) - { - return mpFixedPool->allocate(); - } - - void deallocate(void* p, size_t /*n*/) - { - return mpFixedPool->deallocate(p); - } - - const char* get_name() const - { - return "fixed_pool_reference"; - } - - void set_name(const char* /*pName*/) - { - } - -protected: - friend bool operator==(const fixed_pool_reference& a, const fixed_pool_reference& b); - friend bool operator!=(const fixed_pool_reference& a, const fixed_pool_reference& b); - - eastl::fixed_pool* mpFixedPool; -}; - - -inline bool operator==(const fixed_pool_reference& a, const fixed_pool_reference& b) -{ - return (a.mpFixedPool == b.mpFixedPool); -} - -inline bool operator!=(const fixed_pool_reference& a, const fixed_pool_reference& b) -{ - return (a.mpFixedPool != b.mpFixedPool); -} - - - - - -// Template instantations. -// These tell the compiler to compile all the functions for the given class. -template class eastl::queue<int, deque<int> >; -template class eastl::queue<Align64, deque<Align64> >; -template class eastl::queue<TestObject, list<TestObject> >; -//template class eastl::queue<IntNode, intrusive_list<IntNode> >;// This test has been disabled as of the addition of initializer_list support to eastl::queue. initializer_lists have const nodes, which is incompatible with intrusive_list. You can use eastl::queue<IntNode, intrusive_list<IntNode> > as long as you don't use initializer_list with it. The problem with this line of code is that it forces compilation of the entire class. - - -/////////////////////////////////////////////////////////////////////////////// -// TestQueue -// -static int TestQueue() -{ - int nErrorCount = 0; - - { - // Exercise IntNode. - IntNode x, y; - EATEST_VERIFY((x < y) || !(x < y) || ((int)x < (int)y)); - } - - TestObject::Reset(); - - { - // queue(const Sequence& x = Sequence()); - queue<TestObject, list<TestObject>> toListQueue; - queue<TestObject, list<TestObject>> toListQueue2; - - - // global operators - EATEST_VERIFY( (toListQueue == toListQueue2)); - EATEST_VERIFY(!(toListQueue != toListQueue2)); - EATEST_VERIFY( (toListQueue <= toListQueue2)); - EATEST_VERIFY( (toListQueue >= toListQueue2)); - EATEST_VERIFY(!(toListQueue < toListQueue2)); - EATEST_VERIFY(!(toListQueue > toListQueue2)); - - // bool empty() const; - // size_type size() const; - EATEST_VERIFY(toListQueue.empty()); - EATEST_VERIFY(toListQueue.size() == 0); - - - // void push(const value_type& value); - // reference front(); - // const_reference front() const; - // reference back(); - // const_reference back() const; - toListQueue.push(TestObject(0)); - EATEST_VERIFY(toListQueue.front() == TestObject(0)); - EATEST_VERIFY(toListQueue.back() == TestObject(0)); - - toListQueue.push(TestObject(1)); - EATEST_VERIFY(toListQueue.front() == TestObject(0)); - EATEST_VERIFY(toListQueue.back() == TestObject(1)); - - toListQueue.push(TestObject(2)); - EATEST_VERIFY(toListQueue.front() == TestObject(0)); - EATEST_VERIFY(toListQueue.back() == TestObject(2)); - EATEST_VERIFY(!toListQueue.empty()); - EATEST_VERIFY(toListQueue.size() == 3); - - - // void pop(); - toListQueue.pop(); - EATEST_VERIFY(toListQueue.front() == TestObject(1)); - EATEST_VERIFY(toListQueue.back() == TestObject(2)); - - toListQueue.pop(); - EATEST_VERIFY(toListQueue.front() == TestObject(2)); - EATEST_VERIFY(toListQueue.back() == TestObject(2)); - - toListQueue.pop(); - EATEST_VERIFY(toListQueue.empty()); - EATEST_VERIFY(toListQueue.size() == 0); - - - // decltype(auto) emplace(Args&&... args); - toListQueue.emplace(1); - EATEST_VERIFY(!toListQueue.empty()); - EATEST_VERIFY(toListQueue.front() == TestObject(1)); - EATEST_VERIFY(toListQueue.size() == 1); - - - // container_type& get_container(); - // const container_type& get_container() const; - list<TestObject>& ref = toListQueue.get_container(); - EATEST_VERIFY(ref.size() == toListQueue.size()); - - - // queue(std::initializer_list<value_type> ilist); - queue<int> intQueue = { 3, 4, 5 }; - EATEST_VERIFY(intQueue.size() == 3); - EATEST_VERIFY(intQueue.front() == 3); - intQueue.pop(); - EATEST_VERIFY(intQueue.front() == 4); - intQueue.pop(); - EATEST_VERIFY(intQueue.front() == 5); - } - -#if defined(EA_COMPILER_HAS_THREE_WAY_COMPARISON) - { - // queue(const Sequence& x = Sequence()); - queue<TestObject, list<TestObject>> toListQueue; - queue<TestObject, list<TestObject>> toListQueue2; - - - // global operators - EATEST_VERIFY( ((toListQueue <=> toListQueue2) == 0)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) != 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) <= 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) >= 0)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) < 0)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) > 0)); - - // bool empty() const; - // size_type size() const; - EATEST_VERIFY(toListQueue.empty()); - EATEST_VERIFY(toListQueue.size() == 0); - - // Verify toListQueue > toListQueue2 - toListQueue.push(TestObject(0)); - toListQueue.push(TestObject(1)); - toListQueue2.push(TestObject(0)); - - EATEST_VERIFY(!((toListQueue <=> toListQueue2) == 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) != 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) >= 0)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) <= 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) > 0)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) < 0)); - - // Verify toListQueue2 > toListQueue by element size - toListQueue2.push(TestObject(3)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) == 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) != 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) <= 0)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) >= 0)); - EATEST_VERIFY( ((toListQueue <=> toListQueue2) < 0)); - EATEST_VERIFY(!((toListQueue <=> toListQueue2) > 0)); - - queue<TestObject, list<TestObject>> toListQueue3; - queue<TestObject, list<TestObject>> toListQueue4; - - for (int i = 0; i < 10; i++) - { - toListQueue3.push(TestObject(i)); - if (i < 5) - toListQueue4.push(TestObject(i)); - } - - // Verify toListQueue4 is a strict subset of toListQueue3 - EATEST_VERIFY(!((toListQueue3 <=> toListQueue4) == 0)); - EATEST_VERIFY( ((toListQueue3 <=> toListQueue4) != 0)); - EATEST_VERIFY( ((toListQueue3 <=> toListQueue4) >= 0)); - EATEST_VERIFY(!((toListQueue3 <=> toListQueue4) <= 0)); - EATEST_VERIFY( ((toListQueue3 <=> toListQueue4) > 0)); - EATEST_VERIFY(!((toListQueue3 <=> toListQueue4) < 0)); - - // Verify that even thoughn toListQueue4 has a smaller size, it's lexicographically larger - toListQueue4.push(TestObject(11)); - EATEST_VERIFY(!((toListQueue3 <=> toListQueue4) == 0)); - EATEST_VERIFY( ((toListQueue3 <=> toListQueue4) != 0)); - EATEST_VERIFY( ((toListQueue3 <=> toListQueue4) <= 0)); - EATEST_VERIFY(!((toListQueue3 <=> toListQueue4) >= 0)); - EATEST_VERIFY( ((toListQueue3 <=> toListQueue4) < 0)); - EATEST_VERIFY(!((toListQueue3 <=> toListQueue4) > 0)); - - } - - { - queue<TestObject, list<TestObject>> toListQueue1; - queue<TestObject, list<TestObject>> toListQueue2; - queue<TestObject, list<TestObject>> toListQueue3; - - for (int i = 0; i < 10; i++) - { - toListQueue1.push(TestObject(i)); - toListQueue2.push(TestObject(9-i)); - if (i < 5) - toListQueue3.push(TestObject(i)); - } - - struct weak_ordering_queue - { - queue<TestObject, list<TestObject>> queue; - inline std::weak_ordering operator<=>(const weak_ordering_queue& b) const { return queue <=> b.queue; } - }; - - EATEST_VERIFY(synth_three_way{}(weak_ordering_queue{toListQueue1}, weak_ordering_queue{toListQueue2}) == std::weak_ordering::less); - EATEST_VERIFY(synth_three_way{}(weak_ordering_queue{toListQueue3}, weak_ordering_queue{toListQueue1}) == std::weak_ordering::less); - EATEST_VERIFY(synth_three_way{}(weak_ordering_queue{toListQueue2}, weak_ordering_queue{toListQueue1}) == std::weak_ordering::greater); - EATEST_VERIFY(synth_three_way{}(weak_ordering_queue{toListQueue2}, weak_ordering_queue{toListQueue3}) == std::weak_ordering::greater); - EATEST_VERIFY(synth_three_way{}(weak_ordering_queue{toListQueue1}, weak_ordering_queue{toListQueue1}) == std::weak_ordering::equivalent); - } - #endif - - { - vector<TestObject> toVector; - for(int i = 0; i < 100; i++) - toVector.push_back(TestObject(i)); - - // template <class Allocator> - // queue(this_type&& x, const Allocator& allocator, typename eastl::enable_if<eastl::uses_allocator<container_type, Allocator>::value>::type* = NULL); - // - // explicit queue(container_type&& x); - // - // void push(value_type&& x); - - queue<TestObject, vector<TestObject> > toQ_0; - queue<TestObject, vector<TestObject> > toQ_A(eastl::move(toQ_0), toQ_0.get_container().get_allocator()); // It would be better if we also tested an alternative allocator. - EATEST_VERIFY(toQ_A.size() == 0); - toQ_A.push(TestObject(1000)); - EATEST_VERIFY(toQ_A.size() == 1); - - queue<TestObject, vector<TestObject> > toQ_B(eastl::move(toQ_A), toQ_A.get_container().get_allocator()); // It would be better if we also tested an alternative allocator. - EATEST_VERIFY((toQ_B.size() == 1) && toQ_A.empty()); - - eastl::vector<TestObject> toVectorM(toVector); - queue<TestObject, vector<TestObject> > toQ_C(eastl::move(toVectorM)); - EATEST_VERIFY((toQ_C.size() == toVector.size()) && toVectorM.empty()); - - // template <class... Args> - // void emplace_back(Args&&... args); - - queue<TestObject, vector<TestObject> > toQ_D; - toQ_D.emplace(0, 1, 2); - EATEST_VERIFY(toQ_D.size() == 1) && (toQ_D.back() == TestObject(0, 1, 2)); - } - - - { // Test std namespace elements contained in queue - #ifndef EA_COMPILER_NO_STANDARD_CPP_LIBRARY - eastl::queue< std::pair<int, int> > stlQueue; - stlQueue.push(std::make_pair(1, 1)); - EATEST_VERIFY(stlQueue.size() == 1); - #endif - } - - - EATEST_VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - - return nErrorCount; -} - - - - - - -// Template instantations. -// These tell the compiler to compile all the functions for the given class. -template class eastl::priority_queue<int, vector<int> >; -template class eastl::priority_queue<Align64, deque<Align64> >; -template class eastl::priority_queue<TestObject, vector<TestObject> >; -template class eastl::priority_queue<float, vector<float>, less<float> >; - - -/////////////////////////////////////////////////////////////////////////////// -// TestPriorityQueue -// -static int TestPriorityQueue() -{ - int nErrorCount = 0; - - EASTLTest_Rand rng(EA::UnitTest::GetRandSeed()); - - TestObject::Reset(); - - { - less<TestObject> toLess; - - vector<TestObject> toVector; - for(int i = 0; i < 100; i++) - toVector.push_back(TestObject(i)); - random_shuffle(toVector.begin(), toVector.end(), rng); - - list<TestObject> toList; - for(eastl_size_t j = 0; j < 100; j++) - toList.push_back(toVector[j]); - - - // priority_queue(const Compare& compare = Compare(), const Sequence& x = Sequence()); - // template <typename InputIterator> - // priority_queue(InputIterator first, InputIterator last, const Compare& compare = Compare(), const Sequence& x = Sequence()); - priority_queue<TestObject, vector<TestObject> > toPQ; - priority_queue<TestObject, vector<TestObject> > toPQV(toLess, toVector); - priority_queue<TestObject, vector<TestObject> > toPQL(toList.begin(), toList.end()); - - EATEST_VERIFY(toPQ.empty()); - EATEST_VERIFY(toPQ.size() == 0); - - EATEST_VERIFY(!toPQV.empty()); - EATEST_VERIFY( toPQV.size() == toVector.size()); - - EATEST_VERIFY(!toPQL.empty()); - EATEST_VERIFY( toPQL.size() == toList.size()); - - - // global operators - EATEST_VERIFY( (toPQ != toPQL)); - EATEST_VERIFY( (toPQV == toPQL)); - EATEST_VERIFY(!(toPQV != toPQL)); - EATEST_VERIFY( (toPQV <= toPQL)); - EATEST_VERIFY( (toPQV >= toPQL)); - EATEST_VERIFY(!(toPQV < toPQL)); - EATEST_VERIFY(!(toPQV > toPQL)); - - - // container_type& get_container(); - // const container_type& get_container() const; - vector<TestObject>& ref = toPQL.get_container(); - EATEST_VERIFY(ref.size() == toPQL.size()); - EATEST_VERIFY(is_heap(ref.begin(), ref.end())); - - // bool validate() const; - EATEST_VERIFY(toPQL.validate()); - // To consider: Verify that validate detects an invalid heap. - // Testing this might be an issue if the validation function actively complains in some way. - - - // const_reference top() const; - // void pop(); - const TestObject& to1 = toPQL.top(); - EATEST_VERIFY(to1 == TestObject(99)); - - toPQL.pop(); - EATEST_VERIFY(!toPQL.empty()); - EATEST_VERIFY( toPQL.size() == toList.size() - 1); - EATEST_VERIFY(to1 == TestObject(98)); - EATEST_VERIFY(is_heap(ref.begin(), ref.end())); - - - // void push(const value_type& value); - toPQL.push(TestObject(1000)); - EATEST_VERIFY(toPQL.size() == toList.size()); - const TestObject& to2 = toPQL.top(); - EATEST_VERIFY(to2 == TestObject(1000)); - toPQL.pop(); - const TestObject& to3 = toPQL.top(); - EATEST_VERIFY(to3 == TestObject(98)); - EATEST_VERIFY(is_heap(ref.begin(), ref.end())); - - - // void change(size_type n); - TestObject& to4 = ref[50]; - to4 = TestObject(2000); - toPQL.change(50); - const TestObject& to5 = toPQL.top(); - EATEST_VERIFY(to5 == TestObject(2000)); - EATEST_VERIFY(is_heap(ref.begin(), ref.end())); - - - // void remove(size_type n); - TestObject to6 = ref[20]; - toPQL.remove(20); - EATEST_VERIFY( toPQL.size() == toList.size() - 2); - TestObject& to7 = ref[20]; - EATEST_VERIFY(!(to6 == to7)); - EATEST_VERIFY(is_heap(ref.begin(), ref.end())); - - - // priority_queue(std::initializer_list<value_type> ilist, const compare_type& compare = compare_type()); - #if !defined(EA_COMPILER_NO_INITIALIZER_LISTS) - priority_queue<int, vector<int> > intPQ = { 3, 4, 5 }; - EATEST_VERIFY(intPQ.size() == 3); - EATEST_VERIFY(intPQ.top() == 5); - intPQ.pop(); - EATEST_VERIFY(intPQ.top() == 4); - intPQ.pop(); - EATEST_VERIFY(intPQ.top() == 3); - #endif - } - - { - vector<TestObject> toVector; - for(int i = 0; i < 100; i++) - toVector.push_back(TestObject(i)); - - // template <class Allocator> - // priority_queue(this_type&& x, const Allocator& allocator, typename eastl::enable_if<eastl::uses_allocator<container_type, Allocator>::value>::type* = NULL); - // - // explicit priority_queue(const compare_type& compare, container_type&& x); - // - // template <class InputIterator> - // priority_queue(InputIterator first, InputIterator last, const compare_type& compare, container_type&& x); - // - // void push(value_type&& x); - - priority_queue<TestObject, vector<TestObject> > toPQ_0; - priority_queue<TestObject, vector<TestObject> > toPQ_A(toPQ_0.get_container().begin(), toPQ_0.get_container().begin(), eastl::less<TestObject>(), toPQ_0.get_container()); - EATEST_VERIFY(toPQ_A.size() == 0); - toPQ_A.push(TestObject(1000)); - EATEST_VERIFY(toPQ_A.size() == 1); - - priority_queue<TestObject, vector<TestObject> > toPQ_B(eastl::move(toPQ_A), toPQ_A.get_container().get_allocator()); // It would be better if we also tested an alternative allocator. - EATEST_VERIFY((toPQ_B.size() == 1) && toPQ_A.empty()); - - eastl::vector<TestObject> toVectorM(toVector); - priority_queue<TestObject, vector<TestObject> > toPQ_C(eastl::less<TestObject>(), eastl::move(toVectorM)); - EATEST_VERIFY((toPQ_C.size() == toVector.size()) && toVectorM.empty()); - - // template <class... Args> - // void emplace(Args&&... args); - priority_queue<TestObject, vector<TestObject> > toPQ_D; - toPQ_D.emplace(0, 1, 2); - EATEST_VERIFY(toPQ_D.size() == 1) && (toPQ_D.top() == TestObject(0, 1, 2)); - } - - - EATEST_VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - - return nErrorCount; -} - - - - - - -// Template instantations. -// These tell the compiler to compile all the functions for the given class. -template class eastl::stack<int, vector<int> >; -template class eastl::stack<Align64, list<Align64> >; -template class eastl::stack<TestObject, vector<TestObject> >; -//template class eastl::stack<IntNode, intrusive_list<IntNode> >; // This test has been disabled as of the addition of initializer_list support to eastl::stack. initializer_lists have const nodes, which is incompatible with intrusive_list. You can use eastl::stack<IntNode, intrusive_list<IntNode> > as long as you don't use initializer_list with it. The problem with this line of code is that it forces compilation of the entire class. - - -/////////////////////////////////////////////////////////////////////////////// -// TestStack -// -static int TestStack() -{ - int nErrorCount = 0; - - TestObject::Reset(); - - { - // stack(const Sequence& x = Sequence()); - stack<TestObject, list<TestObject> > toListStack; - stack<TestObject, list<TestObject> > toListStack2; - - - // bool empty() const; - // size_type size() const; - EATEST_VERIFY(toListStack.empty()); - EATEST_VERIFY(toListStack.size() == 0); - - - // global operators - EATEST_VERIFY( (toListStack == toListStack2)); - EATEST_VERIFY(!(toListStack != toListStack2)); - EATEST_VERIFY( (toListStack <= toListStack2)); - EATEST_VERIFY( (toListStack >= toListStack2)); - EATEST_VERIFY(!(toListStack < toListStack2)); - EATEST_VERIFY(!(toListStack > toListStack2)); - - // void push(const value_type& value); - // reference top(); - // const_reference top() const; - toListStack.push(TestObject(0)); - EATEST_VERIFY(toListStack.top() == TestObject(0)); - - toListStack.push(TestObject(1)); - EATEST_VERIFY(toListStack.top() == TestObject(1)); - - toListStack.push(TestObject(2)); - EATEST_VERIFY( toListStack.top() == TestObject(2)); - EATEST_VERIFY(!toListStack.empty()); - EATEST_VERIFY( toListStack.size() == 3); - - // void pop(); - toListStack.pop(); - EATEST_VERIFY(toListStack.top() == TestObject(1)); - - toListStack.pop(); - EATEST_VERIFY(toListStack.top() == TestObject(0)); - - toListStack.pop(); - EATEST_VERIFY(toListStack.empty()); - EATEST_VERIFY(toListStack.size() == 0); - - - // container_type& get_container(); - // const container_type& get_container() const; - list<TestObject>& ref = toListStack.get_container(); - EATEST_VERIFY(ref.size() == toListStack.size()); - - - // stack(std::initializer_list<value_type> ilist); - #if !defined(EA_COMPILER_NO_INITIALIZER_LISTS) - stack<int> intStack = { 3, 4, 5 }; - EATEST_VERIFY(intStack.size() == 3); - EATEST_VERIFY(intStack.top() == 5); - intStack.pop(); - EATEST_VERIFY(intStack.top() == 4); - intStack.pop(); - EATEST_VERIFY(intStack.top() == 3); - #endif - } - -#if defined(EA_COMPILER_HAS_THREE_WAY_COMPARISON) - { - // stack(const Sequence& x = Sequence()); - stack<TestObject, list<TestObject> > toListStack; - stack<TestObject, list<TestObject> > toListStack2; - - // bool empty() const; - // size_type size() const; - EATEST_VERIFY(toListStack.empty()); - EATEST_VERIFY(toListStack.size() == 0); - - - // global operators - EATEST_VERIFY( ((toListStack <=> toListStack2) == 0)); - EATEST_VERIFY(!((toListStack <=> toListStack2) != 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) <= 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) >= 0)); - EATEST_VERIFY(!((toListStack <=> toListStack2) < 0)); - EATEST_VERIFY(!((toListStack <=> toListStack2) > 0)); - - toListStack.push(TestObject(0)); - toListStack.push(TestObject(1)); - toListStack2.push(TestObject(0)); - - EATEST_VERIFY(!((toListStack <=> toListStack2) == 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) != 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) >= 0)); - EATEST_VERIFY(!((toListStack <=> toListStack2) <= 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) > 0)); - EATEST_VERIFY(!((toListStack <=> toListStack2) < 0)); - - // Verify toListStack2 > toListStack by element size - toListStack2.push(TestObject(3)); - EATEST_VERIFY(!((toListStack <=> toListStack2) == 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) != 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) <= 0)); - EATEST_VERIFY(!((toListStack <=> toListStack2) >= 0)); - EATEST_VERIFY( ((toListStack <=> toListStack2) < 0)); - EATEST_VERIFY(!((toListStack <=> toListStack2) > 0)); - - stack<TestObject, list<TestObject> > toListStack3; - stack<TestObject, list<TestObject> > toListStack4; - - for (int i = 0; i < 10; i++) - { - toListStack3.push(TestObject(i)); - if (i < 5) - toListStack4.push(TestObject(i)); - } - - // Verify toListStack4 is a strict subset of toListStack3 - EATEST_VERIFY(!((toListStack3 <=> toListStack4) == 0)); - EATEST_VERIFY( ((toListStack3 <=> toListStack4) != 0)); - EATEST_VERIFY( ((toListStack3 <=> toListStack4) >= 0)); - EATEST_VERIFY(!((toListStack3 <=> toListStack4) <= 0)); - EATEST_VERIFY( ((toListStack3 <=> toListStack4) > 0)); - EATEST_VERIFY(!((toListStack3 <=> toListStack4) < 0)); - - // Verify that even thoughn toListQueue4 has a smaller size, it's lexicographically larger - toListStack4.push(TestObject(11)); - EATEST_VERIFY(!((toListStack3 <=> toListStack4) == 0)); - EATEST_VERIFY( ((toListStack3 <=> toListStack4) != 0)); - EATEST_VERIFY( ((toListStack3 <=> toListStack4) <= 0)); - EATEST_VERIFY(!((toListStack3 <=> toListStack4) >= 0)); - EATEST_VERIFY( ((toListStack3 <=> toListStack4) < 0)); - EATEST_VERIFY(!((toListStack3 <=> toListStack4) > 0)); - } - - { - stack<TestObject, list<TestObject> > toListStack1; - stack<TestObject, list<TestObject> > toListStack2; - stack<TestObject, list<TestObject> > toListStack3; - - for (int i = 0; i < 10; i++) - { - toListStack1.push(TestObject(i)); - toListStack2.push(TestObject(9-i)); - if (i < 5) - toListStack3.push(TestObject(i)); - } - - struct weak_ordering_stack - { - stack<TestObject, list<TestObject> > stack; - inline std::weak_ordering operator<=>(const weak_ordering_stack& b) const { return stack <=> b.stack; } - }; - - EATEST_VERIFY(synth_three_way{}(weak_ordering_stack{toListStack1}, weak_ordering_stack{toListStack2}) == std::weak_ordering::less); - EATEST_VERIFY(synth_three_way{}(weak_ordering_stack{toListStack3}, weak_ordering_stack{toListStack1}) == std::weak_ordering::less); - EATEST_VERIFY(synth_three_way{}(weak_ordering_stack{toListStack2}, weak_ordering_stack{toListStack1}) == std::weak_ordering::greater); - EATEST_VERIFY(synth_three_way{}(weak_ordering_stack{toListStack2}, weak_ordering_stack{toListStack3}) == std::weak_ordering::greater); - EATEST_VERIFY(synth_three_way{}(weak_ordering_stack{toListStack1}, weak_ordering_stack{toListStack1}) == std::weak_ordering::equivalent); - } -#endif - - - { - vector<TestObject> toVector; - for(int i = 0; i < 100; i++) - toVector.push_back(TestObject(i)); - - // template <class Allocator> - // stack(this_type&& x, const Allocator& allocator, typename eastl::enable_if<eastl::uses_allocator<container_type, Allocator>::value>::type* = NULL); - // - // explicit stack(container_type&& x); - // - // void push(value_type&& x); - stack<TestObject, vector<TestObject> > toS_0; - stack<TestObject, vector<TestObject> > toS_A(eastl::move(toS_0), toS_0.get_container().get_allocator()); // It would be better if we also tested an alternative allocator. - EATEST_VERIFY(toS_A.size() == 0); - toS_A.push(TestObject(1000)); - EATEST_VERIFY(toS_A.size() == 1); - - stack<TestObject, vector<TestObject> > toS_B(eastl::move(toS_A), toS_A.get_container().get_allocator()); // It would be better if we also tested an alternative allocator. - EATEST_VERIFY((toS_B.size() == 1) && toS_A.empty()); - - eastl::vector<TestObject> toVectorM(toVector); - stack<TestObject, vector<TestObject> > toS_C(eastl::move(toVectorM)); - EATEST_VERIFY((toS_C.size() == toVector.size()) && toVectorM.empty()); - - { - // template <class... Args> - // void emplace_back(Args&&... args); - stack<TestObject, vector<TestObject>> toS_D; - toS_D.emplace_back(0, 1, 2); - EATEST_VERIFY(toS_D.size() == 1) && (toS_D.top() == TestObject(0, 1, 2)); - } - - { - // template <class... Args> - // decltype(auto) emplace(Args&&... args); - stack<TestObject, vector<TestObject>> toS_D; - auto it = toS_D.emplace(0, 1, 2); - EATEST_VERIFY(toS_D.size() == 1) && (toS_D.top() == TestObject(0, 1, 2)); - EATEST_VERIFY(it == TestObject(0, 1, 2)); - } - } - - - EATEST_VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - - return nErrorCount; -} - - - - - -struct Size0 -{ - // Empty -}; - -struct Size4 -{ - uint32_t m32; -}; - - -/////////////////////////////////////////////////////////////////////////////// -// TestCompressedPair -// -static int TestCompressedPair() -{ - int nErrorCount = 0; - - compressed_pair<Size0, Size0> cp00; - compressed_pair<Size0, Size4> cp04; - compressed_pair<Size4, Size0> cp40; - compressed_pair<Size4, Size4> cp44; - - EATEST_VERIFY(sizeof(cp00) <= 4); - EATEST_VERIFY(sizeof(cp04) <= 4); - EATEST_VERIFY(sizeof(cp40) <= 4); - EATEST_VERIFY(sizeof(cp44) <= 8); - - return nErrorCount; -} - - - - - - -template <typename T> -struct CallTraitsContainer -{ - typedef typename eastl::call_traits<T>::param_type param_type; - typedef typename eastl::call_traits<T>::reference reference; - typedef typename eastl::call_traits<T>::const_reference const_reference; - typedef typename eastl::call_traits<T>::value_type result_type; - typedef T value_type; - -public: - value_type mValue; - - - CallTraitsContainer() { } - CallTraitsContainer(param_type p) : mValue(p) { } - - CallTraitsContainer<T>& operator=(const CallTraitsContainer<T>&) { } // Defined simply to prevent possible compiler warnings. - - result_type value() { return mValue; } - - reference get() { return mValue; } - const_reference const_get() const { return mValue; } - - void call(param_type p){ } -}; - - -/////////////////////////////////////////////////////////////////////////////// -// TestCallTraits -// -static int TestCallTraits() -{ - int nErrorCount = 0; - - CallTraitsContainer<int> ctcInt; - CallTraitsContainer<int*> ctcIntPtr; - CallTraitsContainer<int&> ctcVoid(nErrorCount); - CallTraitsContainer<int[3]> ctcIntArray; - - char buffer[128]; - sprintf(buffer, "%p %p %p %p", &ctcInt, &ctcIntPtr, &ctcVoid, &ctcIntArray); - - return nErrorCount; -} - - -static int AccumulateMultiply(int x, int y) -{ - return (x * y); -} - -static eastl::string AccumulateString(eastl::string s, int x) -{ - s += '0' + static_cast<char>(x); - return s; -} - - - -/////////////////////////////////////////////////////////////////////////////// -// TestNumeric -// -static int TestNumeric() -{ - int nErrorCount = 0; - - //template <typename InputIterator, typename T> - //T accumulate(InputIterator first, InputIterator last, T init); - eastl::vector<int> v(5, 0); - eastl::generate(v.begin(), v.end(), GenerateIncrementalIntegers<int>(1)); - - int sum = eastl::accumulate(v.begin(), v.end(), 100); - EATEST_VERIFY(sum == (100 + 1 + 2 + 3 + 4 + 5)); - - - // template <typename InputIterator, typename T, typename BinaryOperation> - //T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op); - - eastl::generate(v.begin(), v.end(), GenerateIncrementalIntegers<int>(1)); - int product = eastl::accumulate(v.begin(), v.end(), 100, AccumulateMultiply); - EATEST_VERIFY(product == (100 * 1 * 2 * 3 * 4 * 5)); - - eastl::generate(v.begin(), v.end(), GenerateIncrementalIntegers<int>(1)); - eastl::string s = eastl::accumulate(v.begin(), v.end(), eastl::string("0"), AccumulateString); - EATEST_VERIFY(s == "012345"); - - - //template <typename InputIterator1, typename InputIterator2, typename T> - //T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); - // To do. - - //template <typename InputIterator1, typename InputIterator2, typename T, typename BinaryOperation1, typename BinaryOperation2> - //T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2) - // To do. - - //template <typename InputIterator, typename OutputIterator> - //OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result); - // To do. - - //template <typename InputIterator, typename OutputIterator, typename BinaryOperation> - //OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); - // To do. - - return nErrorCount; -} - -#if defined(EA_COMPILER_CPP20_ENABLED) -template <typename T> -static constexpr int SignedIntMidpoint() -{ - int nErrorCount = 0; - - EATEST_VERIFY(eastl::midpoint(T(0), T(0)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(0), T(2)) == T(1)); - EATEST_VERIFY(eastl::midpoint(T(0), T(4)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(0), T(8)) == T(4)); - EATEST_VERIFY(eastl::midpoint(T(2), T(0)) == T(1)); - EATEST_VERIFY(eastl::midpoint(T(4), T(0)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(8), T(0)) == T(4)); - - EATEST_VERIFY(eastl::midpoint(T(1), T(1)) == T(1)); - EATEST_VERIFY(eastl::midpoint(T(1), T(3)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(3), T(1)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(2), T(6)) == T(4)); - EATEST_VERIFY(eastl::midpoint(T(6), T(2)) == T(4)); - - EATEST_VERIFY(eastl::midpoint(T(-1), T(-1)) == T(-1)); - EATEST_VERIFY(eastl::midpoint(T(-1), T(-3)) == T(-2)); - EATEST_VERIFY(eastl::midpoint(T(-3), T(-1)) == T(-2)); - EATEST_VERIFY(eastl::midpoint(T(-2), T(-6)) == T(-4)); - EATEST_VERIFY(eastl::midpoint(T(-6), T(-2)) == T(-4)); - - EATEST_VERIFY(eastl::midpoint(T(-0), T(0)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(0), T(-0)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(-0), T(-0)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(-1), T(1)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(-10), T(10)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(-3), T(7)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(-7), T(3)) == T(-2)); - EATEST_VERIFY(eastl::midpoint(T(-2), T(6)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(-6), T(2)) == T(-2)); - EATEST_VERIFY(eastl::midpoint(T(2), T(-6)) == T(-2)); - EATEST_VERIFY(eastl::midpoint(T(6), T(-2)) == T(2)); - - // If an odd sum, midpoint should round towards the LHS operand. - EATEST_VERIFY(eastl::midpoint(T(0), T(5)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(5), T(0)) == T(3)); - EATEST_VERIFY(eastl::midpoint(T(1), T(4)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(4), T(1)) == T(3)); - EATEST_VERIFY(eastl::midpoint(T(7), T(10)) == T(8)); - EATEST_VERIFY(eastl::midpoint(T(10), T(7)) == T(9)); - EATEST_VERIFY(eastl::midpoint(T(-1), T(2)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(2), T(-1)) == T(1)); - EATEST_VERIFY(eastl::midpoint(T(-5), T(4)) == T(-1)); - EATEST_VERIFY(eastl::midpoint(T(4), T(-5)) == T(0)); - - // Test absolute limits - constexpr T MIN = eastl::numeric_limits<T>::min(); - constexpr T MAX = eastl::numeric_limits<T>::max(); - - EATEST_VERIFY(eastl::midpoint(MIN, MIN) == MIN); - EATEST_VERIFY(eastl::midpoint(MAX, MAX) == MAX); - EATEST_VERIFY(eastl::midpoint(MIN, MAX) == T(-1)); - EATEST_VERIFY(eastl::midpoint(MAX, MIN) == T(0)); - EATEST_VERIFY(eastl::midpoint(MIN, T(0)) == MIN / 2); - EATEST_VERIFY(eastl::midpoint(T(0), MIN) == MIN / 2); - EATEST_VERIFY(eastl::midpoint(MAX, T(0)) == (MAX / 2) + 1); - EATEST_VERIFY(eastl::midpoint(T(0), MAX) == (MAX / 2)); - - EATEST_VERIFY(eastl::midpoint(MIN, T(10)) == (MIN / 2) + 5); - EATEST_VERIFY(eastl::midpoint(T(10), MIN) == (MIN / 2) + 5); - EATEST_VERIFY(eastl::midpoint(MAX, T(10)) == (MAX / 2) + 5 + 1); - EATEST_VERIFY(eastl::midpoint(T(10), MAX) == (MAX / 2) + 5); - EATEST_VERIFY(eastl::midpoint(MIN, T(-10)) == (MIN / 2) - 5); - EATEST_VERIFY(eastl::midpoint(T(-10), MIN) == (MIN / 2) - 5); - EATEST_VERIFY(eastl::midpoint(MAX, T(-10)) == (MAX / 2) - 5 + 1); - EATEST_VERIFY(eastl::midpoint(T(-10), MAX) == (MAX / 2) - 5); - - return nErrorCount; -} - -template <typename T> -static constexpr int UnsignedIntMidpoint() -{ - int nErrorCount = 0; - - EATEST_VERIFY(eastl::midpoint(T(0), T(0)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(0), T(2)) == T(1)); - EATEST_VERIFY(eastl::midpoint(T(0), T(4)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(0), T(8)) == T(4)); - EATEST_VERIFY(eastl::midpoint(T(2), T(0)) == T(1)); - EATEST_VERIFY(eastl::midpoint(T(4), T(0)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(8), T(0)) == T(4)); - - EATEST_VERIFY(eastl::midpoint(T(1), T(1)) == T(1)); - EATEST_VERIFY(eastl::midpoint(T(1), T(3)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(3), T(1)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(2), T(6)) == T(4)); - EATEST_VERIFY(eastl::midpoint(T(6), T(2)) == T(4)); - - // If an odd sum, midpoint should round towards the LHS operand. - EATEST_VERIFY(eastl::midpoint(T(0), T(5)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(5), T(0)) == T(3)); - EATEST_VERIFY(eastl::midpoint(T(1), T(4)) == T(2)); - EATEST_VERIFY(eastl::midpoint(T(4), T(1)) == T(3)); - EATEST_VERIFY(eastl::midpoint(T(7), T(10)) == T(8)); - EATEST_VERIFY(eastl::midpoint(T(10), T(7)) == T(9)); - - // Test absolute limits - constexpr T MIN = eastl::numeric_limits<T>::min(); - constexpr T MAX = eastl::numeric_limits<T>::max(); - - EATEST_VERIFY(eastl::midpoint(MIN, MIN) == MIN); - EATEST_VERIFY(eastl::midpoint(MAX, MAX) == MAX); - EATEST_VERIFY(eastl::midpoint(MIN, MAX) == MAX / 2); - EATEST_VERIFY(eastl::midpoint(MAX, MIN) == (MAX / 2) + 1); - EATEST_VERIFY(eastl::midpoint(MIN, T(0)) == T(0)); - EATEST_VERIFY(eastl::midpoint(T(0), MIN) == T(0)); - - EATEST_VERIFY(eastl::midpoint(MIN, T(10)) == (MIN / 2) + 5); - EATEST_VERIFY(eastl::midpoint(T(10), MIN) == (MIN / 2) + 5); - EATEST_VERIFY(eastl::midpoint(MAX, T(10)) == (MAX / 2) + 5 + 1); - EATEST_VERIFY(eastl::midpoint(T(10), MAX) == (MAX / 2) + 5); - - return nErrorCount; -} - -template <typename T> -static constexpr int FloatMidpoint() -{ - // for use with floats, double, long doubles. - int nErrorCount = 0; - EATEST_VERIFY(eastl::midpoint(T(0.0), T(0.0)) == T(0.0)); - EATEST_VERIFY(eastl::midpoint(T(0.0), T(2.0)) == T(1.0)); - EATEST_VERIFY(eastl::midpoint(T(0.0), T(4.0)) == T(2.0)); - EATEST_VERIFY(eastl::midpoint(T(2.0), T(0.0)) == T(1.0)); - EATEST_VERIFY(eastl::midpoint(T(4.0), T(0.0)) == T(2.0)); - - EATEST_VERIFY(eastl::midpoint(T(0.5), T(0.5)) == T(0.5)); - EATEST_VERIFY(eastl::midpoint(T(0.0), T(0.5)) == T(0.25)); - EATEST_VERIFY(eastl::midpoint(T(0.5), T(0.0)) == T(0.25)); - EATEST_VERIFY(eastl::midpoint(T(0.5), T(1.0)) == T(0.75)); - EATEST_VERIFY(eastl::midpoint(T(1.0), T(0.5)) == T(0.75)); - - EATEST_VERIFY(eastl::midpoint(T(-0.0), T(0.0)) == T(0.0)); - EATEST_VERIFY(eastl::midpoint(T(0.0), T(-0.0)) == T(0.0)); - EATEST_VERIFY(eastl::midpoint(T(-0.0), T(-0.0)) == T(0.0)); - EATEST_VERIFY(eastl::midpoint(T(-1.0), T(2.0)) == T(0.5)); - EATEST_VERIFY(eastl::midpoint(T(-2.0), T(1)) == T(-0.5)); - EATEST_VERIFY(eastl::midpoint(T(-3.0), T(6.0)) == T(1.5)); - EATEST_VERIFY(eastl::midpoint(T(-6.0), T(3.0)) == T(-1.5)); - - // Test absolute limits - const T MIN = eastl::numeric_limits<T>::min(); - const T MAX = eastl::numeric_limits<T>::max(); - - EATEST_VERIFY(eastl::midpoint(MIN, MIN) == MIN); - EATEST_VERIFY(eastl::midpoint(MAX, MAX) == MAX); - EATEST_VERIFY(eastl::midpoint(MIN, MAX) == MAX / 2); - EATEST_VERIFY(eastl::midpoint(MAX, MIN) == MAX / 2); - EATEST_VERIFY(eastl::midpoint(-MAX, MIN) == -MAX / 2); - - EATEST_VERIFY(eastl::midpoint(MIN, T(9.0)) == T(4.5)); - EATEST_VERIFY(eastl::midpoint(MIN, T(-9.0)) == T(-4.5)); - EATEST_VERIFY(eastl::midpoint(T(9.0), MIN) == T(4.5)); - EATEST_VERIFY(eastl::midpoint(T(-9.0), MIN) == T(-4.5)); - EATEST_VERIFY(eastl::midpoint(MAX, T(9.0)) == MAX / 2 + T(4.5)); - EATEST_VERIFY(eastl::midpoint(MAX, T(-9.0)) == MAX / 2 - T(4.5)); - EATEST_VERIFY(eastl::midpoint(T(9.0), MAX) == MAX / 2 + T(4.5)); - EATEST_VERIFY(eastl::midpoint(T(-9.0), MAX) == MAX / 2 - T(4.5)); - - return nErrorCount; -} - -template <typename T> -static constexpr int PointerMidpoint() -{ - int nErrorCount = 0; - - const T ARR[100] = {}; - - EATEST_VERIFY(eastl::midpoint(ARR, ARR) == ARR); - EATEST_VERIFY(eastl::midpoint(ARR, ARR + 100) == ARR + 50); - EATEST_VERIFY(eastl::midpoint(ARR + 100, ARR) == ARR + 50); - EATEST_VERIFY(eastl::midpoint(ARR, ARR + 25) == ARR + 12); - EATEST_VERIFY(eastl::midpoint(ARR + 25, ARR) == ARR + 13); - EATEST_VERIFY(eastl::midpoint(ARR, ARR + 13) == ARR + 6); - EATEST_VERIFY(eastl::midpoint(ARR + 13, ARR) == ARR + 7); - EATEST_VERIFY(eastl::midpoint(ARR + 50, ARR + 100) == ARR + 75); - EATEST_VERIFY(eastl::midpoint(ARR + 100, ARR + 50) == ARR + 75); - - return nErrorCount; -} - - -/////////////////////////////////////////////////////////////////////////////// -// TestMidpoint -// -static int TestMidpoint() -{ - int nErrorCount = 0; - - // template <typename T> - // constexpr eastl::enable_if_t<eastl::is_arithmetic_v<T> && !eastl::is_same_v<eastl::remove_cv_t<T>, bool>, T> - // midpoint(const T lhs, const T rhs) EA_NOEXCEPT - nErrorCount += SignedIntMidpoint<int>(); - nErrorCount += SignedIntMidpoint<char>(); - nErrorCount += SignedIntMidpoint<short>(); - nErrorCount += SignedIntMidpoint<long>(); - nErrorCount += SignedIntMidpoint<long long>(); - - nErrorCount += UnsignedIntMidpoint<unsigned int>(); - nErrorCount += UnsignedIntMidpoint<unsigned char>(); - nErrorCount += UnsignedIntMidpoint<unsigned short>(); - nErrorCount += UnsignedIntMidpoint<unsigned long>(); - nErrorCount += UnsignedIntMidpoint<unsigned long long>(); - - nErrorCount += FloatMidpoint<float>(); - nErrorCount += FloatMidpoint<double>(); - nErrorCount += FloatMidpoint<long double>(); - - // template <typename T> - // constexpr eastl::enable_if_t<eastl::is_object_v<T>, const T*> midpoint(const T* lhs, const T* rhs) - nErrorCount += PointerMidpoint<int>(); - nErrorCount += PointerMidpoint<char>(); - nErrorCount += PointerMidpoint<short>(); - nErrorCount += PointerMidpoint<float>(); - nErrorCount += PointerMidpoint<double>(); - nErrorCount += PointerMidpoint<long double>(); - - return nErrorCount; -} - - -template <typename T> -static constexpr int FloatLerp() -{ - int nErrorCount = 0; - - EATEST_VERIFY(eastl::lerp(T(0.0), T(0.0), T(0.0)) == T(0.0)); - EATEST_VERIFY(eastl::lerp(T(1.0), T(0.0), T(0.0)) == T(1.0)); - EATEST_VERIFY(eastl::lerp(T(-1.0), T(0.0), T(0.0)) == T(-1.0)); - EATEST_VERIFY(eastl::lerp(T(0.0), T(1.0), T(0.0)) == T(0.0)); - EATEST_VERIFY(eastl::lerp(T(0.0), T(-1.0), T(0.0)) == T(0.0)); - EATEST_VERIFY(eastl::lerp(T(-1.0), T(1.0), T(1.0)) == T(1.0)); - EATEST_VERIFY(eastl::lerp(T(1.0), T(-1.0), T(1.0)) == T(-1.0)); - EATEST_VERIFY(eastl::lerp(T(-1.0), T(1.0), T(0.5)) == T(0.0)); - EATEST_VERIFY(eastl::lerp(T(1.0), T(-1.0), T(0.5)) == T(0.0)); - EATEST_VERIFY(eastl::lerp(T(5.0), T(5.0), T(0.5)) == T(5.0)); - EATEST_VERIFY(eastl::lerp(T(-5.0), T(-5.0), T(0.5)) == T(-5.0)); - EATEST_VERIFY(eastl::lerp(T(1.0), T(2.0), T(1.0)) == T(2.0)); - EATEST_VERIFY(eastl::lerp(T(2.0), T(1.0), T(1.0)) == T(1.0)); - EATEST_VERIFY(eastl::lerp(T(1.0), T(2.0), T(1.0)) == T(2.0)); - EATEST_VERIFY(eastl::lerp(T(1.0), T(2.0), T(2.0)) == T(3.0)); - EATEST_VERIFY(eastl::lerp(T(2.0), T(1.0), T(2.0)) == T(0.0)); - EATEST_VERIFY(eastl::lerp(T(1.0), T(-2.0), T(2.0)) == T(-5.0)); - EATEST_VERIFY(eastl::lerp(T(-1.0), T(2.0), T(2.0)) == T(5.0)); - EATEST_VERIFY(eastl::lerp(T(-1.5), T(1.5), T(0.75)) == T(0.75)); - EATEST_VERIFY(eastl::lerp(T(0.125), T(1.75), T(0.25)) == T(0.53125)); - EATEST_VERIFY(eastl::lerp(T(-0.125), T(-1.75), T(0.5)) == T(-0.9375)); - EATEST_VERIFY(eastl::lerp(T(-0.125), T(1.5), T(2.5)) == T(3.9375)); - - return nErrorCount; -} - -/////////////////////////////////////////////////////////////////////////////// -// TestLerp -// -static int TestLerp() -{ - int nErrorCount = 0; - - // template <class T> - // constexpr T lerp(const T a, const T b, const T t) EA_NOEXCEPT - nErrorCount += FloatLerp<float>(); - nErrorCount += FloatLerp<double>(); - nErrorCount += FloatLerp<long double>(); - - return nErrorCount; -} -#endif - - -/////////////////////////////////////////////////////////////////////////////// -// TestAdaptors -// -static int TestAdaptors() -{ - int nErrorCount = 0; - - // reverse lvalue container - { - int int_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - eastl::vector<int> original(begin(int_data), end(int_data)); - - eastl::vector<int> reversed; - for(auto& e : eastl::reverse(original)) - reversed.push_back(e); - - eastl::reverse(begin(original), end(original)); - EATEST_VERIFY(reversed == original); - } - - // reverse const lvalue container - { - int int_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - const eastl::vector<int> original(begin(int_data), end(int_data)); - - eastl::vector<int> reversed; - for(auto& e : eastl::reverse(original)) - reversed.push_back(e); - - eastl::vector<int> reversed_original(original); - eastl::reverse(begin(reversed_original), end(reversed_original)); - EATEST_VERIFY(reversed == reversed_original); - } - - // reverse rvalue container - { - int int_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - eastl::vector<int> original(begin(int_data), end(int_data)); - - eastl::vector<int> reversed; - for (auto& e : eastl::reverse(eastl::vector<int>(original))) - reversed.push_back(e); - - eastl::reverse(begin(original), end(original)); - EATEST_VERIFY(reversed == original); - } - - return nErrorCount; -} - -#if defined(EA_COMPILER_CPP20_ENABLED) -template <typename T> -int TestHasSingleBit() -{ - int nErrorCount = 0; - - VERIFY(eastl::has_single_bit(T(0)) == false); - VERIFY(eastl::has_single_bit(T(1)) == true); - VERIFY(eastl::has_single_bit(T(2)) == true); - VERIFY(eastl::has_single_bit(T(3)) == false); - - VERIFY(eastl::has_single_bit(eastl::numeric_limits<T>::min()) == false); - VERIFY(eastl::has_single_bit(eastl::numeric_limits<T>::max()) == false); - - for (int i = 4; i < eastl::numeric_limits<T>::digits; i++) - { - T power_of_two = static_cast<T>(T(1U) << i); - VERIFY(eastl::has_single_bit(power_of_two)); - VERIFY(eastl::has_single_bit(static_cast<T>(power_of_two - 1)) == false); - } - - return nErrorCount; -} - -template <typename T> -static int TestBitCeil() -{ - int nErrorCount = 0; - - VERIFY(eastl::bit_ceil(T(0)) == T(1)); - VERIFY(eastl::bit_ceil(T(1)) == T(1)); - VERIFY(eastl::bit_ceil(T(2)) == T(2)); - VERIFY(eastl::bit_ceil(T(3)) == T(4)); - - EA_CONSTEXPR auto DIGITS = eastl::numeric_limits<T>::digits; - EA_CONSTEXPR auto MIN = eastl::numeric_limits<T>::min(); - EA_CONSTEXPR auto MAX = static_cast<T>(T(1) << (DIGITS - 1)); - - VERIFY(eastl::bit_ceil(MAX) == MAX); - VERIFY(eastl::bit_ceil(static_cast<T>(MAX - 1)) == MAX); - VERIFY(eastl::bit_ceil(MIN) == T(1)); - - for (int i = 4; i < eastl::numeric_limits<T>::digits; i++) - { - T power_of_two = static_cast<T>(T(1U) << i); - VERIFY(eastl::bit_ceil(power_of_two) == power_of_two); - VERIFY(eastl::bit_ceil(static_cast<T>(power_of_two - 1)) == power_of_two); - } - - return nErrorCount; -} - -template <typename T> -static int TestBitFloor() -{ - int nErrorCount = 0; - VERIFY(eastl::bit_floor(T(0)) == T(0)); - VERIFY(eastl::bit_floor(T(1)) == T(1)); - VERIFY(eastl::bit_floor(T(2)) == T(2)); - VERIFY(eastl::bit_floor(T(3)) == T(2)); - - EA_CONSTEXPR auto DIGITS = eastl::numeric_limits<T>::digits; - EA_CONSTEXPR auto MIN = eastl::numeric_limits<T>::min(); - EA_CONSTEXPR auto MAX = eastl::numeric_limits<T>::max(); - - VERIFY(eastl::bit_floor(MAX) == T(1) << (DIGITS - 1)); - VERIFY(eastl::bit_floor(MIN) == T(0)); - - for (int i = 4; i < eastl::numeric_limits<T>::digits; i++) - { - T power_of_two = static_cast<T>(T(1U) << i); - VERIFY(eastl::bit_floor(power_of_two) == power_of_two); - VERIFY(eastl::bit_floor(static_cast<T>(power_of_two + 1)) == power_of_two); - } - return nErrorCount; -} - -template <typename T> -static int TestBitWidth() -{ - int nErrorCount = 0; - - VERIFY(eastl::bit_width(T(0)) == T(0)); - VERIFY(eastl::bit_width(T(1)) == T(1)); - VERIFY(eastl::bit_width(T(2)) == T(2)); - VERIFY(eastl::bit_width(T(3)) == T(2)); - - EA_CONSTEXPR auto DIGITS = eastl::numeric_limits<T>::digits; - EA_CONSTEXPR auto MIN = eastl::numeric_limits<T>::min(); - EA_CONSTEXPR auto MAX = eastl::numeric_limits<T>::max(); - - VERIFY(eastl::bit_width(MIN) == 0); - VERIFY(eastl::bit_width(MAX) == DIGITS); - - for (int i = 4; i < eastl::numeric_limits<T>::digits; i++) - { - T power_of_two = static_cast<T>(T(1U) << i); - VERIFY(eastl::bit_width(power_of_two) == static_cast<T>(i + 1)); - } - - return nErrorCount; -} - -/////////////////////////////////////////////////////////////////////////////// -// TestPowerofTwo -// -static int TestPowerOfTwo() -{ - int nErrorCount = 0; - nErrorCount += TestHasSingleBit<unsigned int>(); - nErrorCount += TestHasSingleBit<unsigned char>(); - nErrorCount += TestHasSingleBit<unsigned short>(); - nErrorCount += TestHasSingleBit<unsigned long>(); - nErrorCount += TestHasSingleBit<unsigned long long>(); - - nErrorCount += TestBitCeil<unsigned int>(); - nErrorCount += TestBitCeil<unsigned char>(); - nErrorCount += TestBitCeil<unsigned short>(); - nErrorCount += TestBitCeil<unsigned long>(); - nErrorCount += TestBitCeil<unsigned long long>(); - - nErrorCount += TestBitFloor<unsigned int>(); - nErrorCount += TestBitFloor<unsigned char>(); - nErrorCount += TestBitFloor<unsigned short>(); - nErrorCount += TestBitFloor<unsigned long>(); - nErrorCount += TestBitFloor<unsigned long long>(); - - nErrorCount += TestBitWidth<unsigned int>(); - nErrorCount += TestBitWidth<unsigned char>(); - nErrorCount += TestBitWidth<unsigned short>(); - nErrorCount += TestBitWidth<unsigned long>(); - nErrorCount += TestBitWidth<unsigned long long>(); - - return nErrorCount; -} -#endif - -/////////////////////////////////////////////////////////////////////////////// -// TestExtra -// -int TestExtra() -{ - int nErrorCount = 0; - - nErrorCount += TestForwardDeclarations(); - nErrorCount += TestQueue(); - nErrorCount += TestPriorityQueue(); - nErrorCount += TestStack(); - nErrorCount += TestCompressedPair(); - nErrorCount += TestCallTraits(); - nErrorCount += TestNumeric(); - nErrorCount += TestAdaptors(); -#if defined(EA_COMPILER_CPP20_ENABLED) - nErrorCount += TestMidpoint(); - nErrorCount += TestLerp(); - nErrorCount += TestPowerOfTwo(); -#endif - - return nErrorCount; -} - - - - - - - - - - - - |