mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-16 11:30:51 +00:00
9c336fabd5
to use lowercase letters for the start of most method names and to replace some method names with more descriptive names (e.g., "getLeft()" instead of "Left()"). No real functionality change. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@120070 91177308-0d34-0410-b5e6-96231b3b80d8
202 lines
4.9 KiB
C++
202 lines
4.9 KiB
C++
//===----------- ImmutableSetTest.cpp - ImmutableSet unit tests ------------===//
|
|
//
|
|
// 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/ImmutableSet.h"
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
class ImmutableSetTest : public testing::Test {
|
|
protected:
|
|
// for callback tests
|
|
static char buffer[10];
|
|
|
|
struct MyIter {
|
|
int counter;
|
|
char *ptr;
|
|
|
|
MyIter() : counter(0), ptr(buffer) {
|
|
for (unsigned i=0; i<sizeof(buffer);++i) buffer[i]='\0';
|
|
}
|
|
void operator()(char c) {
|
|
*ptr++ = c;
|
|
++counter;
|
|
}
|
|
};
|
|
};
|
|
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());
|
|
|
|
ImmutableSet<int> S = f.getEmptySet();
|
|
EXPECT_EQ(0u, S.getHeight());
|
|
EXPECT_TRUE(S.begin() == S.end());
|
|
EXPECT_FALSE(S.begin() != S.end());
|
|
}
|
|
|
|
|
|
TEST_F(ImmutableSetTest, OneElemIntSetTest) {
|
|
ImmutableSet<int>::Factory f;
|
|
ImmutableSet<int> S = f.getEmptySet();
|
|
|
|
ImmutableSet<int> S2 = f.add(S, 3);
|
|
EXPECT_TRUE(S.isEmpty());
|
|
EXPECT_FALSE(S2.isEmpty());
|
|
EXPECT_FALSE(S == S2);
|
|
EXPECT_TRUE(S != S2);
|
|
EXPECT_FALSE(S.contains(3));
|
|
EXPECT_TRUE(S2.contains(3));
|
|
EXPECT_FALSE(S2.begin() == S2.end());
|
|
EXPECT_TRUE(S2.begin() != S2.end());
|
|
|
|
ImmutableSet<int> S3 = f.add(S, 2);
|
|
EXPECT_TRUE(S.isEmpty());
|
|
EXPECT_FALSE(S3.isEmpty());
|
|
EXPECT_FALSE(S == S3);
|
|
EXPECT_TRUE(S != S3);
|
|
EXPECT_FALSE(S.contains(2));
|
|
EXPECT_TRUE(S3.contains(2));
|
|
|
|
EXPECT_FALSE(S2 == S3);
|
|
EXPECT_TRUE(S2 != S3);
|
|
EXPECT_FALSE(S2.contains(2));
|
|
EXPECT_FALSE(S3.contains(3));
|
|
}
|
|
|
|
TEST_F(ImmutableSetTest, MultiElemIntSetTest) {
|
|
ImmutableSet<int>::Factory f;
|
|
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);
|
|
|
|
EXPECT_TRUE(S.isEmpty());
|
|
EXPECT_FALSE(S2.isEmpty());
|
|
EXPECT_FALSE(S3.isEmpty());
|
|
EXPECT_FALSE(S4.isEmpty());
|
|
|
|
EXPECT_FALSE(S.contains(3));
|
|
EXPECT_FALSE(S.contains(9));
|
|
|
|
EXPECT_TRUE(S2.contains(3));
|
|
EXPECT_TRUE(S2.contains(4));
|
|
EXPECT_TRUE(S2.contains(5));
|
|
EXPECT_FALSE(S2.contains(9));
|
|
EXPECT_FALSE(S2.contains(0));
|
|
|
|
EXPECT_TRUE(S3.contains(43));
|
|
EXPECT_TRUE(S3.contains(20));
|
|
EXPECT_TRUE(S3.contains(9));
|
|
EXPECT_TRUE(S3.contains(3));
|
|
EXPECT_TRUE(S3.contains(4));
|
|
EXPECT_TRUE(S3.contains(5));
|
|
EXPECT_FALSE(S3.contains(0));
|
|
|
|
EXPECT_TRUE(S4.contains(9));
|
|
EXPECT_TRUE(S4.contains(3));
|
|
EXPECT_TRUE(S4.contains(4));
|
|
EXPECT_TRUE(S4.contains(5));
|
|
EXPECT_FALSE(S4.contains(20));
|
|
EXPECT_FALSE(S4.contains(43));
|
|
}
|
|
|
|
TEST_F(ImmutableSetTest, RemoveIntSetTest) {
|
|
ImmutableSet<int>::Factory f;
|
|
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);
|
|
|
|
EXPECT_TRUE(S3.contains(3));
|
|
EXPECT_FALSE(S2.contains(3));
|
|
EXPECT_FALSE(S4.contains(3));
|
|
|
|
EXPECT_TRUE(S2 == S4);
|
|
EXPECT_TRUE(S3 != S2);
|
|
EXPECT_TRUE(S3 != S4);
|
|
|
|
EXPECT_TRUE(S3.contains(4));
|
|
EXPECT_TRUE(S3.contains(5));
|
|
|
|
EXPECT_TRUE(S4.contains(4));
|
|
EXPECT_TRUE(S4.contains(5));
|
|
}
|
|
|
|
TEST_F(ImmutableSetTest, CallbackCharSetTest) {
|
|
ImmutableSet<char>::Factory f;
|
|
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');
|
|
|
|
S3.foreach<MyIter>();
|
|
|
|
ASSERT_STREQ("aeiou", buffer);
|
|
}
|
|
|
|
TEST_F(ImmutableSetTest, Callback2CharSetTest) {
|
|
ImmutableSet<char>::Factory f;
|
|
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');
|
|
|
|
MyIter obj;
|
|
S3.foreach<MyIter>(obj);
|
|
ASSERT_STREQ("bcdfgh", buffer);
|
|
ASSERT_EQ(6, obj.counter);
|
|
|
|
MyIter obj2;
|
|
S2.foreach<MyIter>(obj2);
|
|
ASSERT_STREQ("bcd", buffer);
|
|
ASSERT_EQ(3, obj2.counter);
|
|
|
|
MyIter obj3;
|
|
S.foreach<MyIter>(obj);
|
|
ASSERT_STREQ("", buffer);
|
|
ASSERT_EQ(0, obj3.counter);
|
|
}
|
|
|
|
TEST_F(ImmutableSetTest, IterLongSetTest) {
|
|
ImmutableSet<long>::Factory f;
|
|
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);
|
|
|
|
int i = 0;
|
|
for (ImmutableSet<long>::iterator I = S.begin(), E = S.end(); I != E; ++I) {
|
|
ASSERT_EQ(i++, *I);
|
|
}
|
|
ASSERT_EQ(0, i);
|
|
|
|
i = 0;
|
|
for (ImmutableSet<long>::iterator I = S2.begin(), E = S2.end(); I != E; ++I) {
|
|
ASSERT_EQ(i++, *I);
|
|
}
|
|
ASSERT_EQ(3, i);
|
|
|
|
i = 0;
|
|
for (ImmutableSet<long>::iterator I = S3.begin(), E = S3.end(); I != E; I++) {
|
|
ASSERT_EQ(i++, *I);
|
|
}
|
|
ASSERT_EQ(6, i);
|
|
}
|
|
|
|
}
|