kc3-lang/angle/src/common/CircularBuffer_unittest.cpp

• Show log

  Commit

• Hash : 7aba3bc5
  Author :
  Date : 2021-10-14T23:14:37
  

  Vulkan: Use a CircularBuffer helper class in SurfaceVk
  
  There are two instances of circular buffer in SurfaceVk.  A common
  helper class is introduced by this change to consolidate the
  implementation.
  
  This is in preparation for a follow up change that introduces yet
  another circular buffer in this class.
  
  Bug: angleproject:6401
  Change-Id: Id01b585567310a2528888114239a5c80ff93f1ee
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3225084
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Ian Elliott <ianelliott@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/common/CircularBuffer_unittest.cpp

• //
  // Copyright 2021 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // CircularBuffer_unittest:
  //   Tests of the CircularBuffer class
  //
  
  #include <gtest/gtest.h>
  
  #include "common/CircularBuffer.h"
  
  namespace angle
  {
  // Make sure the various constructors compile and do basic checks
  TEST(CircularBuffer, Constructors)
  {
      CircularBuffer<int, 5> defaultContructor;
      EXPECT_EQ(5u, defaultContructor.size());
  
      CircularBuffer<int, 5> valueConstructor(3);
      EXPECT_EQ(5u, valueConstructor.size());
      EXPECT_EQ(3, valueConstructor.front());
  
      CircularBuffer<int, 5> copy(valueConstructor);
      EXPECT_EQ(5u, copy.size());
  
      CircularBuffer<int, 5> copyRValue(std::move(valueConstructor));
      EXPECT_EQ(5u, copyRValue.size());
  }
  
  // Make sure the destructor destroys all elements.
  TEST(CircularBuffer, Destructor)
  {
      struct s
      {
          s() {}
          s(int *c) : counter(c) {}
          ~s()
          {
              if (counter)
              {
                  ++*counter;
              }
          }
  
          s(const s &) = default;
          s &operator=(const s &) = default;
  
          int *counter;
      };
  
      int destructorCount = 0;
  
      {
          CircularBuffer<s, 11> buf((s(&destructorCount)));
  
          // Destructor called once for the temporary above.
          EXPECT_EQ(destructorCount, 1);
  
          // Change front index to be non-zero.
          buf.next();
          buf.next();
          buf.next();
      }
  
      // Destructor should be called 11 more times, once for each element.
      EXPECT_EQ(destructorCount, 12);
  }
  
  // Test circulating behavior.
  TEST(CircularBuffer, Circulate)
  {
      CircularBuffer<int, 7> buf(128);
  
      for (int i = 0; i < 7; ++i)
      {
          int &value = buf.front();
          EXPECT_EQ(value, 128);
  
          value = i + 10;
  
          buf.next();
      }
  
      for (int i = 0; i < 93; ++i)
      {
          EXPECT_EQ(buf.front(), i % 7 + 10);
          buf.next();
      }
  }
  
  // Test iteration.
  TEST(CircularBuffer, Iterate)
  {
      CircularBuffer<int, 3> buf(12);
  
      for (int i = 0; i < 3; ++i)
      {
          int &value = buf.front();
          buf.next();
  
          EXPECT_EQ(value, 12);
  
          value = i;
      }
  
      // Check that iteration returns all the values (with unknown order) regardless of where the
      // front is pointing.
      for (int i = 0; i < 10; ++i)
      {
          uint32_t valuesSeen = 0;
          for (int value : buf)
          {
              valuesSeen |= 1 << value;
          }
          EXPECT_EQ(valuesSeen, 0x7u);
  
          // Make sure iteration hasn't affected the front index.
          EXPECT_EQ(buf.front(), i % 3);
  
          buf.next();
      }
  }
  
  // Tests buffer operations with a non copyable type.
  TEST(CircularBuffer, NonCopyable)
  {
      struct s : angle::NonCopyable
      {
          s() : x(0) {}
          s(s &&other) : x(other.x) {}
          s &operator=(s &&other)
          {
              x = other.x;
              return *this;
          }
          int x;
      };
  
      CircularBuffer<s, 4> buf;
  
      for (int i = 0; i < 4; ++i)
      {
          s &value = buf.front();
          value.x  = i;
  
          buf.next();
      }
  
      // Make the front index non-zero.
      buf.next();
      EXPECT_EQ(buf.front().x, 1);
  
      CircularBuffer<s, 4> copy = std::move(buf);
  
      for (int i = 0; i < 4; ++i)
      {
          EXPECT_EQ(copy.front().x, (i + 1) % 4);
          copy.next();
      }
  }
  }  // namespace angle
  

Download