Remove container overflow tests for Vectors with inline capacity

Source/wtf/VectorTest.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 268 matching lines @@
     EXPECT_EQ(1u, vectorA.size());
     EXPECT_EQ(1, vectorA.at(0).get());
     EXPECT_EQ(3u, vectorB.size());
     EXPECT_EQ(2, vectorB.at(0).get());
     EXPECT_EQ(3, vectorB.at(1).get());
     EXPECT_EQ(4, vectorB.at(2).get());
 
     vectorB.swap(vectorA);
 }
 
-#if defined(ADDRESS_SANITIZER)
+#if defined(ANNOTATE_CONTIGUOUS_CONTAINER)
 TEST(VectorTest, ContainerAnnotations)
 {
     Vector<int> vectorA;
     vectorA.append(10);
     vectorA.reserveCapacity(32);
 
     volatile int* intPointerA = vectorA.data();
     EXPECT_DEATH(intPointerA[1] = 11, "container-overflow");
     vectorA.append(11);
     intPointerA[1] = 11;
@@ skipping 18 matching lines @@
     volatile int* intPointerB2 = vectorB.data();
     volatile int* intPointerC2 = vectorC.data();
     intPointerB2[2] = 13;
     EXPECT_DEATH((void)intPointerB2[3], "container-overflow");
     EXPECT_DEATH((void)intPointerC2[2], "container-overflow");
 
     vectorB = vectorC;
     volatile int* intPointerB3 = vectorB.data();
     EXPECT_DEATH((void)intPointerB3[2], "container-overflow");
 }
-
-TEST(VectorTest, ContainerAnnotationsInline)
-{
-    Vector<int> vectorA;
-    Vector<int, 4> vectorB;
-
-    vectorB.append(1);
-    vectorB.append(2);
-    volatile int* intPointerB = vectorB.data();
-    EXPECT_DEATH((void)intPointerB[2], "container-overflow");
-
-    vectorB.append(3);
-    vectorB.append(4);
-    vectorB.append(5);
-    vectorB.reserveCapacity(16);
-    intPointerB = vectorB.data();
-    EXPECT_DEATH((void)intPointerB[5], "container-overflow");
-
-    vectorB.clear();
-    vectorB.shrinkToFit();
-    vectorB.append(1);
-    intPointerB = vectorB.data();
-    EXPECT_DEATH((void)intPointerB[1], "container-overflow");
-
-    vectorB.shrinkToFit();
-    intPointerB = vectorB.data();
-    EXPECT_DEATH((void)intPointerB[1], "container-overflow");
-
-    vectorA = vectorB;
-    vectorA.reserveCapacity(8);
-    volatile int* intPointerA = vectorA.data();
-    EXPECT_DEATH((void)intPointerA[1], "container-overflow");
-
-    Vector<int, 4> vectorC;
-    vectorC.append(3);
-    vectorC.append(4);
-    vectorB.swap(vectorC);
-    intPointerB = vectorB.data();
-    vectorC.reserveCapacity(8);
-    volatile int* intPointerC = vectorC.data();
-    vectorC[0] = 2;
-    vectorB[1] = 1337;
-    EXPECT_DEATH((void)intPointerC[1], "container-overflow");
-    EXPECT_DEATH((void)intPointerB[2], "container-overflow");
-}
-#endif // defined(ADDRESS_SANITIZER)
+#endif // defined(ANNOTATE_CONTIGUOUS_CONTAINER)
 
 class Comparable {
 };
 bool operator==(const Comparable& a, const Comparable& b) { return true; }
 
 template<typename T> void compare()
 {
     EXPECT_TRUE(Vector<T>() == Vector<T>());
     EXPECT_FALSE(Vector<T>(1) == Vector<T>(0));
     EXPECT_FALSE(Vector<T>() == Vector<T>(1));
     EXPECT_TRUE(Vector<T>(1) == Vector<T>(1));
 
     Vector<T, 1> vectorWithInlineCapacity;
     EXPECT_TRUE(vectorWithInlineCapacity == Vector<T>());
     EXPECT_FALSE(vectorWithInlineCapacity == Vector<T>(1));
 }
 
 TEST(VectorTest, Compare)
 {
     compare<int>();
     compare<Comparable>();
     compare<WTF::String>();
 }
 
 } // anonymous namespace
 
 } // namespace WTF