[llvm-commits] [llvm] r61914 - in /llvm/trunk: include/llvm/ADT/StringMap.h unittests/ADT/StringMapTest.cpp
Misha Brukman
brukman+llvm at gmail.com
Wed Jan 7 20:48:20 PST 2009
Author: brukman
Date: Wed Jan 7 22:48:20 2009
New Revision: 61914
URL: http://llvm.org/viewvc/llvm-project?rev=61914&view=rev
Log:
* Added unittests for StringMap
* Fixed but in StringMap::clear()
* Removed trailing whitespace
Original patch by Talin.
Added:
llvm/trunk/unittests/ADT/StringMapTest.cpp
Modified:
llvm/trunk/include/llvm/ADT/StringMap.h
Modified: llvm/trunk/include/llvm/ADT/StringMap.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/StringMap.h?rev=61914&r1=61913&r2=61914&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/StringMap.h (original)
+++ llvm/trunk/include/llvm/ADT/StringMap.h Wed Jan 7 22:48:20 2009
@@ -336,7 +336,7 @@
// clear - Empties out the StringMap
void clear() {
if (empty()) return;
-
+
// Zap all values, resetting the keys back to non-present (not tombstone),
// which is safe because we're removing all elements.
for (ItemBucket *I = TheTable, *E = TheTable+NumBuckets; I != E; ++I) {
@@ -345,6 +345,8 @@
I->Item = 0;
}
}
+
+ NumItems = 0;
}
/// GetOrCreateValue - Look up the specified key in the table. If a value
@@ -421,7 +423,7 @@
StringMapImpl::ItemBucket *Ptr;
public:
typedef StringMapEntry<ValueTy> value_type;
-
+
explicit StringMapConstIterator(StringMapImpl::ItemBucket *Bucket,
bool NoAdvance = false)
: Ptr(Bucket) {
Added: llvm/trunk/unittests/ADT/StringMapTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ADT/StringMapTest.cpp?rev=61914&view=auto
==============================================================================
--- llvm/trunk/unittests/ADT/StringMapTest.cpp (added)
+++ llvm/trunk/unittests/ADT/StringMapTest.cpp Wed Jan 7 22:48:20 2009
@@ -0,0 +1,189 @@
+//===- llvm/unittest/ADT/StringMapMap.cpp - StringMap unit tests -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+#include "llvm/ADT/StringMap.h"
+using namespace llvm;
+
+namespace {
+
+// Test fixture
+class StringMapTest : public testing::Test {
+protected:
+ StringMap<uint32_t> testMap;
+
+ static const char testKey[];
+ static const uint32_t testValue;
+ static const char* testKeyFirst;
+ static const char* testKeyLast;
+ static const std::string testKeyStr;
+
+ void assertEmptyMap() {
+ // Size tests
+ EXPECT_EQ(0u, testMap.size());
+ EXPECT_TRUE(testMap.empty());
+
+ // Iterator tests
+ EXPECT_TRUE(testMap.begin() == testMap.end());
+
+ // Lookup tests
+ EXPECT_EQ(0u, testMap.count(testKey));
+ EXPECT_EQ(0u, testMap.count(testKeyFirst, testKeyLast));
+ EXPECT_EQ(0u, testMap.count(testKeyStr));
+ EXPECT_TRUE(testMap.find(testKey) == testMap.end());
+ EXPECT_TRUE(testMap.find(testKeyFirst, testKeyLast) == testMap.end());
+ EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end());
+ }
+
+ void assertSingleItemMap() {
+ // Size tests
+ EXPECT_EQ(1u, testMap.size());
+ EXPECT_FALSE(testMap.begin() == testMap.end());
+ EXPECT_FALSE(testMap.empty());
+
+ // Iterator tests
+ StringMap<uint32_t>::iterator it = testMap.begin();
+ EXPECT_STREQ(testKey, it->first());
+ EXPECT_EQ(testValue, it->second);
+ ++it;
+ EXPECT_TRUE(it == testMap.end());
+
+ // Lookup tests
+ EXPECT_EQ(1u, testMap.count(testKey));
+ EXPECT_EQ(1u, testMap.count(testKeyFirst, testKeyLast));
+ EXPECT_EQ(1u, testMap.count(testKeyStr));
+ EXPECT_TRUE(testMap.find(testKey) == testMap.begin());
+ EXPECT_TRUE(testMap.find(testKeyFirst, testKeyLast) == testMap.begin());
+ EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin());
+ }
+};
+
+const char StringMapTest::testKey[] = "key";
+const uint32_t StringMapTest::testValue = 1u;
+const char* StringMapTest::testKeyFirst = testKey;
+const char* StringMapTest::testKeyLast = testKey + sizeof(testKey) - 1;
+const std::string StringMapTest::testKeyStr(testKey);
+
+// Empty map tests
+TEST_F(StringMapTest, EmptyMapTest) {
+ SCOPED_TRACE("EmptyMapTest");
+ assertEmptyMap();
+}
+
+// Constant map tests
+TEST_F(StringMapTest, ConstEmptyMapTest) {
+ const StringMap<uint32_t>& constTestMap = testMap;
+
+ // Size tests
+ EXPECT_EQ(0u, constTestMap.size());
+ EXPECT_TRUE(constTestMap.empty());
+
+ // Iterator tests
+ EXPECT_TRUE(constTestMap.begin() == constTestMap.end());
+
+ // Lookup tests
+ EXPECT_EQ(0u, constTestMap.count(testKey));
+ EXPECT_EQ(0u, constTestMap.count(testKeyFirst, testKeyLast));
+ EXPECT_EQ(0u, constTestMap.count(testKeyStr));
+ EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end());
+ EXPECT_TRUE(constTestMap.find(testKeyFirst, testKeyLast) ==
+ constTestMap.end());
+ EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end());
+}
+
+// A map with a single entry
+TEST_F(StringMapTest, SingleEntryMapTest) {
+ SCOPED_TRACE("SingleEntryMapTest");
+ testMap[testKey] = testValue;
+ assertSingleItemMap();
+}
+
+// Test clear() method
+TEST_F(StringMapTest, ClearTest) {
+ SCOPED_TRACE("ClearTest");
+ testMap[testKey] = testValue;
+ testMap.clear();
+ assertEmptyMap();
+}
+
+// Test erase(iterator) method
+TEST_F(StringMapTest, EraseIteratorTest) {
+ SCOPED_TRACE("EraseIteratorTest");
+ testMap[testKey] = testValue;
+ testMap.erase(testMap.begin());
+ assertEmptyMap();
+}
+
+// Test erase(value) method
+TEST_F(StringMapTest, EraseValueTest) {
+ SCOPED_TRACE("EraseValueTest");
+ testMap[testKey] = testValue;
+ testMap.erase(testKey);
+ assertEmptyMap();
+}
+
+// Test inserting two values and erasing one
+TEST_F(StringMapTest, InsertAndEraseTest) {
+ SCOPED_TRACE("InsertAndEraseTest");
+ testMap[testKey] = testValue;
+ testMap["otherKey"] = 2;
+ testMap.erase("otherKey");
+ assertSingleItemMap();
+}
+
+// Test StringMapEntry::Create() method.
+// DISABLED because this fails without a StringMapEntryInitializer, and
+// I can't get it to compile with one.
+TEST_F(StringMapTest, DISABLED_StringMapEntryTest) {
+ StringMap<uint32_t>::value_type* entry =
+ StringMap<uint32_t>::value_type::Create(
+ testKeyFirst, testKeyLast, 1u);
+ EXPECT_STREQ(testKey, entry->first());
+ EXPECT_EQ(1u, entry->second);
+}
+
+// Test insert() method
+// DISABLED because this fails without a StringMapEntryInitializer, and
+// I can't get it to compile with one.
+TEST_F(StringMapTest, DISABLED_InsertTest) {
+ SCOPED_TRACE("InsertTest");
+ testMap.insert(
+ StringMap<uint32_t>::value_type::Create(
+ testKeyFirst, testKeyLast, testMap.getAllocator(), 1u));
+ assertSingleItemMap();
+}
+
+// A more complex iteration test
+TEST_F(StringMapTest, IterationTest) {
+ bool visited[100];
+
+ // Insert 100 numbers into the map
+ for (int i = 0; i < 100; ++i) {
+ std::stringstream ss;
+ ss << "key_" << i;
+ testMap[ss.str()] = i;
+ visited[i] = false;
+ }
+
+ // Iterate over all numbers and mark each one found.
+ for (StringMap<uint32_t>::iterator it = testMap.begin();
+ it != testMap.end(); ++it) {
+ std::stringstream ss;
+ ss << "key_" << it->second;
+ ASSERT_STREQ(ss.str().c_str(), it->first());
+ visited[it->second] = true;
+ }
+
+ // Ensure every number was visited.
+ for (int i = 0; i < 100; ++i) {
+ ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited";
+ }
+}
+
+}
More information about the llvm-commits
mailing list