[NFC] Define NumBuiltinElts utility just once at the beginning of SmallVectorTest file

[yurai007]

Summary

Extracted from: https://reviews.llvm.org/D130268

[fhahn]

LGTM, thanks!

llvm/unittests/ADT/SmallVectorTest.cpp

 
 // Generate a sequence of values to initialize the vector.
 template <typename VectorT> void makeSequence(VectorT &v, int start, int end) {
   for (int i = start; i <= end; ++i) {
     v.push_back(Constructable(i));
   }
 }
 
+template <typename T, unsigned N>
+static unsigned NumBuiltinElts(const SmallVector<T, N> &) {
+  return N;
+}
+
 class SmallVectorTestBase : public testing::Test {
 protected:
   void SetUp() override { Constructable::reset(); }
 };
 
 // Test fixture class
 template <typename VectorT>
 class SmallVectorTest : public SmallVectorTestBase {

 
 template <typename InvalidType> class DualSmallVectorsTest;
 
 template <typename VectorT1, typename VectorT2>
 class DualSmallVectorsTest<std::pair<VectorT1, VectorT2>> : public SmallVectorTestBase {
 protected:
   VectorT1 theVector;
   VectorT2 otherVector;
-
-  template <typename T, unsigned N>
-  static unsigned NumBuiltinElts(const SmallVector<T, N>&) { return N; }
 };
 
 typedef ::testing::Types<
     // Small mode -> Small mode.
     std::pair<SmallVector<Constructable, 4>, SmallVector<Constructable, 4>>,
     // Small mode -> Big mode.
     std::pair<SmallVector<Constructable, 4>, SmallVector<Constructable, 2>>,
     // Big mode -> Small mode.
TYPED_TEST(DualSmallVectorsTest, MoveAssignment) {
   // Make sure the # of constructor/destructor calls line up. There
   // are two live objects after clearing the other vector.
   U.clear();
   EXPECT_EQ(Constructable::getNumConstructorCalls()-4,
             Constructable::getNumDestructorCalls());
 
   // If the source vector (otherVector) was in small-mode, assert that we just
   // moved the data pointer over.
-  EXPECT_TRUE(this->NumBuiltinElts(U) == 4 || V.data() == OrigDataPtr);
+  EXPECT_TRUE(NumBuiltinElts(U) == 4 || V.data() == OrigDataPtr);
 
   // There shouldn't be any live objects any more.
   V.clear();
   EXPECT_EQ(Constructable::getNumConstructorCalls(),
             Constructable::getNumDestructorCalls());
 
   // We shouldn't have copied anything in this whole process.
   EXPECT_EQ(Constructable::getNumCopyConstructorCalls(), 0);

 class SmallVectorReferenceInvalidationTest : public SmallVectorTestBase {
 protected:
   const char *AssertionMessage =
       "Attempting to reference an element of the vector in an operation \" "
       "\"that invalidates it";
 
   VectorT V;
 
-  template <typename T, unsigned N>
-  static unsigned NumBuiltinElts(const SmallVector<T, N> &) {
-    return N;
-  }
-
   template <class T> static bool isValueType() {
     return std::is_same<T, typename VectorT::value_type>::value;
   }
 
   void SetUp() override {
     SmallVectorTestBase::SetUp();
 
     // Fill up the small size so that insertions move the elements.
using SmallVectorReferenceInvalidationTestTypes =
     ::testing::Types<SmallVector<int, 3>, SmallVector<Constructable, 3>>;
 
 TYPED_TEST_SUITE(SmallVectorReferenceInvalidationTest,
                  SmallVectorReferenceInvalidationTestTypes, );
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, PushBack) {
   // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
   auto &V = this->V;
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
 
   // Push back a reference to last element when growing from small storage.
   V.push_back(V.back());
   EXPECT_EQ(N, V.back());
 
   // Check that the old value is still there (not moved away).
   EXPECT_EQ(N, V[V.size() - 2]);
 
   // Fill storage again.
   V.back() = V.size();
   while (V.size() < V.capacity())
     V.push_back(V.size() + 1);
 
   // Push back a reference to last element when growing from large storage.
   V.push_back(V.back());
   EXPECT_EQ(int(V.size()) - 1, V.back());
 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, PushBackMoved) {
   // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
   auto &V = this->V;
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
 
   // Push back a reference to last element when growing from small storage.
   V.push_back(std::move(V.back()));
   EXPECT_EQ(N, V.back());
   if (this->template isValueType<Constructable>()) {
     // Check that the value was moved (not copied).
     EXPECT_EQ(0, V[V.size() - 2]);
   }
if (this->template isValueType<Constructable>()) {
     // Check the value got moved out.
     EXPECT_EQ(0, V[V.size() - 2]);
   }
 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, Resize) {
   auto &V = this->V;
   (void)V;
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
   V.resize(N + 1, V.back());
   EXPECT_EQ(N, V.back());
 
   // Resize to add enough elements that V will grow again. If reference
   // invalidation breaks in the future, sanitizers should be able to catch a
   // use-after-free here.
   V.resize(V.capacity() + 1, V.front());
   EXPECT_EQ(1, V.back());
 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, Append) {
   auto &V = this->V;
   (void)V;
   V.append(1, V.back());
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
   EXPECT_EQ(N, V[N - 1]);
 
   // Append enough more elements that V will grow again. This tests growing
   // when already in large mode.
   //
   // If reference invalidation breaks in the future, sanitizers should be able
   // to catch a use-after-free here.
   V.append(V.capacity() - V.size() + 1, V.front());
   EXPECT_EQ(1, V.back());
 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, AppendRange) {
   auto &V = this->V;
   (void)V;
 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
   EXPECT_DEATH(V.append(V.begin(), V.begin() + 1), this->AssertionMessage);
 
-  ASSERT_EQ(3u, this->NumBuiltinElts(V));
+  ASSERT_EQ(3u, NumBuiltinElts(V));
   ASSERT_EQ(3u, V.size());
   V.pop_back();
   ASSERT_EQ(2u, V.size());
 
   // Confirm this checks for growth when there's more than one element
   // appended.
   EXPECT_DEATH(V.append(V.begin(), V.end()), this->AssertionMessage);
 #endif
 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, Assign) {
   // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
   auto &V = this->V;
   (void)V;
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
   ASSERT_EQ(unsigned(N), V.size());
   ASSERT_EQ(unsigned(N), V.capacity());
 
   // Check assign that shrinks in small mode.
   V.assign(1, V.back());
   EXPECT_EQ(1u, V.size());
   EXPECT_EQ(N, V[0]);
 

 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, InsertN) {
   auto &V = this->V;
   (void)V;
 
   // Cover NumToInsert <= this->end() - I.
   V.insert(V.begin() + 1, 1, V.back());
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
   EXPECT_EQ(N, V[1]);
 
   // Cover NumToInsert > this->end() - I, inserting enough elements that V will
   // also grow again; V.capacity() will be more elements than necessary but
   // it's a simple way to cover both conditions.
   //
   // If reference invalidation breaks in the future, sanitizers should be able
   // to catch a use-after-free here.
   V.insert(V.begin(), V.capacity(), V.front());
   EXPECT_EQ(1, V.front());
 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, InsertRange) {
   auto &V = this->V;
   (void)V;
 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
   EXPECT_DEATH(V.insert(V.begin(), V.begin(), V.begin() + 1),
                this->AssertionMessage);
 
-  ASSERT_EQ(3u, this->NumBuiltinElts(V));
+  ASSERT_EQ(3u, NumBuiltinElts(V));
   ASSERT_EQ(3u, V.size());
   V.pop_back();
   ASSERT_EQ(2u, V.size());
 
   // Confirm this checks for growth when there's more than one element
   // inserted.
   EXPECT_DEATH(V.insert(V.begin(), V.begin(), V.end()), this->AssertionMessage);
 #endif
 }
 
 TYPED_TEST(SmallVectorReferenceInvalidationTest, EmplaceBack) {
   // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
   auto &V = this->V;
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
 
   // Push back a reference to last element when growing from small storage.
   V.emplace_back(V.back());
   EXPECT_EQ(N, V.back());
 
   // Check that the old value is still there (not moved away).
   EXPECT_EQ(N, V[V.size() - 2]);
 
::testing::Types<SmallVector<std::pair<int, int>, 3>,
                      SmallVector<std::pair<Constructable, Constructable>, 3>>;
 
 TYPED_TEST_SUITE(SmallVectorInternalReferenceInvalidationTest,
                  SmallVectorInternalReferenceInvalidationTestTypes, );
 
 TYPED_TEST(SmallVectorInternalReferenceInvalidationTest, EmplaceBack) {
   // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
   auto &V = this->V;
-  int N = this->NumBuiltinElts(V);
+  int N = NumBuiltinElts(V);
 
   // Push back a reference to last element when growing from small storage.
   V.emplace_back(V.back().first, V.back().second);
   EXPECT_EQ(N, V.back().first);
   EXPECT_EQ(N, V.back().second);
 
   // Check that the old value is still there (not moved away).
   EXPECT_EQ(N, V[V.size() - 2].first);