RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-25 04:39:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Convert StringMap to using StringRef for its APIs.

Browse Source 
- Yay for '-'s and simplifications!

 - I kept StringMap::GetOrCreateValue for compatibility purposes, this can
   eventually go away. Likewise the StringMapEntry Create functions still follow
   the old style.

 - NIFC.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76888 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Daniel Dunbar 2009-07-23 18:17:34 +00:00
parent b53cc014d0
commit 6316fbcb04
12 changed files with 91 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
include/llvm/ADT/StringMap.h
View File

@ -14,6 +14,7 @@
#ifndef LLVM_ADT_STRINGMAP_H
#define LLVM_ADT_STRINGMAP_H
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Allocator.h"
#include <cstring>
#include <string>
@ -95,12 +96,12 @@ protected:
/// specified bucket will be non-null. Otherwise, it will be null. In either
/// case, the FullHashValue field of the bucket will be set to the hash value
/// of the string.
unsigned LookupBucketFor(const char *KeyStart, const char *KeyEnd);
unsigned LookupBucketFor(const StringRef &Key);
/// FindKey - Look up the bucket that contains the specified key. If it exists
/// in the map, return the bucket number of the key. Otherwise return -1.
/// This does not modify the map.
int FindKey(const char *KeyStart, const char *KeyEnd) const;
int FindKey(const StringRef &Key) const;
/// RemoveKey - Remove the specified StringMapEntry from the table, but do not
/// delete it. This aborts if the value isn't in the table.
@ -108,7 +109,7 @@ protected:
/// RemoveKey - Remove the StringMapEntry for the specified key from the
/// table, returning it. If the key is not in the table, this returns null.
StringMapEntryBase *RemoveKey(const char *KeyStart, const char *KeyEnd);
StringMapEntryBase *RemoveKey(const StringRef &Key);
private:
void init(unsigned Size);
public:
@ -136,6 +137,10 @@ public:
StringMapEntry(unsigned strLen, const ValueTy &V)
: StringMapEntryBase(strLen), second(V) {}
StringRef getKey() const {
return StringRef(getKeyData(), getKeyLength());
}
const ValueTy &getValue() const { return second; }
ValueTy &getValue() { return second; }
@ -277,75 +282,40 @@ public:
return const_iterator(TheTable+NumBuckets, true);
}
iterator find(const char *KeyStart, const char *KeyEnd) {
int Bucket = FindKey(KeyStart, KeyEnd);
iterator find(const StringRef &Key) {
int Bucket = FindKey(Key);
if (Bucket == -1) return end();
return iterator(TheTable+Bucket);
}
iterator find(const char *Key) {
return find(Key, Key + strlen(Key));
}
iterator find(const std::string &Key) {
return find(Key.data(), Key.data() + Key.size());
}
const_iterator find(const char *KeyStart, const char *KeyEnd) const {
int Bucket = FindKey(KeyStart, KeyEnd);
const_iterator find(const StringRef &Key) const {
int Bucket = FindKey(Key);
if (Bucket == -1) return end();
return const_iterator(TheTable+Bucket);
}
const_iterator find(const char *Key) const {
return find(Key, Key + strlen(Key));
}
const_iterator find(const std::string &Key) const {
return find(Key.data(), Key.data() + Key.size());
}
/// lookup - Return the entry for the specified key, or a default
/// constructed value if no such entry exists.
ValueTy lookup(const char *KeyStart, const char *KeyEnd) const {
const_iterator it = find(KeyStart, KeyEnd);
if (it != end())
return it->second;
return ValueTy();
}
ValueTy lookup(const char *Key) const {
const_iterator it = find(Key);
if (it != end())
return it->second;
return ValueTy();
}
ValueTy lookup(const std::string &Key) const {
ValueTy lookup(const StringRef &Key) const {
const_iterator it = find(Key);
if (it != end())
return it->second;
return ValueTy();
}
ValueTy& operator[](const char *Key) {
return GetOrCreateValue(Key, Key + strlen(Key)).getValue();
}
ValueTy& operator[](const std::string &Key) {
return GetOrCreateValue(Key.data(), Key.data() + Key.size()).getValue();
ValueTy& operator[](const StringRef &Key) {
return GetOrCreateValue(Key).getValue();
}
size_type count(const char *KeyStart, const char *KeyEnd) const {
return find(KeyStart, KeyEnd) == end() ? 0 : 1;
}
size_type count(const char *Key) const {
return count(Key, Key + strlen(Key));
}
size_type count(const std::string &Key) const {
return count(Key.data(), Key.data() + Key.size());
size_type count(const StringRef &Key) const {
return find(Key) == end() ? 0 : 1;
}
/// insert - Insert the specified key/value pair into the map. If the key
/// already exists in the map, return false and ignore the request, otherwise
/// insert it and return true.
bool insert(MapEntryTy *KeyValue) {
unsigned BucketNo =
LookupBucketFor(KeyValue->getKeyData(),
KeyValue->getKeyData()+KeyValue->getKeyLength());
unsigned BucketNo = LookupBucketFor(KeyValue->getKey());
ItemBucket &Bucket = TheTable[BucketNo];
if (Bucket.Item && Bucket.Item != getTombstoneVal())
return false; // Already exists in map.
@ -380,15 +350,15 @@ public:
/// exists, return it. Otherwise, default construct a value, insert it, and
/// return.
template <typename InitTy>
StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart,
const char *KeyEnd,
StringMapEntry<ValueTy> &GetOrCreateValue(const StringRef &Key,
InitTy Val) {
unsigned BucketNo = LookupBucketFor(KeyStart, KeyEnd);
unsigned BucketNo = LookupBucketFor(Key);
ItemBucket &Bucket = TheTable[BucketNo];
if (Bucket.Item && Bucket.Item != getTombstoneVal())
return *static_cast<MapEntryTy*>(Bucket.Item);
MapEntryTy *NewItem = MapEntryTy::Create(KeyStart, KeyEnd, Allocator, Val);
MapEntryTy *NewItem =
MapEntryTy::Create(Key.begin(), Key.end(), Allocator, Val);
if (Bucket.Item == getTombstoneVal())
--NumTombstones;
@ -403,9 +373,20 @@ public:
return *NewItem;
}
StringMapEntry<ValueTy> &GetOrCreateValue(const StringRef &Key) {
return GetOrCreateValue(Key, ValueTy());
}
template <typename InitTy>
StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart,
const char *KeyEnd,
InitTy Val) {
return GetOrCreateValue(StringRef(KeyStart, KeyEnd - KeyStart), Val);
}
StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart,
const char *KeyEnd) {
return GetOrCreateValue(KeyStart, KeyEnd, ValueTy());
return GetOrCreateValue(StringRef(KeyStart, KeyEnd - KeyStart));
}
/// remove - Remove the specified key/value pair from the map, but do not
@ -420,14 +401,7 @@ public:
V.Destroy(Allocator);
}
bool erase(const char *Key) {
iterator I = find(Key);
if (I == end()) return false;
erase(I);
return true;
}
bool erase(const std::string &Key) {
bool erase(const StringRef &Key) {
iterator I = find(Key);
if (I == end()) return false;
erase(I);

13
include/llvm/Support/StringPool.h
View File

@ -1,4 +1,4 @@
//===-- StringPool.h - Interned string pool -------------------------------===//
//===-- StringPool.h - Interned string pool ---------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -64,12 +64,7 @@ namespace llvm {
/// intern - Adds a string to the pool and returns a reference-counted
/// pointer to it. No additional memory is allocated if the string already
/// exists in the pool.
PooledStringPtr intern(const char *Begin, const char *End);
/// intern - Adds a null-terminated string to the pool and returns a
/// reference-counted pointer to it. No additional memory is allocated if
/// the string already exists in the pool.
inline PooledStringPtr intern(const char *Str);
PooledStringPtr intern(const StringRef &Str);
/// empty - Checks whether the pool is empty. Returns true if so.
///
@ -139,10 +134,6 @@ namespace llvm {
inline bool operator!=(const PooledStringPtr &That) { return S != That.S; }
};
PooledStringPtr StringPool::intern(const char *Str) {
return intern(Str, Str + strlen(Str));
}
} // End llvm namespace
#endif

2
lib/Analysis/LibCallSemantics.cpp
View File

@ -59,7 +59,7 @@ const LibCallFunctionInfo *LibCallInfo::getFunctionInfo(Function *F) const {
// Look up this function in the string map.
const char *ValueName = F->getNameStart();
StringMap<const LibCallFunctionInfo*>::iterator I =
Map->find(ValueName, ValueName+F->getNameLen());
Map->find(StringRef(ValueName, F->getNameLen()));
return I != Map->end() ? I->second : 0;
}

9
lib/CodeGen/GCMetadata.cpp
View File

@ -75,20 +75,17 @@ GCModuleInfo::~GCModuleInfo() {
GCStrategy *GCModuleInfo::getOrCreateStrategy(const Module *M,
const std::string &Name) {
const char *Start = Name.c_str();
strategy_map_type::iterator NMI =
StrategyMap.find(Start, Start + Name.size());
strategy_map_type::iterator NMI = StrategyMap.find(Name);
if (NMI != StrategyMap.end())
return NMI->getValue();
for (GCRegistry::iterator I = GCRegistry::begin(),
E = GCRegistry::end(); I != E; ++I) {
if (strcmp(Start, I->getName()) == 0) {
if (Name == I->getName()) {
GCStrategy *S = I->instantiate();
S->M = M;
S->Name = Name;
StrategyMap.GetOrCreateValue(Start, Start + Name.size()).setValue(S);
StrategyMap.GetOrCreateValue(Name).setValue(S);
StrategyList.push_back(S);
return S;
}

26
lib/Support/StringMap.cpp
View File

@ -65,14 +65,13 @@ static unsigned HashString(const char *Start, const char *End) {
/// specified bucket will be non-null. Otherwise, it will be null. In either
/// case, the FullHashValue field of the bucket will be set to the hash value
/// of the string.
unsigned StringMapImpl::LookupBucketFor(const char *NameStart,
const char *NameEnd) {
unsigned StringMapImpl::LookupBucketFor(const StringRef &Name) {
unsigned HTSize = NumBuckets;
if (HTSize == 0) { // Hash table unallocated so far?
init(16);
HTSize = NumBuckets;
}
unsigned FullHashValue = HashString(NameStart, NameEnd);
unsigned FullHashValue = HashString(Name.begin(), Name.end());
unsigned BucketNo = FullHashValue & (HTSize-1);
unsigned ProbeAmt = 1;
@ -102,12 +101,10 @@ unsigned StringMapImpl::LookupBucketFor(const char *NameStart,
// being non-null and for the full hash value) not at the items. This
// is important for cache locality.
// Do the comparison like this because NameStart isn't necessarily
// Do the comparison like this because Name isn't necessarily
// null-terminated!
char *ItemStr = (char*)BucketItem+ItemSize;
unsigned ItemStrLen = BucketItem->getKeyLength();
if (unsigned(NameEnd-NameStart) == ItemStrLen &&
memcmp(ItemStr, NameStart, ItemStrLen) == 0) {
if (Name == StringRef(ItemStr, BucketItem->getKeyLength())) {
// We found a match!
return BucketNo;
}
@ -126,10 +123,10 @@ unsigned StringMapImpl::LookupBucketFor(const char *NameStart,
/// FindKey - Look up the bucket that contains the specified key. If it exists
/// in the map, return the bucket number of the key. Otherwise return -1.
/// This does not modify the map.
int StringMapImpl::FindKey(const char *KeyStart, const char *KeyEnd) const {
int StringMapImpl::FindKey(const StringRef &Key) const {
unsigned HTSize = NumBuckets;
if (HTSize == 0) return -1; // Really empty table?
unsigned FullHashValue = HashString(KeyStart, KeyEnd);
unsigned FullHashValue = HashString(Key.begin(), Key.end());
unsigned BucketNo = FullHashValue & (HTSize-1);
unsigned ProbeAmt = 1;
@ -151,9 +148,7 @@ int StringMapImpl::FindKey(const char *KeyStart, const char *KeyEnd) const {
// Do the comparison like this because NameStart isn't necessarily
// null-terminated!
char *ItemStr = (char*)BucketItem+ItemSize;
unsigned ItemStrLen = BucketItem->getKeyLength();
if (unsigned(KeyEnd-KeyStart) == ItemStrLen &&
memcmp(ItemStr, KeyStart, ItemStrLen) == 0) {
if (Key == StringRef(ItemStr, BucketItem->getKeyLength())) {
// We found a match!
return BucketNo;
}
@ -172,16 +167,15 @@ int StringMapImpl::FindKey(const char *KeyStart, const char *KeyEnd) const {
/// delete it. This aborts if the value isn't in the table.
void StringMapImpl::RemoveKey(StringMapEntryBase *V) {
const char *VStr = (char*)V + ItemSize;
StringMapEntryBase *V2 = RemoveKey(VStr, VStr+V->getKeyLength());
StringMapEntryBase *V2 = RemoveKey(StringRef(VStr, V->getKeyLength()));
V2 = V2;
assert(V == V2 && "Didn't find key?");
}
/// RemoveKey - Remove the StringMapEntry for the specified key from the
/// table, returning it. If the key is not in the table, this returns null.
StringMapEntryBase *StringMapImpl::RemoveKey(const char *KeyStart,
const char *KeyEnd) {
int Bucket = FindKey(KeyStart, KeyEnd);
StringMapEntryBase *StringMapImpl::RemoveKey(const StringRef &Key) {
int Bucket = FindKey(Key);
if (Bucket == -1) return 0;
StringMapEntryBase *Result = TheTable[Bucket].Item;

7
lib/Support/StringPool.cpp
View File

@ -13,6 +13,7 @@
#include "llvm/Support/StringPool.h"
#include "llvm/Support/Streams.h"
#include "llvm/ADT/StringRef.h"
using namespace llvm;
@ -22,12 +23,12 @@ StringPool::~StringPool() {
assert(InternTable.empty() && "PooledStringPtr leaked!");
}
PooledStringPtr StringPool::intern(const char *Begin, const char *End) {
table_t::iterator I = InternTable.find(Begin, End);
PooledStringPtr StringPool::intern(const StringRef &Key) {
table_t::iterator I = InternTable.find(Key);
if (I != InternTable.end())
return PooledStringPtr(&*I);
entry_t *S = entry_t::Create(Begin, End);
entry_t *S = entry_t::Create(Key.begin(), Key.end());
S->getValue().Pool = this;
InternTable.insert(S);

2
lib/Transforms/Scalar/SimplifyLibCalls.cpp
View File

@ -1657,7 +1657,7 @@ bool SimplifyLibCalls::runOnFunction(Function &F) {
// Ignore unknown calls.
const char *CalleeName = Callee->getNameStart();
StringMap<LibCallOptimization*>::iterator OMI =
Optimizations.find(CalleeName, CalleeName+Callee->getNameLen());
Optimizations.find(StringRef(CalleeName, Callee->getNameLen()));
if (OMI == Optimizations.end()) continue;
// Set the builder to the instruction after the call.

6
lib/VMCore/LLVMContextImpl.cpp
View File

@ -397,7 +397,7 @@ MDString *LLVMContextImpl::getMDString(const char *StrBegin,
unsigned StrLength) {
sys::SmartScopedWriter<true> Writer(ConstantsLock);
StringMapEntry<MDString *> &Entry =
MDStringCache.GetOrCreateValue(StrBegin, StrBegin + StrLength);
MDStringCache.GetOrCreateValue(StringRef(StrBegin, StrLength));
MDString *&S = Entry.getValue();
if (!S) S = new MDString(Entry.getKeyData(),
Entry.getKeyLength());
@ -460,8 +460,8 @@ Constant *LLVMContextImpl::getConstantArray(const ArrayType *Ty,
void LLVMContextImpl::erase(MDString *M) {
sys::SmartScopedWriter<true> Writer(ConstantsLock);
MDStringCache.erase(MDStringCache.find(M->StrBegin,
M->StrBegin + M->length()));
MDStringCache.erase(MDStringCache.find(StringRef(M->StrBegin,
M->length())));
}
void LLVMContextImpl::erase(MDNode *M) {

15
lib/VMCore/ValueSymbolTable.cpp
View File

@ -33,7 +33,7 @@ ValueSymbolTable::~ValueSymbolTable() {
// lookup a value - Returns null on failure...
//
Value *ValueSymbolTable::lookup(const std::string &Name) const {
const_iterator VI = vmap.find(Name.data(), Name.data() + Name.size());
const_iterator VI = vmap.find(Name);
if (VI != vmap.end()) // We found the symbol
return VI->getValue();
return 0;
@ -41,7 +41,8 @@ Value *ValueSymbolTable::lookup(const std::string &Name) const {
Value *ValueSymbolTable::lookup(const char *NameBegin,
const char *NameEnd) const {
const_iterator VI = vmap.find(NameBegin, NameEnd);
// FIXME: ValueSymbolTable should move to a StringRef based API.
const_iterator VI = vmap.find(StringRef(NameBegin, NameEnd - NameBegin));
if (VI != vmap.end()) // We found the symbol
return VI->getValue();
return 0;
@ -71,8 +72,8 @@ void ValueSymbolTable::reinsertValue(Value* V) {
UniqueName.append_uint_32(++LastUnique);
// Try insert the vmap entry with this suffix.
ValueName &NewName =
vmap.GetOrCreateValue(UniqueName.data(),
UniqueName.data() + UniqueName.size());
vmap.GetOrCreateValue(StringRef(UniqueName.data(),
UniqueName.size()));
if (NewName.getValue() == 0) {
// Newly inserted name. Success!
NewName.setValue(V);
@ -95,7 +96,7 @@ void ValueSymbolTable::removeValueName(ValueName *V) {
ValueName *ValueSymbolTable::createValueName(const char *NameStart,
unsigned NameLen, Value *V) {
// In the common case, the name is not already in the symbol table.
ValueName &Entry = vmap.GetOrCreateValue(NameStart, NameStart+NameLen);
ValueName &Entry = vmap.GetOrCreateValue(StringRef(NameStart, NameLen));
if (Entry.getValue() == 0) {
Entry.setValue(V);
//DEBUG(DOUT << " Inserted value: " << Entry.getKeyData() << ": "
@ -113,8 +114,8 @@ ValueName *ValueSymbolTable::createValueName(const char *NameStart,
// Try insert the vmap entry with this suffix.
ValueName &NewName =
vmap.GetOrCreateValue(UniqueName.data(),
UniqueName.data() + UniqueName.size());
vmap.GetOrCreateValue(StringRef(UniqueName.data(),
UniqueName.size()));
if (NewName.getValue() == 0) {
// Newly inserted name. Success!
NewName.setValue(V);

15
tools/llvm-mc/AsmLexer.cpp
View File

@ -107,8 +107,9 @@ asmtok::TokKind AsmLexer::LexIdentifier() {
*CurPtr == '.' || *CurPtr == '@')
++CurPtr;
// Unique string.
CurStrVal =
getSS(TheStringSet).GetOrCreateValue(TokStart, CurPtr, 0).getKeyData();
CurStrVal = getSS(TheStringSet).GetOrCreateValue(StringRef(TokStart,
CurPtr - TokStart),
0).getKeyData();
return asmtok::Identifier;
}
@ -121,8 +122,9 @@ asmtok::TokKind AsmLexer::LexPercent() {
++CurPtr;
// Unique string.
CurStrVal =
getSS(TheStringSet).GetOrCreateValue(TokStart, CurPtr, 0).getKeyData();
CurStrVal = getSS(TheStringSet).GetOrCreateValue(StringRef(TokStart,
CurPtr - TokStart),
0).getKeyData();
return asmtok::Register;
}
@ -249,8 +251,9 @@ asmtok::TokKind AsmLexer::LexQuote() {
}
// Unique string, include quotes for now.
CurStrVal =
getSS(TheStringSet).GetOrCreateValue(TokStart, CurPtr, 0).getKeyData();
CurStrVal = getSS(TheStringSet).GetOrCreateValue(StringRef(TokStart,
CurPtr - TokStart),
0).getKeyData();
return asmtok::String;
}

5
tools/lto/LTOModule.cpp
View File

@ -379,7 +379,7 @@ void LTOModule::addDefinedSymbol(GlobalValue* def, Mangler &mangler,
void LTOModule::addAsmGlobalSymbol(const char *name) {
// only add new define if not already defined
if ( _defines.count(name, &name[strlen(name)+1]) == 0 )
if ( _defines.count(name) == 0 )
return;
// string is owned by _defines
@ -507,8 +507,7 @@ void LTOModule::lazyParseSymbols()
it != _undefines.end(); ++it) {
// if this symbol also has a definition, then don't make an undefine
// because it is a tentative definition
if ( _defines.count(it->getKeyData(), it->getKeyData()+
it->getKeyLength()) == 0 ) {
if ( _defines.count(it->getKey())) {
NameAndAttributes info = it->getValue();
_symbols.push_back(info);
}

23
unittests/ADT/StringMapTest.cpp
View File

@ -22,7 +22,7 @@ protected:
static const char testKey[];
static const uint32_t testValue;
static const char* testKeyFirst;
static const char* testKeyLast;
static size_t testKeyLength;
static const std::string testKeyStr;
void assertEmptyMap() {
@ -35,10 +35,11 @@ protected:
// Lookup tests
EXPECT_EQ(0u, testMap.count(testKey));
EXPECT_EQ(0u, testMap.count(testKeyFirst, testKeyLast));
EXPECT_EQ(0u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
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(StringRef(testKeyFirst, testKeyLength)) ==
testMap.end());
EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end());
}
@ -57,10 +58,11 @@ protected:
// Lookup tests
EXPECT_EQ(1u, testMap.count(testKey));
EXPECT_EQ(1u, testMap.count(testKeyFirst, testKeyLast));
EXPECT_EQ(1u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
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(StringRef(testKeyFirst, testKeyLength)) ==
testMap.begin());
EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin());
}
};
@ -68,7 +70,7 @@ protected:
const char StringMapTest::testKey[] = "key";
const uint32_t StringMapTest::testValue = 1u;
const char* StringMapTest::testKeyFirst = testKey;
const char* StringMapTest::testKeyLast = testKey + sizeof(testKey) - 1;
size_t StringMapTest::testKeyLength = sizeof(testKey) - 1;
const std::string StringMapTest::testKeyStr(testKey);
// Empty map tests.
@ -90,10 +92,10 @@ TEST_F(StringMapTest, ConstEmptyMapTest) {
// Lookup tests
EXPECT_EQ(0u, constTestMap.count(testKey));
EXPECT_EQ(0u, constTestMap.count(testKeyFirst, testKeyLast));
EXPECT_EQ(0u, constTestMap.count(StringRef(testKeyFirst, testKeyLength)));
EXPECT_EQ(0u, constTestMap.count(testKeyStr));
EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end());
EXPECT_TRUE(constTestMap.find(testKeyFirst, testKeyLast) ==
EXPECT_TRUE(constTestMap.find(StringRef(testKeyFirst, testKeyLength)) ==
constTestMap.end());
EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end());
}
@ -186,7 +188,7 @@ namespace {
TEST_F(StringMapTest, StringMapEntryTest) {
StringMap<uint32_t>::value_type* entry =
StringMap<uint32_t>::value_type::Create(
testKeyFirst, testKeyLast, 1u);
testKeyFirst, testKeyFirst + testKeyLength, 1u);
EXPECT_STREQ(testKey, entry->first());
EXPECT_EQ(1u, entry->second);
}
@ -196,7 +198,8 @@ TEST_F(StringMapTest, InsertTest) {
SCOPED_TRACE("InsertTest");
testMap.insert(
StringMap<uint32_t>::value_type::Create(
testKeyFirst, testKeyLast, testMap.getAllocator(), 1u));
testKeyFirst, testKeyFirst + testKeyLength,
testMap.getAllocator(), 1u));
assertSingleItemMap();
}