text: /*
  * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
  * its licensors.
  *
  * For complete copyright and license terms please see the LICENSE at the root of this
  * distribution (the "License"). All use of this software is governed by the License,
  * or, if provided, by the license below or the license accompanying this file. Do not
  * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *
  */
  #include "UserTypes.h"
  
  #include <AzCore/std/containers/array.h>
  #include <AzCore/std/containers/deque.h>
  #include <AzCore/std/containers/queue.h>
  #include <AzCore/std/containers/stack.h>
  #include <AzCore/std/containers/ring_buffer.h>
  
  #include <AzCore/std/allocator_static.h>
  #include <AzCore/std/allocator_ref.h>
  
  using namespace AZStd;
  using namespace UnitTestInternal;
  
  #define AZ_TEST_VALIDATE_EMPTY_DEQUE(_Deque) \
      AZ_TEST_ASSERT(_Deque.validate());       \
      AZ_TEST_ASSERT(_Deque.size() == 0);      \
      AZ_TEST_ASSERT(_Deque.empty());          \
      AZ_TEST_ASSERT(_Deque.begin() == _Deque.end());
  
  #define AZ_TEST_VALIDATE_DEQUE(_Deque, _NumElements)                       \
      AZ_TEST_ASSERT(_Deque.validate());                                     \
      AZ_TEST_ASSERT(_Deque.size() == _NumElements);                         \
      AZ_TEST_ASSERT((_NumElements > 0) ? !_Deque.empty() : _Deque.empty()); \
      AZ_TEST_ASSERT((_NumElements > 0) ? _Deque.begin() != _Deque.end() : _Deque.begin() == _Deque.end());
  
  namespace UnitTest
  {
      class Containers
          : public AllocatorsFixture
      {
      };
      
      /**
       * Deque container test.
       */
      TEST_F(Containers, Deque)
      {
          // DequeContainerTest-Begin
  
          typedef deque<int> int_deque_type;
  
          int_deque_type int_deque;
          AZ_TEST_VALIDATE_EMPTY_DEQUE(int_deque);
  
          int_deque_type int_deque1(10);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 10);
  
          int_deque_type int_deque2(6, 101);
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 6);
          AZ_TEST_ASSERT(int_deque2.front() == 101);
          AZ_TEST_ASSERT(int_deque2.back() == 101);
  
          int_deque_type int_deque3(int_deque1);
          AZ_TEST_VALIDATE_DEQUE(int_deque3, int_deque1.size());
          AZ_TEST_ASSERT(int_deque3 == int_deque1);
          AZ_TEST_ASSERT(int_deque3 != int_deque2);
  
          int_deque_type int_deque4(int_deque2.begin(), int_deque2.end());
          AZ_TEST_VALIDATE_DEQUE(int_deque4, int_deque2.size());
          AZ_TEST_ASSERT(int_deque4 == int_deque2);
          AZ_TEST_ASSERT(int_deque4 != int_deque3);
  
          // This one will force the map to grow, which is a different code path.
          int_deque1.insert(int_deque1.end(), 10, 99);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 20);
          AZ_TEST_ASSERT(int_deque1.back() == 99);
  
          int_deque3 = int_deque2;
          AZ_TEST_VALIDATE_DEQUE(int_deque3, int_deque2.size());
          AZ_TEST_ASSERT(int_deque3 == int_deque2);
  
          int_deque1.resize(30, 199);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 30);
          AZ_TEST_ASSERT(int_deque1.back() == 199);
  
          int_deque1.resize(40, 299);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 40);
  
          AZ_TEST_ASSERT(int_deque1.at(29) == 199);
          AZ_TEST_ASSERT(int_deque1.at(30) == 299);
  
          for (int_deque_type::size_type i = 0; i < int_deque1.size(); ++i)
          {
              AZ_TEST_ASSERT(int_deque1.at(i) == int_deque1[i]);
          }
  
          AZ_TEST_ASSERT(int_deque2.front() == 101);
          AZ_TEST_ASSERT(int_deque2.back() == 101);
  
          int_deque2.push_front(11);
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 7);
          AZ_TEST_ASSERT(int_deque2.front() == 11);
          int_deque2.push_back(21);
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 8);
          AZ_TEST_ASSERT(int_deque2.back() == 21);
  
          int_deque2.pop_front();
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 7);
          AZ_TEST_ASSERT(int_deque2.front() == 101);
          int_deque2.pop_back();
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 6);
          AZ_TEST_ASSERT(int_deque2.back() == 101);
  
          int_deque1.assign(5, 333);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 5);
  
          array<int, 7> elements = {
              {1, 2, 3, 4, 5, 6, 7}
          };
          int_deque1.assign(elements.begin(), elements.end());
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 7);
  
          int_deque1.insert(int_deque1.begin(), 101);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 8);
          AZ_TEST_ASSERT(int_deque1.front() == 101);
  
          int_deque1.insert(int_deque1.end(), 201);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 9);
          AZ_TEST_ASSERT(int_deque1.back() == 201);
  
          int_deque1.insert(next(int_deque1.begin(), 3), 301);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 10);
          AZ_TEST_ASSERT(int_deque1[3] == 301);
  
          int_deque1.insert(int_deque1.begin(), 2, 401);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 12);
          AZ_TEST_ASSERT(int_deque1.front() == 401);
  
          int_deque1.insert(int_deque1.end(), 3, 501);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 15);
          AZ_TEST_ASSERT(int_deque1.back() == 501);
  
          int_deque1.insert(next(int_deque1.begin(), 3), 5, 601);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 20);
          AZ_TEST_ASSERT(int_deque1[3] == 601);
  
          int_deque1.insert(int_deque1.begin(), elements.begin(), next(elements.begin()));
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 21);
          AZ_TEST_ASSERT(int_deque1.front() == 1);
  
          int_deque1.insert(int_deque1.end(), prior(elements.end()), elements.end());
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 22);
          AZ_TEST_ASSERT(int_deque1.back() == 7);
  
          int_deque1.insert(next(int_deque1.begin(), 3), elements.begin(), elements.end());
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 29);
          AZ_TEST_ASSERT(int_deque1[3] == 1);
  
          int_deque1.insert(int_deque1.begin(), { 42 });
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 30);
          AZ_TEST_ASSERT(int_deque1.front() == 42);
  
          int_deque1.insert(int_deque1.begin(), { 1, 1, 2, 3, 5, 8, 13 });
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 37);
          AZ_TEST_ASSERT(int_deque1.front() == 1);
          AZ_TEST_ASSERT(int_deque1[3] == 3);
  
          AZ_TEST_START_TRACE_SUPPRESSION;
          int_deque1.insert(int_deque1.begin(), {});
          AZ_TEST_STOP_TRACE_SUPPRESSION(1);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 37);
          int_deque1.erase(int_deque1.begin(), int_deque1.begin() + 8);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 29);
  
          int_deque1.erase(int_deque1.begin());
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 28);
          AZ_TEST_ASSERT(int_deque1.front() == 401);
  
          int_deque1.erase(prior(int_deque1.end()));
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 27);
          AZ_TEST_ASSERT(int_deque1.back() == 501);
  
          int_deque1.erase(next(int_deque1.begin()), int_deque1.end());
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 1);
          AZ_TEST_ASSERT(int_deque1.front() == 401);
  
          int_deque1.swap(int_deque2);
          AZ_TEST_VALIDATE_DEQUE(int_deque1, 6);
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 1);
          AZ_TEST_ASSERT(int_deque1.front() == 101);
          AZ_TEST_ASSERT(int_deque1.back() == 101);
          AZ_TEST_ASSERT(int_deque2.front() == 401);
  
          for (int_deque_type::iterator it = int_deque2.begin(); it != int_deque2.end(); ++it)
          {
              AZ_TEST_ASSERT(*it == 401);
          }
  
          for (int_deque_type::reverse_iterator rit = int_deque2.rbegin(); rit != int_deque2.rend(); ++rit)
          {
              AZ_TEST_ASSERT(*rit == 401);
          }
  
          // extensions
          int_deque2.push_back();
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 2);
          AZ_TEST_ASSERT(int_deque2.front() == 401);
  
          int_deque2.push_front();
          AZ_TEST_VALIDATE_DEQUE(int_deque2, 3);
          AZ_TEST_ASSERT(int_deque2[1] == 401);
  
          // alignment
          deque<MyClass> aligned_deque(5, 99);
          for (AZStd::size_t i = 0; i < aligned_deque.size(); ++i)
          {
              AZ_TEST_ASSERT(((AZStd::size_t)&aligned_deque[i] & (alignment_of<MyClass>::value - 1)) == 0);
          }
  
          // different allocators
          typedef static_buffer_allocator<16*1024, 0> staic_buffer_16KB_type;
          staic_buffer_16KB_type myMemoryManager1;
          staic_buffer_16KB_type myMemoryManager2;
          typedef allocator_ref<staic_buffer_16KB_type> static_allocator_ref_type;
          static_allocator_ref_type allocator1(myMemoryManager1, "Mystack allocator 1");
          static_allocator_ref_type allocator2(myMemoryManager2, "Mystack allocator 2");
  
          typedef deque<int, static_allocator_ref_type> int_deque_myalloc_type;
          int_deque_myalloc_type int_deque10(100, 13, allocator1); /// Allocate 100 elements using memory manager 1
          AZ_TEST_VALIDATE_DEQUE(int_deque10, 100);
          AZ_TEST_ASSERT(myMemoryManager1.get_allocated_size() >= 100 * sizeof(int));
  
          // leak_and_reset
          int_deque10.leak_and_reset();  /// leave the allocated memory and reset the vector.
          AZ_TEST_VALIDATE_EMPTY_DEQUE(int_deque10);
          AZ_TEST_ASSERT(myMemoryManager1.get_allocated_size() >= 100 * sizeof(int));
          myMemoryManager1.reset(); /// discard the memory
  
          // allocate again from myMemoryManager1
          int_deque10.resize(100, 15);
  
          int_deque10.set_allocator(allocator2);
          AZ_TEST_VALIDATE_DEQUE(int_deque10, 100);
          // now we move the allocated size from menager1 to manager2 (without freeing menager1)
          AZ_TEST_ASSERT(myMemoryManager1.get_allocated_size() == myMemoryManager2.get_allocated_size());
  
          myMemoryManager1.reset(); // flush manager 1 again (int_vector10 is stored in manager 2)
  
          // swap with different allocators
          int_deque_myalloc_type int_deque11(50, 25, allocator1); // create copy in manager1
          AZ_TEST_VALIDATE_DEQUE(int_deque11, 50);
  
          int_deque11.swap(int_deque10); // swap the vectors content (since the allocators are different)
          AZ_TEST_VALIDATE_DEQUE(int_deque10, 50);
          AZ_TEST_VALIDATE_DEQUE(int_deque11, 100);
          AZ_TEST_ASSERT(int_deque11.front() == 15);
          AZ_TEST_ASSERT(int_deque10.front() == 25);
  
          //////////////////////////////////////////////////////////////////////////////////////////
          // Test asserts (which don't cause throw exceptions)
          //AZ_TEST_START_TRACE_SUPPRESSION;
          //int_deque10.resize(1000000);  // too many elements, 1 assert on too many, 1 assert on allocator returning NULL
          //AZ_TEST_STOP_TRACE_SUPPRESSION(2);
  
  #ifdef AZSTD_HAS_CHECKED_ITERATORS
          int_deque.clear();
          int_deque_type::iterator iter = int_deque.end();
          // We have exeption when we access the map.
          //AZ_TEST_START_TRACE_SUPPRESSION;
          //int b = *iter; // the end if is valid but can not dereferenced
          //int_deque.validate_iterator(iter);
          //(void)b;
          //AZ_TEST_STOP_TRACE_SUPPRESSION(1);
  
          int_deque.push_back(1);
          AZ_TEST_START_TRACE_SUPPRESSION;
          int_deque.validate_iterator(iter); // The push back should make the end iterator invalid.
          AZ_TEST_STOP_TRACE_SUPPRESSION(1);
  
          iter = int_deque.begin();
          int_deque.clear();
          AZ_TEST_START_TRACE_SUPPRESSION;
          int_deque.validate_iterator(iter); // The clear should invalidate all iterators
          AZ_TEST_STOP_TRACE_SUPPRESSION(1);
  #endif
  
          aligned_deque.emplace_back(10, true, 2.0f);
  
          // DequeContainerTest-End
      }
  
      /**
      * Queue container test.
      */
      TEST_F(Containers, Queue)
      {
          // QueueContainerTest-Begin
          typedef queue<int> int_queue_type;
          int_queue_type int_queue;
          AZ_TEST_ASSERT(int_queue.empty());
          AZ_TEST_ASSERT(int_queue.size() == 0);
  
          // Queue uses deque as default container, so try to contruct to queue from a deque.
          deque<int> container(40, 10);
          int_queue_type int_queue2(container);
          AZ_TEST_ASSERT(!int_queue2.empty());
          AZ_TEST_ASSERT(int_queue2.size() == 40);
  
          int_queue.push(10);
          AZ_TEST_ASSERT(!int_queue.empty());
          AZ_TEST_ASSERT(int_queue.size() == 1);
          AZ_TEST_ASSERT(int_queue.front() == int_queue.back());
          AZ_TEST_ASSERT(int_queue.front() == 10);
  
          int_queue.pop();
          AZ_TEST_ASSERT(int_queue.empty());
          AZ_TEST_ASSERT(int_queue.size() == 0);
  
          int_queue2.push(20);
          AZ_TEST_ASSERT(!int_queue2.empty());
          AZ_TEST_ASSERT(int_queue2.size() == 41);
          AZ_TEST_ASSERT(int_queue2.back() == 20);
  
          int_queue2.pop();
          AZ_TEST_ASSERT(!int_queue2.empty());
          AZ_TEST_ASSERT(int_queue2.size() == 40);
          AZ_TEST_ASSERT(int_queue2.back() == 20);
  
          int_queue.push();
          AZ_TEST_ASSERT(!int_queue.empty());
          AZ_TEST_ASSERT(int_queue.size() == 1);
  
          // Test Swap
          int_queue.swap(int_queue2);
          AZ_TEST_ASSERT(!int_queue2.empty());
          AZ_TEST_ASSERT(int_queue2.size() == 1);
          AZ_TEST_ASSERT(!int_queue.empty());
          AZ_TEST_ASSERT(int_queue.size() == 40);
          AZ_TEST_ASSERT(int_queue.back() == 20);
  
          queue<MyClass> class_queue;
          class_queue.emplace(3, false, 1.0f);
  
          // QueueContainerTest-End
      }
  
      /**
      * Priority queue container test.
      */
      TEST_F(Containers, PriorityQueue)
      {
          // PriorityQueueContainerTest-Begin
          typedef priority_queue<int> int_priority_queue_type;
          int_priority_queue_type int_queue;
          AZ_TEST_ASSERT(int_queue.empty());
          AZ_TEST_ASSERT(int_queue.size() == 0);
  
          array<int, 10> elements = {
              {10, 2, 6, 3, 5, 8, 7, 9, 1, 4}
          };
          int_priority_queue_type int_queue2(elements.begin(), elements.end());
          AZ_TEST_ASSERT(!int_queue2.empty());
          AZ_TEST_ASSERT(int_queue2.size() == 10);
          int lastValue = 11;
          while (!int_queue2.empty())
          {
              AZ_TEST_ASSERT(int_queue2.top() < lastValue);
              lastValue = int_queue2.top();
              int_queue2.pop();
          }
          AZ_TEST_ASSERT(int_queue2.size() == 0);
  
          priority_queue<int, vector<int>, AZStd::greater<int> > int_queue3(elements.begin(), elements.end());
          AZ_TEST_ASSERT(!int_queue3.empty());
          AZ_TEST_ASSERT(int_queue3.size() == 10);
          lastValue = 0;
          while (!int_queue3.empty())
          {
              AZ_TEST_ASSERT(int_queue3.top() > lastValue);
              lastValue = int_queue3.top();
              int_queue3.pop();
          }
          AZ_TEST_ASSERT(int_queue3.size() == 0);
  
          int_priority_queue_type int_queue4(elements.begin(), elements.end());
          int_queue4.push(100);
          AZ_TEST_ASSERT(!int_queue4.empty());
          AZ_TEST_ASSERT(int_queue4.size() == 11);
          AZ_TEST_ASSERT(int_queue4.top() == 100);
          // PriorityQueueContainerTest-End
      }
  
      /**
      * Stack container test.
      */
      TEST_F(Containers, Stack)
      {
          // StackContainerTest-Begin
          typedef stack<int> int_stack_type;
          int_stack_type int_stack;
          AZ_TEST_ASSERT(int_stack.empty());
          AZ_TEST_ASSERT(int_stack.size() == 0);
  
          deque<int> container(40, 10);
          int_stack_type int_stack2(container);
          AZ_TEST_ASSERT(!int_stack2.empty());
          AZ_TEST_ASSERT(int_stack2.size() == 40);
  
          int_stack.push(20);
          AZ_TEST_ASSERT(!int_stack.empty());
          AZ_TEST_ASSERT(int_stack.size() == 1);
          AZ_TEST_ASSERT(int_stack.top() == 20);
  
          int_stack.pop();
          AZ_TEST_ASSERT(int_stack.empty());
          AZ_TEST_ASSERT(int_stack.size() == 0);
  
          int_stack2.push(20);
          AZ_TEST_ASSERT(!int_stack2.empty());
          AZ_TEST_ASSERT(int_stack2.size() == 41);
          AZ_TEST_ASSERT(int_stack2.top() == 20);
  
          int_stack2.pop();
          AZ_TEST_ASSERT(!int_stack2.empty());
          AZ_TEST_ASSERT(int_stack2.size() == 40);
          AZ_TEST_ASSERT(int_stack2.top() == 10);
  
          int_stack.push();
          AZ_TEST_ASSERT(!int_stack.empty());
          AZ_TEST_ASSERT(int_stack.size() == 1);
          // StackContainerTest-End
      }
  
      /**
      * Make sure a ring_buffer is empty, and control all functions to return the proper values.
      * Empty ring_buffer as all AZStd containers should not have allocated any memory. Empty and clean containers are not the same.
      */
  #define AZ_TEST_VALIDATE_EMPTY_RINGBUFFER(_RingBuffer) \
      AZ_TEST_ASSERT(_RingBuffer.validate());            \
      AZ_TEST_ASSERT(_RingBuffer.size() == 0);           \
      AZ_TEST_ASSERT(_RingBuffer.empty());               \
      AZ_TEST_ASSERT(_RingBuffer.capacity() == 0);       \
      AZ_TEST_ASSERT(_RingBuffer.begin() == _RingBuffer.end());
  
      /**
      * Validate a ring_buffer for certain number of elements.
      */
  #define AZ_TEST_VALIDATE_RINGBUFFER(_RingBuffer, _NumElements)                          \
      AZ_TEST_ASSERT(_RingBuffer.validate());                                             \
      AZ_TEST_ASSERT(_RingBuffer.size() == _NumElements);                                 \
      AZ_TEST_ASSERT((_NumElements > 0) ? !_RingBuffer.empty() : _RingBuffer.empty());    \
      AZ_TEST_ASSERT((_NumElements > 0) ? _RingBuffer.capacity() >= _NumElements : true); \
      AZ_TEST_ASSERT((_NumElements > 0) ? _RingBuffer.begin() != _RingBuffer.end() : _RingBuffer.begin() == _RingBuffer.end());
  
      /**
       * ring_buffer container test.
       */
      TEST_F(Containers, RingBuffer)
      {
          typedef ring_buffer<int> int_ringbuffer_type;
          typedef ring_buffer<MyClass> class_ringbuffer_type;
  
          // Test empty  buffer with intergral type.
          int_ringbuffer_type int_buffer;
          AZ_TEST_VALIDATE_EMPTY_RINGBUFFER(int_buffer);
  
          // Default vector (non-integral type).
          class_ringbuffer_type myclass_buffer;
          AZ_TEST_VALIDATE_EMPTY_RINGBUFFER(myclass_buffer);
  
          // Allocate buffer with capacity of 10 elements.
          int_ringbuffer_type int_buffer1(10);
          AZ_TEST_ASSERT(int_buffer1.size() == 0);
          AZ_TEST_ASSERT(int_buffer1.capacity() == 10);
          AZ_TEST_ASSERT(int_buffer1.empty());
          AZ_TEST_ASSERT(int_buffer1.begin() == int_buffer1.end());
  
          // Allocate buffer with 15 elements init to 13.
          int_ringbuffer_type int_buffer2(15, 13);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer2, 15);
          for (int_ringbuffer_type::iterator iter = int_buffer2.begin(); iter != int_buffer2.end(); ++iter)
          {
              AZ_TEST_ASSERT(*iter == 13);
          }
  
          // Allocate buffer with 15 elements init to 13 and a capacity 31.
          int_ringbuffer_type int_buffer3(31, 15, 13);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer3, 15);
          AZ_TEST_ASSERT(int_buffer3.capacity() == 31);
          for (int_ringbuffer_type::iterator iter = int_buffer3.begin(); iter != int_buffer3.end(); ++iter)
          {
              AZ_TEST_ASSERT(*iter == 13);
          }
  
          // Copy ctor
          int_ringbuffer_type int_buffer4(int_buffer3);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer4, 15);
          AZ_TEST_ASSERT(int_buffer4.capacity() == 31);
          for (int_ringbuffer_type::iterator iter = int_buffer4.begin(); iter != int_buffer4.end(); ++iter)
          {
              AZ_TEST_ASSERT(*iter == 13);
          }
  
          // Test == and !=
          AZ_TEST_ASSERT(int_buffer4 == int_buffer3);
          AZ_TEST_ASSERT((int_buffer4 != int_buffer3) == false);
  
          AZStd::array<int, 6> myArr = {
              {0, 1, 2, 3, 4, 5}
          };
          int_ringbuffer_type int_buffer5(myArr.begin(), myArr.end());
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size());
          int i = 0;
          for (int_ringbuffer_type::iterator iter = int_buffer5.begin(); iter != int_buffer5.end(); ++iter, ++i)
          {
              AZ_TEST_ASSERT(*iter == i);
          }
  
          int_ringbuffer_type int_buffer6(10, myArr.begin(), myArr.end());
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer6, myArr.size());
          AZ_TEST_ASSERT(int_buffer6.capacity() == 10);
          i = 0;
          for (int_ringbuffer_type::iterator iter = int_buffer6.begin(); iter != int_buffer6.end(); ++iter, ++i)
          {
              AZ_TEST_ASSERT(*iter == i);
          }
  
          // =
          int_buffer1 = int_buffer6;
          AZ_TEST_ASSERT(int_buffer1 == int_buffer6);
  
          // []
          AZ_TEST_ASSERT(int_buffer5[3] == 3);
          AZ_TEST_ASSERT(int_buffer5[4] == int_buffer5.at(4));
  
          AZ_TEST_ASSERT(int_buffer5.front() == 0);
          AZ_TEST_ASSERT(int_buffer5.back() == 5);
  
          // full
          AZ_TEST_ASSERT(int_buffer5.full() == true);
          AZ_TEST_ASSERT(int_buffer6.full() == false);
  
          // Circular checks
          AZ_TEST_ASSERT(int_buffer5.is_linearized() == true);
          int_ringbuffer_type::array_range arr1 = int_buffer5.array_one();
          int_ringbuffer_type::array_range arr2 = int_buffer5.array_two();
          AZ_TEST_ASSERT(arr1.second == int_buffer5.size());  // we have only 1 linear array
          AZ_TEST_ASSERT(arr2.second == 0);
          AZ_TEST_ASSERT(*arr1.first == 0); // Check that we are pointing to the first elements, which is 0.
  
          // Overwrite the first 2 elements.
          int_buffer5.push_back(6);
          int_buffer5.push_back(7);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size());
          AZ_TEST_ASSERT(int_buffer5.front() == 2);
          AZ_TEST_ASSERT(int_buffer5.back() == 7);
          arr1 = int_buffer5.array_one();
          arr2 = int_buffer5.array_two();
          AZ_TEST_ASSERT(arr1.second == 4);
          AZ_TEST_ASSERT(*arr1.first == 2);
          AZ_TEST_ASSERT(arr2.second == 2);
          AZ_TEST_ASSERT(*arr2.first == 6);
  
          // rotate - full buffer
          int_buffer5.rotate(int_buffer5.begin() + 1); // rotate right by 1
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size());
          AZ_TEST_ASSERT(int_buffer5.front() == 3);
          AZ_TEST_ASSERT(int_buffer5.back() == 2);
          arr1 = int_buffer5.array_one();
          arr2 = int_buffer5.array_two();
          AZ_TEST_ASSERT(arr1.second == 3);
          AZ_TEST_ASSERT(*arr1.first == 3);
          AZ_TEST_ASSERT(arr2.second == 3);
          AZ_TEST_ASSERT(*arr2.first == 6);
  
          // rotate - !full buffer
          int_buffer6.rotate(int_buffer6.begin() + 5);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer6, myArr.size());
          AZ_TEST_ASSERT(int_buffer6.front() == 5);
          AZ_TEST_ASSERT(int_buffer6.back() == 4);
          arr1 = int_buffer6.array_one();
          arr2 = int_buffer6.array_two();
          AZ_TEST_ASSERT(arr1.second == 1);
          AZ_TEST_ASSERT(*arr1.first == 5);
          AZ_TEST_ASSERT(arr2.second == 5);
          AZ_TEST_ASSERT(*arr2.first == 0);
  
          // linearize
          int_buffer5.linearize();
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size());
          AZ_TEST_ASSERT(int_buffer5.is_linearized());
          AZ_TEST_ASSERT(int_buffer5.front() == 3);
          AZ_TEST_ASSERT(int_buffer5.back() == 2);
          arr1 = int_buffer5.array_one();
          arr2 = int_buffer5.array_two();
          AZ_TEST_ASSERT(arr1.second == 6);
          AZ_TEST_ASSERT(*arr1.first == 3);
          AZ_TEST_ASSERT(arr2.second == 0);
  
          // resize - grow
          int_buffer5.resize(100, 11);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, 100);
          AZ_TEST_ASSERT(int_buffer5.front() == 3);
          AZ_TEST_ASSERT(int_buffer5.back() == 11);
  
          // resize - shrink
          int_buffer5.resize(5);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, 5);
          AZ_TEST_ASSERT(int_buffer5.front() == 3);
          AZ_TEST_ASSERT(int_buffer5.back() == 7);
  
          // swap
          int_buffer5.swap(int_buffer6);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer6, 5);
          AZ_TEST_ASSERT(int_buffer6.front() == 3);
          AZ_TEST_ASSERT(int_buffer6.back() == 7);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size());
          AZ_TEST_ASSERT(int_buffer5.front() == 5);
          AZ_TEST_ASSERT(int_buffer5.back() == 4);
  
          // push
          int_buffer5.push_back(101);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size() + 1);
          AZ_TEST_ASSERT(int_buffer5.back() == 101);
          int_buffer5.push_back();
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size() + 2);
  
          int_buffer5.push_front(201);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size() + 3);
          AZ_TEST_ASSERT(int_buffer5.front() == 201);
          int_buffer5.push_front();
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size() + 4);
  
          // pop
          int_buffer5.pop_front();
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size() + 3);
          AZ_TEST_ASSERT(int_buffer5.front() == 201);
          int_buffer5.pop_back();
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size() + 2);
          AZ_TEST_ASSERT(int_buffer5.back() == 101);
  
          // insert
          int_buffer5.insert(int_buffer5.begin() + 1, 303);
          AZ_TEST_VALIDATE_RINGBUFFER(int_buffer5, myArr.size() + 3);
          AZ_TEST_ASSERT(int_buffer5[0] == 201);
          AZ_TEST_ASSERT(int_buffer5[1] == 303);
  
          /*  int_buffer5.insert(int_buffer5.begin(),3,404);
              AZ_TEST_ASSERT(int_buffer5[0]==404);
              AZ_TEST_ASSERT(int_buffer5[3]==201);*/
  
          // erase
          int_buffer5.erase(int_buffer5.begin() + 1);
          AZ_TEST_ASSERT(int_buffer5[0] == 201);
      }
  
      TEST_F(Containers, RingBufferReverseIterators)
      {
          using int_ringbuffer_type = AZStd::ring_buffer<int>;
          const int max = 42;
          int_ringbuffer_type rev_buffer(max);
          
          for (int i = 0; i < max; ++i)
          {
              rev_buffer.push_back(i);
          }
          int iteration = 0;
          for (int_ringbuffer_type::const_reverse_iterator rit = rev_buffer.rbegin(); rit != rev_buffer.rend(); ++rit)
          {
              EXPECT_EQ(max - iteration - 1, *rit);
              ++iteration;
          }
      }
  }
  