Merge pull request #7380 from gottesmm/diverse_stack_unittest

Author: swift-ci

unittests/Basic/BlotMapVectorTest.cpp

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define DEBUG_TYPE "swift-blot-map-vector-test"
 #include "swift/Basic/BlotMapVector.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Lazy.h"
@@ -19,6 +20,7 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Debug.h"
 #include "gtest/gtest.h"
 #include <map>
 #include <set>
@@ -93,31 +95,31 @@ class CtorTester {
 
   CtorTester() : Value(new int(-1)) {
     dump("Constructing ()");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     // EXPECT_TRUE(ConstructedTesters->insert(this));
     assert(!isLive());
     fflush(stdout);
   }
 
   explicit CtorTester(EmptyTester) : Value(new int(-2)) {
     dump("Constructing Empty");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     // EXPECT_TRUE(ConstructedTesters->insert(this));
     assert(!isLive());
     fflush(stdout);
   }
 
   explicit CtorTester(TombstoneTester) : Value(new int(-3)) {
     dump("Constructing Tombstone");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     // EXPECT_TRUE(ConstructedTesters->insert(this));
     assert(!isLive());
     fflush(stdout);
   }
 
   explicit CtorTester(int V) : Value(new int(V)) {
     dump("Constructing Normal");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     EXPECT_TRUE(ConstructedTesters->insert(this));
     assert(!isIgnorableTester());
     assert(isLive());
@@ -126,7 +128,7 @@ class CtorTester {
 
   explicit CtorTester(uint32_t V) : Value(new int(V)) {
     dump("Constructing Normal");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     EXPECT_TRUE(ConstructedTesters->insert(this));
     assert(!isIgnorableTester());
     assert(isLive());
@@ -136,7 +138,7 @@ class CtorTester {
   CtorTester(const CtorTester &Arg) : Value(new int(*Arg.Value.get())) {
     dump("CopyConstructing");
     Arg.dump("   From");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     if (!Arg.isIgnorableTester()) {
       EXPECT_TRUE(ConstructedTesters->insert(this));
       fflush(stdout);
@@ -146,7 +148,7 @@ class CtorTester {
   CtorTester(CtorTester &&Arg) : Value(new int(-1)) {
     dump("Operator Move Constructor");
     Arg.dump("    From");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     assert(Value);
     assert(Arg.Value);
     // If Arg is not ignorable, it will be now and we will not be.
@@ -155,13 +157,13 @@ class CtorTester {
       EXPECT_EQ(1u, ConstructedTesters->erase(&Arg));
     }
     std::swap(Value, Arg.Value);
-    fflush(stdout);
+    DEBUG(fflush(stdout));
   }
 
   CtorTester &operator=(const CtorTester &Arg) {
     dump("Operator Copy Assignment");
     Arg.dump("    From");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     assert(Value);
     assert(Arg.Value);
 
@@ -178,7 +180,7 @@ class CtorTester {
   CtorTester &operator=(CtorTester &&Arg) {
     dump("Operator Move Assignment");
     Arg.dump("    From");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     assert(Value);
     assert(Arg.Value);
     if (!Arg.isIgnorableTester() && isIgnorableTester()) {
@@ -190,14 +192,14 @@ class CtorTester {
     }
 
     std::swap(Value, Arg.Value);
-    fflush(stdout);
+    DEBUG(fflush(stdout));
     return *this;
   }
 
   ~CtorTester() {
     bool IsIgnorable = isIgnorableTester();
     dump("Destroying");
-    llvm::outs() << "\n";
+    DEBUG(llvm::errs() << "\n");
     delete Value.get();
     Value = nullptr;
     fflush(stdout);
@@ -224,9 +226,9 @@ class CtorTester {
     Addr += llvm::utohexstr(uintptr_t(this));
     std::string ValueAddr = "0x";
     ValueAddr += llvm::utohexstr(uintptr_t(Value.get()));
-    llvm::outs() << Name << " <Tester Addr:" << Addr
-                 << " ValueAddr:" << ValueAddr << " Value:" << *Value.get()
-                 << ">";
+    DEBUG(llvm::errs() << Name << " <Tester Addr:" << Addr
+          << " ValueAddr:" << ValueAddr << " Value:" << *Value.get()
+          << ">");
   }
 };
 
@@ -236,7 +238,7 @@ void CtorTesterSet::dumpLiveTesters() const {
       continue;
     llvm::SmallString<64> Hex;
     std::string Addr = llvm::utohexstr(uintptr_t(Tester));
-    llvm::outs() << "<Tester Addr:" << Addr << " Value:" << Tester->getValue()
+    llvm::errs() << "<Tester Addr:" << Addr << " Value:" << Tester->getValue()
                  << ">\n";
   }
 }
@@ -331,7 +333,7 @@ template <typename T> class BlotMapVectorTest : public ::testing::Test {
 
   ~BlotMapVectorTest() override {
     ConstructedTesters->verifyTesters();
-    llvm::outs() << "Destroying Fixture\n";
+    DEBUG(llvm::errs() << "Destroying Fixture\n");
     ConstructedTesters->finalize();
   }
 

unittests/Basic/CMakeLists.txt

@@ -9,6 +9,7 @@ add_swift_unittest(SwiftBasicTests
   BlotMapVectorTest.cpp
   ClusteredBitVectorTest.cpp
   DemangleTest.cpp
+  DiverseStackTest.cpp
   EditorPlaceholderTest.cpp
   EncodedSequenceTest.cpp
   FileSystemTest.cpp

unittests/Basic/DiverseStackTest.cpp

@@ -0,0 +1,84 @@
+//===--- DiverseStackTest.cpp ---------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Basic/DiverseStack.h"
+#include "gtest/gtest.h"
+
+using namespace swift;
+
+namespace {
+
+struct ParentType {
+  uint8_t allocatedSize;
+
+public:
+  ParentType(uint8_t allocatedSize) : allocatedSize(allocatedSize) {}
+
+  unsigned allocated_size() const { return allocatedSize; }
+};
+
+struct TwoByteType : ParentType {
+  uint8_t Value;
+
+  TwoByteType(uint8_t Value) : ParentType(sizeof(*this)), Value(Value) {}
+};
+
+struct ThreeByteType : ParentType {
+  uint16_t Value;
+
+  ThreeByteType(uint16_t Value) : ParentType(sizeof(*this)), Value(Value) {}
+};
+
+} // end anonymous namespace
+
+TEST(DiverseStack, MonomorphicPushPop) {
+  DiverseStack<ParentType, 128> Stack;
+
+  EXPECT_TRUE(Stack.empty());
+
+  constexpr size_t TwoByteDataSize = 5;
+  uint8_t InputData[TwoByteDataSize] = {5, 9, 1, 2, 10};
+  for (unsigned i = 0; i < TwoByteDataSize; ++i) {
+    Stack.push<TwoByteType>(TwoByteType(InputData[i]));
+  }
+
+  EXPECT_FALSE(Stack.empty());
+
+  for (int i = TwoByteDataSize - 1; i >= 0; --i) {
+    TwoByteType T = reinterpret_cast<TwoByteType &>(Stack.top());
+    Stack.pop();
+    EXPECT_EQ(T.Value, InputData[i]);
+  }
+
+  EXPECT_TRUE(Stack.empty());
+}
+
+// We test the property here that iterating forward through the stack iterates
+// in stack order. This is a bit counter-intuitive for people used to vector
+// stacks.
+TEST(DiverseStack, Iterate) {
+  DiverseStack<ParentType, 128> Stack;
+
+  constexpr size_t TwoByteDataSize = 5;
+  uint8_t InputData[TwoByteDataSize] = {5, 9, 1, 2, 10};
+  for (unsigned i = 0; i < TwoByteDataSize; ++i) {
+    Stack.push<TwoByteType>(TwoByteType(InputData[i]));
+  }
+
+  const uint8_t *Ptr = &InputData[TwoByteDataSize - 1];
+  for (auto II = Stack.begin(), IE = Stack.end(); II != IE;) {
+    TwoByteType T = reinterpret_cast<TwoByteType &>(*II);
+    EXPECT_EQ(T.Value, *Ptr);
+    --Ptr;
+    ++II;
+  }
+}