StringMapTest.cpp revision 6316fbcb04af00fe76b6526fab09f51484014b3e 
1//===- llvm/unittest/ADT/StringMapMap.cpp - StringMap unit tests ----------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "gtest/gtest.h"
11#include "llvm/ADT/StringMap.h"
12#include "llvm/Support/DataTypes.h"
13using namespace llvm;
14
15namespace {
16
17// Test fixture
18class StringMapTest : public testing::Test {
19protected:
20  StringMap<uint32_t> testMap;
21
22  static const char testKey[];
23  static const uint32_t testValue;
24  static const char* testKeyFirst;
25  static size_t testKeyLength;
26  static const std::string testKeyStr;
27
28  void assertEmptyMap() {
29    // Size tests
30    EXPECT_EQ(0u, testMap.size());
31    EXPECT_TRUE(testMap.empty());
32
33    // Iterator tests
34    EXPECT_TRUE(testMap.begin() == testMap.end());
35
36    // Lookup tests
37    EXPECT_EQ(0u, testMap.count(testKey));
38    EXPECT_EQ(0u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
39    EXPECT_EQ(0u, testMap.count(testKeyStr));
40    EXPECT_TRUE(testMap.find(testKey) == testMap.end());
41    EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
42                testMap.end());
43    EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end());
44  }
45
46  void assertSingleItemMap() {
47    // Size tests
48    EXPECT_EQ(1u, testMap.size());
49    EXPECT_FALSE(testMap.begin() == testMap.end());
50    EXPECT_FALSE(testMap.empty());
51
52    // Iterator tests
53    StringMap<uint32_t>::iterator it = testMap.begin();
54    EXPECT_STREQ(testKey, it->first());
55    EXPECT_EQ(testValue, it->second);
56    ++it;
57    EXPECT_TRUE(it == testMap.end());
58
59    // Lookup tests
60    EXPECT_EQ(1u, testMap.count(testKey));
61    EXPECT_EQ(1u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
62    EXPECT_EQ(1u, testMap.count(testKeyStr));
63    EXPECT_TRUE(testMap.find(testKey) == testMap.begin());
64    EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
65                testMap.begin());
66    EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin());
67  }
68};
69
70const char StringMapTest::testKey[] = "key";
71const uint32_t StringMapTest::testValue = 1u;
72const char* StringMapTest::testKeyFirst = testKey;
73size_t StringMapTest::testKeyLength = sizeof(testKey) - 1;
74const std::string StringMapTest::testKeyStr(testKey);
75
76// Empty map tests.
77TEST_F(StringMapTest, EmptyMapTest) {
78  SCOPED_TRACE("EmptyMapTest");
79  assertEmptyMap();
80}
81
82// Constant map tests.
83TEST_F(StringMapTest, ConstEmptyMapTest) {
84  const StringMap<uint32_t>& constTestMap = testMap;
85
86  // Size tests
87  EXPECT_EQ(0u, constTestMap.size());
88  EXPECT_TRUE(constTestMap.empty());
89
90  // Iterator tests
91  EXPECT_TRUE(constTestMap.begin() == constTestMap.end());
92
93  // Lookup tests
94  EXPECT_EQ(0u, constTestMap.count(testKey));
95  EXPECT_EQ(0u, constTestMap.count(StringRef(testKeyFirst, testKeyLength)));
96  EXPECT_EQ(0u, constTestMap.count(testKeyStr));
97  EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end());
98  EXPECT_TRUE(constTestMap.find(StringRef(testKeyFirst, testKeyLength)) ==
99              constTestMap.end());
100  EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end());
101}
102
103// A map with a single entry.
104TEST_F(StringMapTest, SingleEntryMapTest) {
105  SCOPED_TRACE("SingleEntryMapTest");
106  testMap[testKey] = testValue;
107  assertSingleItemMap();
108}
109
110// Test clear() method.
111TEST_F(StringMapTest, ClearTest) {
112  SCOPED_TRACE("ClearTest");
113  testMap[testKey] = testValue;
114  testMap.clear();
115  assertEmptyMap();
116}
117
118// Test erase(iterator) method.
119TEST_F(StringMapTest, EraseIteratorTest) {
120  SCOPED_TRACE("EraseIteratorTest");
121  testMap[testKey] = testValue;
122  testMap.erase(testMap.begin());
123  assertEmptyMap();
124}
125
126// Test erase(value) method.
127TEST_F(StringMapTest, EraseValueTest) {
128  SCOPED_TRACE("EraseValueTest");
129  testMap[testKey] = testValue;
130  testMap.erase(testKey);
131  assertEmptyMap();
132}
133
134// Test inserting two values and erasing one.
135TEST_F(StringMapTest, InsertAndEraseTest) {
136  SCOPED_TRACE("InsertAndEraseTest");
137  testMap[testKey] = testValue;
138  testMap["otherKey"] = 2;
139  testMap.erase("otherKey");
140  assertSingleItemMap();
141}
142
143// A more complex iteration test.
144TEST_F(StringMapTest, IterationTest) {
145  bool visited[100];
146
147  // Insert 100 numbers into the map
148  for (int i = 0; i < 100; ++i) {
149    std::stringstream ss;
150    ss << "key_" << i;
151    testMap[ss.str()] = i;
152    visited[i] = false;
153  }
154
155  // Iterate over all numbers and mark each one found.
156  for (StringMap<uint32_t>::iterator it = testMap.begin();
157      it != testMap.end(); ++it) {
158    std::stringstream ss;
159    ss << "key_" << it->second;
160    ASSERT_STREQ(ss.str().c_str(), it->first());
161    visited[it->second] = true;
162  }
163
164  // Ensure every number was visited.
165  for (int i = 0; i < 100; ++i) {
166    ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited";
167  }
168}
169
170} // end anonymous namespace
171
172namespace llvm {
173
174template <>
175class StringMapEntryInitializer<uint32_t> {
176public:
177  template <typename InitTy>
178  static void Initialize(StringMapEntry<uint32_t> &T, InitTy InitVal) {
179    T.second = InitVal;
180  }
181};
182
183} // end llvm namespace
184
185namespace {
186
187// Test StringMapEntry::Create() method.
188TEST_F(StringMapTest, StringMapEntryTest) {
189  StringMap<uint32_t>::value_type* entry =
190      StringMap<uint32_t>::value_type::Create(
191          testKeyFirst, testKeyFirst + testKeyLength, 1u);
192  EXPECT_STREQ(testKey, entry->first());
193  EXPECT_EQ(1u, entry->second);
194}
195
196// Test insert() method.
197TEST_F(StringMapTest, InsertTest) {
198  SCOPED_TRACE("InsertTest");
199  testMap.insert(
200      StringMap<uint32_t>::value_type::Create(
201          testKeyFirst, testKeyFirst + testKeyLength,
202          testMap.getAllocator(), 1u));
203  assertSingleItemMap();
204}
205
206} // end anonymous namespace
207