diff options
Diffstat (limited to 'unittests/ADT')
| -rw-r--r-- | unittests/ADT/APIntTest.cpp | 20 | ||||
| -rw-r--r-- | unittests/ADT/FoldingSet.cpp | 39 | ||||
| -rw-r--r-- | unittests/ADT/ImmutableSetTest.cpp | 48 | ||||
| -rw-r--r-- | unittests/ADT/IntEqClassesTest.cpp | 107 | ||||
| -rw-r--r-- | unittests/ADT/IntervalMapTest.cpp | 716 | ||||
| -rw-r--r-- | unittests/ADT/StringMapTest.cpp | 2 | ||||
| -rw-r--r-- | unittests/ADT/StringRefTest.cpp | 2 | ||||
| -rw-r--r-- | unittests/ADT/TripleTest.cpp | 78 | ||||
| -rw-r--r-- | unittests/ADT/TwineTest.cpp | 8 |
9 files changed, 961 insertions, 59 deletions
diff --git a/unittests/ADT/APIntTest.cpp b/unittests/ADT/APIntTest.cpp index 9c02739..e05bdbf 100644 --- a/unittests/ADT/APIntTest.cpp +++ b/unittests/ADT/APIntTest.cpp @@ -57,7 +57,7 @@ TEST(APIntTest, i33_Count) { TEST(APIntTest, i65_Count) { APInt i65minus(65, 0, true); - i65minus.set(64); + i65minus.setBit(64); EXPECT_EQ(0u, i65minus.countLeadingZeros()); EXPECT_EQ(1u, i65minus.countLeadingOnes()); EXPECT_EQ(65u, i65minus.getActiveBits()); @@ -332,6 +332,24 @@ TEST(APIntTest, Log2) { EXPECT_EQ(APInt(15, 9).exactLogBase2(), -1); } +TEST(APIntTest, magic) { + EXPECT_EQ(APInt(32, 3).magic().m, APInt(32, "55555556", 16)); + EXPECT_EQ(APInt(32, 3).magic().s, 0U); + EXPECT_EQ(APInt(32, 5).magic().m, APInt(32, "66666667", 16)); + EXPECT_EQ(APInt(32, 5).magic().s, 1U); + EXPECT_EQ(APInt(32, 7).magic().m, APInt(32, "92492493", 16)); + EXPECT_EQ(APInt(32, 7).magic().s, 2U); +} + +TEST(APIntTest, magicu) { + EXPECT_EQ(APInt(32, 3).magicu().m, APInt(32, "AAAAAAAB", 16)); + EXPECT_EQ(APInt(32, 3).magicu().s, 1U); + EXPECT_EQ(APInt(32, 5).magicu().m, APInt(32, "CCCCCCCD", 16)); + EXPECT_EQ(APInt(32, 5).magicu().s, 2U); + EXPECT_EQ(APInt(32, 7).magicu().m, APInt(32, "24924925", 16)); + EXPECT_EQ(APInt(32, 7).magicu().s, 3U); +} + #ifdef GTEST_HAS_DEATH_TEST #ifndef NDEBUG TEST(APIntTest, StringDeath) { diff --git a/unittests/ADT/FoldingSet.cpp b/unittests/ADT/FoldingSet.cpp new file mode 100644 index 0000000..a18a0df --- /dev/null +++ b/unittests/ADT/FoldingSet.cpp @@ -0,0 +1,39 @@ +//===- llvm/unittest/ADT/FoldingSetTest.cpp -------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// FoldingSet unit tests. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/FoldingSet.h" +#include <string> + +using namespace llvm; + +namespace { + +// Unaligned string test. +TEST(FoldingSetTest, UnalignedStringTest) { + SCOPED_TRACE("UnalignedStringTest"); + + FoldingSetNodeID a, b; + // An aligned string + std::string str1= "a test string"; + a.AddString(str1); + + // An unaligned string + std::string str2 = ">" + str1; + b.AddString(str2.c_str() + 1); + + EXPECT_EQ(a.ComputeHash(), b.ComputeHash()); +} + +} + diff --git a/unittests/ADT/ImmutableSetTest.cpp b/unittests/ADT/ImmutableSetTest.cpp index 1be510d..febd441 100644 --- a/unittests/ADT/ImmutableSetTest.cpp +++ b/unittests/ADT/ImmutableSetTest.cpp @@ -37,11 +37,11 @@ char ImmutableSetTest::buffer[10]; TEST_F(ImmutableSetTest, EmptyIntSetTest) { ImmutableSet<int>::Factory f; - EXPECT_TRUE(f.GetEmptySet() == f.GetEmptySet()); - EXPECT_FALSE(f.GetEmptySet() != f.GetEmptySet()); - EXPECT_TRUE(f.GetEmptySet().isEmpty()); + EXPECT_TRUE(f.getEmptySet() == f.getEmptySet()); + EXPECT_FALSE(f.getEmptySet() != f.getEmptySet()); + EXPECT_TRUE(f.getEmptySet().isEmpty()); - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); EXPECT_EQ(0u, S.getHeight()); EXPECT_TRUE(S.begin() == S.end()); EXPECT_FALSE(S.begin() != S.end()); @@ -50,9 +50,9 @@ TEST_F(ImmutableSetTest, EmptyIntSetTest) { TEST_F(ImmutableSetTest, OneElemIntSetTest) { ImmutableSet<int>::Factory f; - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); - ImmutableSet<int> S2 = f.Add(S, 3); + ImmutableSet<int> S2 = f.add(S, 3); EXPECT_TRUE(S.isEmpty()); EXPECT_FALSE(S2.isEmpty()); EXPECT_FALSE(S == S2); @@ -62,7 +62,7 @@ TEST_F(ImmutableSetTest, OneElemIntSetTest) { EXPECT_FALSE(S2.begin() == S2.end()); EXPECT_TRUE(S2.begin() != S2.end()); - ImmutableSet<int> S3 = f.Add(S, 2); + ImmutableSet<int> S3 = f.add(S, 2); EXPECT_TRUE(S.isEmpty()); EXPECT_FALSE(S3.isEmpty()); EXPECT_FALSE(S == S3); @@ -78,11 +78,11 @@ TEST_F(ImmutableSetTest, OneElemIntSetTest) { TEST_F(ImmutableSetTest, MultiElemIntSetTest) { ImmutableSet<int>::Factory f; - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); - ImmutableSet<int> S2 = f.Add(f.Add(f.Add(S, 3), 4), 5); - ImmutableSet<int> S3 = f.Add(f.Add(f.Add(S2, 9), 20), 43); - ImmutableSet<int> S4 = f.Add(S2, 9); + ImmutableSet<int> S2 = f.add(f.add(f.add(S, 3), 4), 5); + ImmutableSet<int> S3 = f.add(f.add(f.add(S2, 9), 20), 43); + ImmutableSet<int> S4 = f.add(S2, 9); EXPECT_TRUE(S.isEmpty()); EXPECT_FALSE(S2.isEmpty()); @@ -116,11 +116,11 @@ TEST_F(ImmutableSetTest, MultiElemIntSetTest) { TEST_F(ImmutableSetTest, RemoveIntSetTest) { ImmutableSet<int>::Factory f; - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); - ImmutableSet<int> S2 = f.Add(f.Add(S, 4), 5); - ImmutableSet<int> S3 = f.Add(S2, 3); - ImmutableSet<int> S4 = f.Remove(S3, 3); + ImmutableSet<int> S2 = f.add(f.add(S, 4), 5); + ImmutableSet<int> S3 = f.add(S2, 3); + ImmutableSet<int> S4 = f.remove(S3, 3); EXPECT_TRUE(S3.contains(3)); EXPECT_FALSE(S2.contains(3)); @@ -139,10 +139,10 @@ TEST_F(ImmutableSetTest, RemoveIntSetTest) { TEST_F(ImmutableSetTest, CallbackCharSetTest) { ImmutableSet<char>::Factory f; - ImmutableSet<char> S = f.GetEmptySet(); + ImmutableSet<char> S = f.getEmptySet(); - ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'a'), 'e'), 'i'); - ImmutableSet<char> S3 = f.Add(f.Add(S2, 'o'), 'u'); + ImmutableSet<char> S2 = f.add(f.add(f.add(S, 'a'), 'e'), 'i'); + ImmutableSet<char> S3 = f.add(f.add(S2, 'o'), 'u'); S3.foreach<MyIter>(); @@ -151,10 +151,10 @@ TEST_F(ImmutableSetTest, CallbackCharSetTest) { TEST_F(ImmutableSetTest, Callback2CharSetTest) { ImmutableSet<char>::Factory f; - ImmutableSet<char> S = f.GetEmptySet(); + ImmutableSet<char> S = f.getEmptySet(); - ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'b'), 'c'), 'd'); - ImmutableSet<char> S3 = f.Add(f.Add(f.Add(S2, 'f'), 'g'), 'h'); + ImmutableSet<char> S2 = f.add(f.add(f.add(S, 'b'), 'c'), 'd'); + ImmutableSet<char> S3 = f.add(f.add(f.add(S2, 'f'), 'g'), 'h'); MyIter obj; S3.foreach<MyIter>(obj); @@ -174,10 +174,10 @@ TEST_F(ImmutableSetTest, Callback2CharSetTest) { TEST_F(ImmutableSetTest, IterLongSetTest) { ImmutableSet<long>::Factory f; - ImmutableSet<long> S = f.GetEmptySet(); + ImmutableSet<long> S = f.getEmptySet(); - ImmutableSet<long> S2 = f.Add(f.Add(f.Add(S, 0), 1), 2); - ImmutableSet<long> S3 = f.Add(f.Add(f.Add(S2, 3), 4), 5); + ImmutableSet<long> S2 = f.add(f.add(f.add(S, 0), 1), 2); + ImmutableSet<long> S3 = f.add(f.add(f.add(S2, 3), 4), 5); int i = 0; for (ImmutableSet<long>::iterator I = S.begin(), E = S.end(); I != E; ++I) { diff --git a/unittests/ADT/IntEqClassesTest.cpp b/unittests/ADT/IntEqClassesTest.cpp new file mode 100644 index 0000000..fc908c1 --- /dev/null +++ b/unittests/ADT/IntEqClassesTest.cpp @@ -0,0 +1,107 @@ +//===---- ADT/IntEqClassesTest.cpp - IntEqClasses 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 "llvm/ADT/IntEqClasses.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +TEST(IntEqClasses, Simple) { + IntEqClasses ec(10); + + ec.join(0, 1); + ec.join(3, 2); + ec.join(4, 5); + ec.join(7, 6); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(2u, ec.findLeader(2)); + EXPECT_EQ(2u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(8u, ec.findLeader(8)); + EXPECT_EQ(9u, ec.findLeader(9)); + + // join two non-leaders. + ec.join(1, 3); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(8u, ec.findLeader(8)); + EXPECT_EQ(9u, ec.findLeader(9)); + + // join two leaders. + ec.join(4, 8); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(4u, ec.findLeader(8)); + EXPECT_EQ(9u, ec.findLeader(9)); + + // join mixed. + ec.join(9, 1); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(4u, ec.findLeader(8)); + EXPECT_EQ(0u, ec.findLeader(9)); + + // compressed map. + ec.compress(); + EXPECT_EQ(3u, ec.getNumClasses()); + + EXPECT_EQ(0u, ec[0]); + EXPECT_EQ(0u, ec[1]); + EXPECT_EQ(0u, ec[2]); + EXPECT_EQ(0u, ec[3]); + EXPECT_EQ(1u, ec[4]); + EXPECT_EQ(1u, ec[5]); + EXPECT_EQ(2u, ec[6]); + EXPECT_EQ(2u, ec[7]); + EXPECT_EQ(1u, ec[8]); + EXPECT_EQ(0u, ec[9]); + + // uncompressed map. + ec.uncompress(); + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(4u, ec.findLeader(8)); + EXPECT_EQ(0u, ec.findLeader(9)); +} + +} // end anonymous namespace diff --git a/unittests/ADT/IntervalMapTest.cpp b/unittests/ADT/IntervalMapTest.cpp new file mode 100644 index 0000000..b5556d2 --- /dev/null +++ b/unittests/ADT/IntervalMapTest.cpp @@ -0,0 +1,716 @@ +//===---- ADT/IntervalMapTest.cpp - IntervalMap 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 "llvm/ADT/IntervalMap.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +typedef IntervalMap<unsigned, unsigned, 4> UUMap; + +// Empty map tests +TEST(IntervalMapTest, EmptyMap) { + UUMap::Allocator allocator; + UUMap map(allocator); + EXPECT_TRUE(map.empty()); + + // Lookup on empty map. + EXPECT_EQ(0u, map.lookup(0)); + EXPECT_EQ(7u, map.lookup(0, 7)); + EXPECT_EQ(0u, map.lookup(~0u-1)); + EXPECT_EQ(7u, map.lookup(~0u-1, 7)); + + // Iterators. + EXPECT_TRUE(map.begin() == map.begin()); + EXPECT_TRUE(map.begin() == map.end()); + EXPECT_TRUE(map.end() == map.end()); + EXPECT_FALSE(map.begin() != map.begin()); + EXPECT_FALSE(map.begin() != map.end()); + EXPECT_FALSE(map.end() != map.end()); + EXPECT_FALSE(map.begin().valid()); + EXPECT_FALSE(map.end().valid()); + UUMap::iterator I = map.begin(); + EXPECT_FALSE(I.valid()); + EXPECT_TRUE(I == map.end()); + + // Default constructor and cross-constness compares. + UUMap::const_iterator CI; + CI = map.begin(); + EXPECT_TRUE(CI == I); + UUMap::iterator I2; + I2 = map.end(); + EXPECT_TRUE(I2 == CI); +} + +// Single entry map tests +TEST(IntervalMapTest, SingleEntryMap) { + UUMap::Allocator allocator; + UUMap map(allocator); + map.insert(100, 150, 1); + EXPECT_FALSE(map.empty()); + + // Lookup around interval. + EXPECT_EQ(0u, map.lookup(0)); + EXPECT_EQ(0u, map.lookup(99)); + EXPECT_EQ(1u, map.lookup(100)); + EXPECT_EQ(1u, map.lookup(101)); + EXPECT_EQ(1u, map.lookup(125)); + EXPECT_EQ(1u, map.lookup(149)); + EXPECT_EQ(1u, map.lookup(150)); + EXPECT_EQ(0u, map.lookup(151)); + EXPECT_EQ(0u, map.lookup(200)); + EXPECT_EQ(0u, map.lookup(~0u-1)); + + // Iterators. + EXPECT_TRUE(map.begin() == map.begin()); + EXPECT_FALSE(map.begin() == map.end()); + EXPECT_TRUE(map.end() == map.end()); + EXPECT_TRUE(map.begin().valid()); + EXPECT_FALSE(map.end().valid()); + + // Iter deref. + UUMap::iterator I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(1u, I.value()); + + // Preincrement. + ++I; + EXPECT_FALSE(I.valid()); + EXPECT_FALSE(I == map.begin()); + EXPECT_TRUE(I == map.end()); + + // PreDecrement. + --I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(1u, I.value()); + EXPECT_TRUE(I == map.begin()); + EXPECT_FALSE(I == map.end()); + + // Change the value. + I.setValue(2); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Grow the bounds. + I.setStart(0); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(0u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(2u, I.value()); + + I.setStop(200); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(0u, I.start()); + EXPECT_EQ(200u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Shrink the bounds. + I.setStart(150); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(150u, I.start()); + EXPECT_EQ(200u, I.stop()); + EXPECT_EQ(2u, I.value()); + + I.setStop(160); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(150u, I.start()); + EXPECT_EQ(160u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Erase last elem. + I.erase(); + EXPECT_TRUE(map.empty()); + EXPECT_EQ(0, std::distance(map.begin(), map.end())); +} + +// Flat coalescing tests. +TEST(IntervalMapTest, RootCoalescing) { + UUMap::Allocator allocator; + UUMap map(allocator); + map.insert(100, 150, 1); + + // Coalesce from the left. + map.insert(90, 99, 1); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(150u, map.stop()); + + // Coalesce from the right. + map.insert(151, 200, 1); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(200u, map.stop()); + + // Non-coalesce from the left. + map.insert(60, 89, 2); + EXPECT_EQ(2, std::distance(map.begin(), map.end())); + EXPECT_EQ(60u, map.start()); + EXPECT_EQ(200u, map.stop()); + EXPECT_EQ(2u, map.lookup(89)); + EXPECT_EQ(1u, map.lookup(90)); + + UUMap::iterator I = map.begin(); + EXPECT_EQ(60u, I.start()); + EXPECT_EQ(89u, I.stop()); + EXPECT_EQ(2u, I.value()); + ++I; + EXPECT_EQ(90u, I.start()); + EXPECT_EQ(200u, I.stop()); + EXPECT_EQ(1u, I.value()); + ++I; + EXPECT_FALSE(I.valid()); + + // Non-coalesce from the right. + map.insert(201, 210, 2); + EXPECT_EQ(3, std::distance(map.begin(), map.end())); + EXPECT_EQ(60u, map.start()); + EXPECT_EQ(210u, map.stop()); + EXPECT_EQ(2u, map.lookup(201)); + EXPECT_EQ(1u, map.lookup(200)); + + // Erase from the left. + map.begin().erase(); + EXPECT_EQ(2, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(210u, map.stop()); + + // Erase from the right. + (--map.end()).erase(); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(200u, map.stop()); + + // Add non-coalescing, then trigger coalescing with setValue. + map.insert(80, 89, 2); + map.insert(201, 210, 2); + EXPECT_EQ(3, std::distance(map.begin(), map.end())); + (++map.begin()).setValue(2); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(80u, I.start()); + EXPECT_EQ(210u, I.stop()); + EXPECT_EQ(2u, I.value()); +} + +// Flat multi-coalescing tests. +TEST(IntervalMapTest, RootMultiCoalescing) { + UUMap::Allocator allocator; + UUMap map(allocator); + map.insert(140, 150, 1); + map.insert(160, 170, 1); + map.insert(100, 110, 1); + map.insert(120, 130, 1); + EXPECT_EQ(4, std::distance(map.begin(), map.end())); + EXPECT_EQ(100u, map.start()); + EXPECT_EQ(170u, map.stop()); + + // Verify inserts. + UUMap::iterator I = map.begin(); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(110u, I.stop()); + ++I; + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(130u, I.stop()); + ++I; + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Test advanceTo on flat tree. + I = map.begin(); + I.advanceTo(135); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + + I.advanceTo(145); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + + I.advanceTo(200); + EXPECT_FALSE(I.valid()); + + I.advanceTo(300); + EXPECT_FALSE(I.valid()); + + // Coalesce left with followers. + // [100;110] [120;130] [140;150] [160;170] + map.insert(111, 115, 1); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(115u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(130u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Coalesce right with followers. + // [100;115] [120;130] [140;150] [160;170] + map.insert(135, 139, 1); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(115u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(130u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(135u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Coalesce left and right with followers. + // [100;115] [120;130] [135;150] [160;170] + map.insert(131, 134, 1); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(115u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Test clear() on non-branched map. + map.clear(); + EXPECT_TRUE(map.empty()); + EXPECT_TRUE(map.begin() == map.end()); +} + +// Branched, non-coalescing tests. +TEST(IntervalMapTest, Branched) { + UUMap::Allocator allocator; + UUMap map(allocator); + + // Insert enough intervals to force a branched tree. + // This creates 9 leaf nodes with 11 elements each, tree height = 1. + for (unsigned i = 1; i < 100; ++i) { + map.insert(10*i, 10*i+5, i); + EXPECT_EQ(10u, map.start()); + EXPECT_EQ(10*i+5, map.stop()); + } + + // Tree limits. + EXPECT_FALSE(map.empty()); + EXPECT_EQ(10u, map.start()); + EXPECT_EQ(995u, map.stop()); + + // Tree lookup. + for (unsigned i = 1; i < 100; ++i) { + EXPECT_EQ(0u, map.lookup(10*i-1)); + EXPECT_EQ(i, map.lookup(10*i)); + EXPECT_EQ(i, map.lookup(10*i+5)); + EXPECT_EQ(0u, map.lookup(10*i+6)); + } + + // Forward iteration. + UUMap::iterator I = map.begin(); + for (unsigned i = 1; i < 100; ++i) { + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + ++I; + } + EXPECT_FALSE(I.valid()); + EXPECT_TRUE(I == map.end()); + + // Backwards iteration. + for (unsigned i = 99; i; --i) { + --I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + } + EXPECT_TRUE(I == map.begin()); + + // Test advanceTo in same node. + I.advanceTo(20); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(25u, I.stop()); + + // Change value, no coalescing. + I.setValue(0); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(25u, I.stop()); + EXPECT_EQ(0u, I.value()); + + // Close the gap right, no coalescing. + I.setStop(29); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(29u, I.stop()); + EXPECT_EQ(0u, I.value()); + + // Change value, no coalescing. + I.setValue(2); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(29u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Change value, now coalescing. + I.setValue(3); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(35u, I.stop()); + EXPECT_EQ(3u, I.value()); + + // Close the gap, now coalescing. + I.setValue(4); + ASSERT_TRUE(I.valid()); + I.setStop(39); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(45u, I.stop()); + EXPECT_EQ(4u, I.value()); + + // advanceTo another node. + I.advanceTo(200); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(200u, I.start()); + EXPECT_EQ(205u, I.stop()); + + // Close the gap left, no coalescing. + I.setStart(196); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(196u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(20u, I.value()); + + // Change value, no coalescing. + I.setValue(0); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(196u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(0u, I.value()); + + // Change value, now coalescing. + I.setValue(19); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(190u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(19u, I.value()); + + // Close the gap, now coalescing. + I.setValue(18); + ASSERT_TRUE(I.valid()); + I.setStart(186); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(180u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(18u, I.value()); + + // Erase from the front. + I = map.begin(); + for (unsigned i = 0; i != 20; ++i) { + I.erase(); + EXPECT_TRUE(I == map.begin()); + EXPECT_FALSE(map.empty()); + EXPECT_EQ(I.start(), map.start()); + EXPECT_EQ(995u, map.stop()); + } + + // Test clear() on branched map. + map.clear(); + EXPECT_TRUE(map.empty()); + EXPECT_TRUE(map.begin() == map.end()); +} + +// Branched, high, non-coalescing tests. +TEST(IntervalMapTest, Branched2) { + UUMap::Allocator allocator; + UUMap map(allocator); + + // Insert enough intervals to force a height >= 2 tree. + for (unsigned i = 1; i < 1000; ++i) + map.insert(10*i, 10*i+5, i); + + // Tree limits. + EXPECT_FALSE(map.empty()); + EXPECT_EQ(10u, map.start()); + EXPECT_EQ(9995u, map.stop()); + + // Tree lookup. + for (unsigned i = 1; i < 1000; ++i) { + EXPECT_EQ(0u, map.lookup(10*i-1)); + EXPECT_EQ(i, map.lookup(10*i)); + EXPECT_EQ(i, map.lookup(10*i+5)); + EXPECT_EQ(0u, map.lookup(10*i+6)); + } + + // Forward iteration. + UUMap::iterator I = map.begin(); + for (unsigned i = 1; i < 1000; ++i) { + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + ++I; + } + EXPECT_FALSE(I.valid()); + EXPECT_TRUE(I == map.end()); + + // Backwards iteration. + for (unsigned i = 999; i; --i) { + --I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + } + EXPECT_TRUE(I == map.begin()); + + // Test advanceTo in same node. + I.advanceTo(20); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(25u, I.stop()); + + // advanceTo sibling leaf node. + I.advanceTo(200); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(200u, I.start()); + EXPECT_EQ(205u, I.stop()); + + // advanceTo further. + I.advanceTo(2000); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(2000u, I.start()); + EXPECT_EQ(2005u, I.stop()); + + // advanceTo beyond end() + I.advanceTo(20000); + EXPECT_FALSE(I.valid()); + + // end().advanceTo() is valid as long as x > map.stop() + I.advanceTo(30000); + EXPECT_FALSE(I.valid()); + + // Test clear() on branched map. + map.clear(); + EXPECT_TRUE(map.empty()); + EXPECT_TRUE(map.begin() == map.end()); +} + +// Random insertions, coalescing to a single interval. +TEST(IntervalMapTest, RandomCoalescing) { + UUMap::Allocator allocator; + UUMap map(allocator); + + // This is a poor PRNG with maximal period: + // x_n = 5 x_{n-1} + 1 mod 2^N + + unsigned x = 100; + for (unsigned i = 0; i != 4096; ++i) { + map.insert(10*x, 10*x+9, 1); + EXPECT_GE(10*x, map.start()); + EXPECT_LE(10*x+9, map.stop()); + x = (5*x+1)%4096; + } + + // Map should be fully coalesced after that exercise. + EXPECT_FALSE(map.empty()); + EXPECT_EQ(0u, map.start()); + EXPECT_EQ(40959u, map.stop()); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + +} + +TEST(IntervalMapOverlapsTest, SmallMaps) { + typedef IntervalMapOverlaps<UUMap,UUMap> UUOverlaps; + UUMap::Allocator allocator; + UUMap mapA(allocator); + UUMap mapB(allocator); + + // empty, empty. + EXPECT_FALSE(UUOverlaps(mapA, mapB).valid()); + + mapA.insert(1, 2, 3); + + // full, empty + EXPECT_FALSE(UUOverlaps(mapA, mapB).valid()); + // empty, full + EXPECT_FALSE(UUOverlaps(mapB, mapA).valid()); + + mapB.insert(3, 4, 5); + + // full, full, non-overlapping + EXPECT_FALSE(UUOverlaps(mapA, mapB).valid()); + EXPECT_FALSE(UUOverlaps(mapB, mapA).valid()); + + // Add an overlapping segment. + mapA.insert(4, 5, 6); + + UUOverlaps AB(mapA, mapB); + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(4u, AB.a().start()); + EXPECT_EQ(3u, AB.b().start()); + ++AB; + EXPECT_FALSE(AB.valid()); + + UUOverlaps BA(mapB, mapA); + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(3u, BA.a().start()); + EXPECT_EQ(4u, BA.b().start()); + // advance past end. + BA.advanceTo(6); + EXPECT_FALSE(BA.valid()); + // advance an invalid iterator. + BA.advanceTo(7); + EXPECT_FALSE(BA.valid()); +} + +TEST(IntervalMapOverlapsTest, BigMaps) { + typedef IntervalMapOverlaps<UUMap,UUMap> UUOverlaps; + UUMap::Allocator allocator; + UUMap mapA(allocator); + UUMap mapB(allocator); + + // [0;4] [10;14] [20;24] ... + for (unsigned n = 0; n != 100; ++n) + mapA.insert(10*n, 10*n+4, n); + + // [5;6] [15;16] [25;26] ... + for (unsigned n = 10; n != 20; ++n) + mapB.insert(10*n+5, 10*n+6, n); + + // [208;209] [218;219] ... + for (unsigned n = 20; n != 30; ++n) + mapB.insert(10*n+8, 10*n+9, n); + + // insert some overlapping segments. + mapB.insert(400, 400, 400); + mapB.insert(401, 401, 401); + mapB.insert(402, 500, 402); + mapB.insert(600, 601, 402); + + UUOverlaps AB(mapA, mapB); + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(400u, AB.a().start()); + EXPECT_EQ(400u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(400u, AB.a().start()); + EXPECT_EQ(401u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(400u, AB.a().start()); + EXPECT_EQ(402u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(410u, AB.a().start()); + EXPECT_EQ(402u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(420u, AB.a().start()); + EXPECT_EQ(402u, AB.b().start()); + AB.skipB(); + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(600u, AB.a().start()); + EXPECT_EQ(600u, AB.b().start()); + ++AB; + EXPECT_FALSE(AB.valid()); + + // Test advanceTo. + UUOverlaps AB2(mapA, mapB); + AB2.advanceTo(410); + ASSERT_TRUE(AB2.valid()); + EXPECT_EQ(410u, AB2.a().start()); + EXPECT_EQ(402u, AB2.b().start()); + + // It is valid to advanceTo with any monotonic sequence. + AB2.advanceTo(411); + ASSERT_TRUE(AB2.valid()); + EXPECT_EQ(410u, AB2.a().start()); + EXPECT_EQ(402u, AB2.b().start()); + + // Check reversed maps. + UUOverlaps BA(mapB, mapA); + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(400u, BA.b().start()); + EXPECT_EQ(400u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(400u, BA.b().start()); + EXPECT_EQ(401u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(400u, BA.b().start()); + EXPECT_EQ(402u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(410u, BA.b().start()); + EXPECT_EQ(402u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(420u, BA.b().start()); + EXPECT_EQ(402u, BA.a().start()); + BA.skipA(); + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(600u, BA.b().start()); + EXPECT_EQ(600u, BA.a().start()); + ++BA; + EXPECT_FALSE(BA.valid()); + + // Test advanceTo. + UUOverlaps BA2(mapB, mapA); + BA2.advanceTo(410); + ASSERT_TRUE(BA2.valid()); + EXPECT_EQ(410u, BA2.b().start()); + EXPECT_EQ(402u, BA2.a().start()); + + BA2.advanceTo(411); + ASSERT_TRUE(BA2.valid()); + EXPECT_EQ(410u, BA2.b().start()); + EXPECT_EQ(402u, BA2.a().start()); +} + +} // namespace diff --git a/unittests/ADT/StringMapTest.cpp b/unittests/ADT/StringMapTest.cpp index 413f068..ea91348 100644 --- a/unittests/ADT/StringMapTest.cpp +++ b/unittests/ADT/StringMapTest.cpp @@ -9,7 +9,7 @@ #include "gtest/gtest.h" #include "llvm/ADT/StringMap.h" -#include "llvm/System/DataTypes.h" +#include "llvm/Support/DataTypes.h" using namespace llvm; namespace { diff --git a/unittests/ADT/StringRefTest.cpp b/unittests/ADT/StringRefTest.cpp index 7e4d0dc..5731e4a 100644 --- a/unittests/ADT/StringRefTest.cpp +++ b/unittests/ADT/StringRefTest.cpp @@ -16,7 +16,7 @@ using namespace llvm; namespace llvm { std::ostream &operator<<(std::ostream &OS, const StringRef &S) { - OS << S; + OS << S.str(); return OS; } diff --git a/unittests/ADT/TripleTest.cpp b/unittests/ADT/TripleTest.cpp index bcc7196..160b692 100644 --- a/unittests/ADT/TripleTest.cpp +++ b/unittests/ADT/TripleTest.cpp @@ -85,9 +85,7 @@ TEST(TripleTest, ParsedIDs) { EXPECT_EQ(Triple::x86_64, T.getArch()); EXPECT_EQ(Triple::PC, T.getVendor()); EXPECT_EQ(Triple::Linux, T.getOS()); - // When environments are defined, change this test to verify the "gnu" - // environment. - EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + EXPECT_EQ(Triple::GNU, T.getEnvironment()); T = Triple("powerpc-dunno-notsure"); EXPECT_EQ(Triple::ppc, T.getArch()); @@ -95,6 +93,12 @@ TEST(TripleTest, ParsedIDs) { EXPECT_EQ(Triple::UnknownOS, T.getOS()); EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + T = Triple("arm-none-none-eabi"); + EXPECT_EQ(Triple::arm, T.getArch()); + EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); + EXPECT_EQ(Triple::UnknownOS, T.getOS()); + EXPECT_EQ(Triple::EABI, T.getEnvironment()); + T = Triple("huh"); EXPECT_EQ(Triple::UnknownArch, T.getArch()); } @@ -110,6 +114,7 @@ static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) { } TEST(TripleTest, Normalization) { + EXPECT_EQ("", Triple::normalize("")); EXPECT_EQ("-", Triple::normalize("-")); EXPECT_EQ("--", Triple::normalize("--")); @@ -144,10 +149,11 @@ TEST(TripleTest, Normalization) { EXPECT_EQ("-pc", Triple::normalize("pc")); EXPECT_EQ("--linux", Triple::normalize("linux")); + EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux")); + // Check that normalizing a permutated set of valid components returns a // triple with the unpermuted components. StringRef C[4]; - C[3] = "environment"; for (int Arch = 1+Triple::UnknownArch; Arch < Triple::InvalidArch; ++Arch) { C[0] = Triple::getArchTypeName(Triple::ArchType(Arch)); for (int Vendor = 1+Triple::UnknownVendor; Vendor <= Triple::PC; @@ -156,46 +162,52 @@ TEST(TripleTest, Normalization) { for (int OS = 1+Triple::UnknownOS; OS <= Triple::Minix; ++OS) { C[2] = Triple::getOSTypeName(Triple::OSType(OS)); - std::string E = Join(C[0], C[1], C[2]); - std::string F = Join(C[0], C[1], C[2], C[3]); - EXPECT_EQ(E, Triple::normalize(Join(C[0], C[1], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[2], C[3]))); - // If a value has multiple interpretations, then the permutation // test will inevitably fail. Currently this is only the case for // "psp" which parses as both an architecture and an O/S. if (OS == Triple::Psp) continue; + std::string E = Join(C[0], C[1], C[2]); + EXPECT_EQ(E, Triple::normalize(Join(C[0], C[1], C[2]))); + EXPECT_EQ(E, Triple::normalize(Join(C[0], C[2], C[1]))); EXPECT_EQ(E, Triple::normalize(Join(C[1], C[2], C[0]))); EXPECT_EQ(E, Triple::normalize(Join(C[1], C[0], C[2]))); EXPECT_EQ(E, Triple::normalize(Join(C[2], C[0], C[1]))); EXPECT_EQ(E, Triple::normalize(Join(C[2], C[1], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[3], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[3], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[1], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[1], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[2], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[3], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[0], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[0], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[2], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[2], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[3], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[0], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[1], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[1], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[3], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[3], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[0], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[1], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[2], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[2], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[0], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[0], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[1], C[0]))); + for (int Env = 1+Triple::UnknownEnvironment; Env <= Triple::MachO; + ++Env) { + C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env)); + + std::string F = Join(C[0], C[1], C[2], C[3]); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[2], C[3]))); + + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[3], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[3], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[1], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[1], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[2], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[3], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[0], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[0], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[2], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[2], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[3], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[0], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[1], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[1], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[3], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[3], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[0], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[1], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[2], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[2], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[0], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[0], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[1], C[0]))); + } } } } @@ -210,6 +222,7 @@ TEST(TripleTest, Normalization) { EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu + EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi } TEST(TripleTest, MutateName) { @@ -251,6 +264,7 @@ TEST(TripleTest, MutateName) { EXPECT_EQ(Triple::PC, T.getVendor()); EXPECT_EQ(Triple::Darwin, T.getOS()); EXPECT_EQ("i386-pc-darwin", T.getTriple()); + } } diff --git a/unittests/ADT/TwineTest.cpp b/unittests/ADT/TwineTest.cpp index 61e8a0a..57f54cb 100644 --- a/unittests/ADT/TwineTest.cpp +++ b/unittests/ADT/TwineTest.cpp @@ -9,6 +9,7 @@ #include "gtest/gtest.h" #include "llvm/ADT/Twine.h" +#include "llvm/ADT/SmallString.h" #include "llvm/Support/raw_ostream.h" using namespace llvm; @@ -69,6 +70,13 @@ TEST(TwineTest, Concat) { repr(Twine("a").concat(Twine("b").concat(Twine("c"))))); } +TEST(TwineTest, toNullTerminatedStringRef) { + SmallString<8> storage; + EXPECT_EQ(0, *Twine("hello").toNullTerminatedStringRef(storage).end()); + EXPECT_EQ(0, + *Twine(StringRef("hello")).toNullTerminatedStringRef(storage).end()); +} + // I suppose linking in the entire code generator to add a unit test to check // the code size of the concat operation is overkill... :) |