2009-01-08 07:35:39 +00:00
|
|
|
//===- llvm/unittest/ADT/StringMapMap.cpp - StringMap unit tests ----------===//
|
2009-01-08 04:48:20 +00:00
|
|
|
//
|
|
|
|
// 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"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/DataTypes.h"
|
2009-01-08 04:48:20 +00:00
|
|
|
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;
|
2009-07-23 18:17:34 +00:00
|
|
|
static size_t testKeyLength;
|
2009-01-08 04:48:20 +00:00
|
|
|
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));
|
2009-07-23 18:17:34 +00:00
|
|
|
EXPECT_EQ(0u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
|
2009-01-08 04:48:20 +00:00
|
|
|
EXPECT_EQ(0u, testMap.count(testKeyStr));
|
|
|
|
EXPECT_TRUE(testMap.find(testKey) == testMap.end());
|
2009-07-23 18:17:34 +00:00
|
|
|
EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
|
|
|
|
testMap.end());
|
2009-01-08 04:48:20 +00:00
|
|
|
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();
|
2011-07-14 18:31:43 +00:00
|
|
|
EXPECT_STREQ(testKey, it->first().data());
|
2009-01-08 04:48:20 +00:00
|
|
|
EXPECT_EQ(testValue, it->second);
|
|
|
|
++it;
|
|
|
|
EXPECT_TRUE(it == testMap.end());
|
|
|
|
|
|
|
|
// Lookup tests
|
|
|
|
EXPECT_EQ(1u, testMap.count(testKey));
|
2009-07-23 18:17:34 +00:00
|
|
|
EXPECT_EQ(1u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
|
2009-01-08 04:48:20 +00:00
|
|
|
EXPECT_EQ(1u, testMap.count(testKeyStr));
|
|
|
|
EXPECT_TRUE(testMap.find(testKey) == testMap.begin());
|
2009-07-23 18:17:34 +00:00
|
|
|
EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
|
|
|
|
testMap.begin());
|
2009-01-08 04:48:20 +00:00
|
|
|
EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const char StringMapTest::testKey[] = "key";
|
|
|
|
const uint32_t StringMapTest::testValue = 1u;
|
|
|
|
const char* StringMapTest::testKeyFirst = testKey;
|
2009-07-23 18:17:34 +00:00
|
|
|
size_t StringMapTest::testKeyLength = sizeof(testKey) - 1;
|
2009-01-08 04:48:20 +00:00
|
|
|
const std::string StringMapTest::testKeyStr(testKey);
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// Empty map tests.
|
2009-01-08 04:48:20 +00:00
|
|
|
TEST_F(StringMapTest, EmptyMapTest) {
|
|
|
|
assertEmptyMap();
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// Constant map tests.
|
2009-01-08 04:48:20 +00:00
|
|
|
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));
|
2009-07-23 18:17:34 +00:00
|
|
|
EXPECT_EQ(0u, constTestMap.count(StringRef(testKeyFirst, testKeyLength)));
|
2009-01-08 04:48:20 +00:00
|
|
|
EXPECT_EQ(0u, constTestMap.count(testKeyStr));
|
|
|
|
EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end());
|
2009-07-23 18:17:34 +00:00
|
|
|
EXPECT_TRUE(constTestMap.find(StringRef(testKeyFirst, testKeyLength)) ==
|
2009-01-08 09:31:36 +00:00
|
|
|
constTestMap.end());
|
2009-01-08 04:48:20 +00:00
|
|
|
EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end());
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// A map with a single entry.
|
2009-01-08 04:48:20 +00:00
|
|
|
TEST_F(StringMapTest, SingleEntryMapTest) {
|
|
|
|
testMap[testKey] = testValue;
|
|
|
|
assertSingleItemMap();
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// Test clear() method.
|
2009-01-08 04:48:20 +00:00
|
|
|
TEST_F(StringMapTest, ClearTest) {
|
|
|
|
testMap[testKey] = testValue;
|
|
|
|
testMap.clear();
|
|
|
|
assertEmptyMap();
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// Test erase(iterator) method.
|
2009-01-08 04:48:20 +00:00
|
|
|
TEST_F(StringMapTest, EraseIteratorTest) {
|
|
|
|
testMap[testKey] = testValue;
|
|
|
|
testMap.erase(testMap.begin());
|
|
|
|
assertEmptyMap();
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// Test erase(value) method.
|
2009-01-08 04:48:20 +00:00
|
|
|
TEST_F(StringMapTest, EraseValueTest) {
|
|
|
|
testMap[testKey] = testValue;
|
|
|
|
testMap.erase(testKey);
|
|
|
|
assertEmptyMap();
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// Test inserting two values and erasing one.
|
2009-01-08 04:48:20 +00:00
|
|
|
TEST_F(StringMapTest, InsertAndEraseTest) {
|
|
|
|
testMap[testKey] = testValue;
|
|
|
|
testMap["otherKey"] = 2;
|
|
|
|
testMap.erase("otherKey");
|
|
|
|
assertSingleItemMap();
|
|
|
|
}
|
|
|
|
|
2012-06-19 17:40:35 +00:00
|
|
|
TEST_F(StringMapTest, SmallFullMapTest) {
|
|
|
|
// StringMap has a tricky corner case when the map is small (<8 buckets) and
|
|
|
|
// it fills up through a balanced pattern of inserts and erases. This can
|
|
|
|
// lead to inf-loops in some cases (PR13148) so we test it explicitly here.
|
|
|
|
llvm::StringMap<int> Map(2);
|
|
|
|
|
|
|
|
Map["eins"] = 1;
|
|
|
|
Map["zwei"] = 2;
|
|
|
|
Map["drei"] = 3;
|
|
|
|
Map.erase("drei");
|
|
|
|
Map.erase("eins");
|
|
|
|
Map["veir"] = 4;
|
|
|
|
Map["funf"] = 5;
|
|
|
|
|
|
|
|
EXPECT_EQ(3u, Map.size());
|
|
|
|
EXPECT_EQ(0, Map.lookup("eins"));
|
|
|
|
EXPECT_EQ(2, Map.lookup("zwei"));
|
|
|
|
EXPECT_EQ(0, Map.lookup("drei"));
|
|
|
|
EXPECT_EQ(4, Map.lookup("veir"));
|
|
|
|
EXPECT_EQ(5, Map.lookup("funf"));
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// A more complex iteration test.
|
2009-01-08 04:48:20 +00:00
|
|
|
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;
|
2011-07-14 18:31:43 +00:00
|
|
|
ASSERT_STREQ(ss.str().c_str(), it->first().data());
|
2009-01-08 04:48:20 +00:00
|
|
|
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";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
// Test StringMapEntry::Create() method.
|
|
|
|
TEST_F(StringMapTest, StringMapEntryTest) {
|
|
|
|
StringMap<uint32_t>::value_type* entry =
|
|
|
|
StringMap<uint32_t>::value_type::Create(
|
2009-07-23 18:17:34 +00:00
|
|
|
testKeyFirst, testKeyFirst + testKeyLength, 1u);
|
2011-07-14 18:31:43 +00:00
|
|
|
EXPECT_STREQ(testKey, entry->first().data());
|
2009-01-08 09:31:36 +00:00
|
|
|
EXPECT_EQ(1u, entry->second);
|
2010-02-11 07:16:13 +00:00
|
|
|
free(entry);
|
2009-01-08 09:31:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Test insert() method.
|
|
|
|
TEST_F(StringMapTest, InsertTest) {
|
|
|
|
SCOPED_TRACE("InsertTest");
|
|
|
|
testMap.insert(
|
|
|
|
StringMap<uint32_t>::value_type::Create(
|
2009-07-23 18:17:34 +00:00
|
|
|
testKeyFirst, testKeyFirst + testKeyLength,
|
|
|
|
testMap.getAllocator(), 1u));
|
2009-01-08 09:31:36 +00:00
|
|
|
assertSingleItemMap();
|
2009-01-08 04:48:20 +00:00
|
|
|
}
|
2009-01-08 09:31:36 +00:00
|
|
|
|
2014-01-02 23:57:28 +00:00
|
|
|
// Create a non-default constructable value
|
2014-01-03 00:00:41 +00:00
|
|
|
struct StringMapTestStruct {
|
|
|
|
StringMapTestStruct(int i) : i(i) {}
|
|
|
|
StringMapTestStruct() LLVM_DELETED_FUNCTION;
|
|
|
|
int i;
|
|
|
|
};
|
2014-01-02 23:57:28 +00:00
|
|
|
|
2014-01-03 00:00:41 +00:00
|
|
|
TEST_F(StringMapTest, NonDefaultConstructable) {
|
2014-01-02 23:57:28 +00:00
|
|
|
StringMap<StringMapTestStruct> t;
|
|
|
|
t.GetOrCreateValue("Test", StringMapTestStruct(123));
|
|
|
|
StringMap<StringMapTestStruct>::iterator iter = t.find("Test");
|
|
|
|
ASSERT_NE(iter, t.end());
|
|
|
|
ASSERT_EQ(iter->second.i, 123);
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:31:36 +00:00
|
|
|
} // end anonymous namespace
|