unittests/ADT/ImmutableSetTest.cpp

   1 // llvm/unittest/ADT/ImmutableSetTest.cpp - ImmutableSet unit tests -*- C++ -*-//
   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/ImmutableSet.h"
  12
  13 using namespace llvm;
  14
  15 namespace {
  16 class ImmutableSetTest : public testing::Test {
  17 };
  18
  19
  20 TEST_F(ImmutableSetTest, EmptyIntSetTest) {
  21   ImmutableSet<int>::Factory f;
  22
  23   EXPECT_TRUE(f.GetEmptySet() == f.GetEmptySet());
  24   EXPECT_FALSE(f.GetEmptySet() != f.GetEmptySet());
  25   EXPECT_TRUE(f.GetEmptySet().isEmpty());
  26
  27   ImmutableSet<int> S = f.GetEmptySet();
  28   EXPECT_EQ(0u, S.getHeight());
  29   EXPECT_TRUE(S.begin() == S.end());
  30   EXPECT_FALSE(S.begin() != S.end());
  31 }
  32
  33
  34 TEST_F(ImmutableSetTest, OneElemIntSetTest) {
  35   ImmutableSet<int>::Factory f;
  36   ImmutableSet<int> S = f.GetEmptySet();
  37
  38   ImmutableSet<int> S2 = f.Add(S, 3);
  39   EXPECT_TRUE(S.isEmpty());
  40   EXPECT_FALSE(S2.isEmpty());
  41   EXPECT_FALSE(S == S2);
  42   EXPECT_TRUE(S != S2);
  43   EXPECT_FALSE(S.contains(3));
  44   EXPECT_TRUE(S2.contains(3));
  45   EXPECT_FALSE(S2.begin() == S2.end());
  46   EXPECT_TRUE(S2.begin() != S2.end());
  47
  48   ImmutableSet<int> S3 = f.Add(S, 2);
  49   EXPECT_TRUE(S.isEmpty());
  50   EXPECT_FALSE(S3.isEmpty());
  51   EXPECT_FALSE(S == S3);
  52   EXPECT_TRUE(S != S3);
  53   EXPECT_FALSE(S.contains(2));
  54   EXPECT_TRUE(S3.contains(2));
  55
  56   EXPECT_FALSE(S2 == S3);
  57   EXPECT_TRUE(S2 != S3);
  58   EXPECT_FALSE(S2.contains(2));
  59   EXPECT_FALSE(S3.contains(3));
  60 }
  61
  62 TEST_F(ImmutableSetTest, MultiElemIntSetTest) {
  63   ImmutableSet<int>::Factory f;
  64   ImmutableSet<int> S = f.GetEmptySet();
  65
  66   ImmutableSet<int> S2 = f.Add(f.Add(f.Add(S, 3), 4), 5);
  67   ImmutableSet<int> S3 = f.Add(f.Add(f.Add(S2, 9), 20), 43);
  68   ImmutableSet<int> S4 = f.Add(S2, 9);
  69
  70   EXPECT_TRUE(S.isEmpty());
  71   EXPECT_FALSE(S2.isEmpty());
  72   EXPECT_FALSE(S3.isEmpty());
  73   EXPECT_FALSE(S4.isEmpty());
  74
  75   EXPECT_FALSE(S.contains(3));
  76   EXPECT_FALSE(S.contains(9));
  77
  78   EXPECT_TRUE(S2.contains(3));
  79   EXPECT_TRUE(S2.contains(4));
  80   EXPECT_TRUE(S2.contains(5));
  81   EXPECT_FALSE(S2.contains(9));
  82   EXPECT_FALSE(S2.contains(0));
  83
  84   EXPECT_TRUE(S3.contains(43));
  85   EXPECT_TRUE(S3.contains(20));
  86   EXPECT_TRUE(S3.contains(9));
  87   EXPECT_TRUE(S3.contains(3));
  88   EXPECT_TRUE(S3.contains(4));
  89   EXPECT_TRUE(S3.contains(5));
  90   EXPECT_FALSE(S3.contains(0));
  91
  92   EXPECT_TRUE(S4.contains(9));
  93   EXPECT_TRUE(S4.contains(3));
  94   EXPECT_TRUE(S4.contains(4));
  95   EXPECT_TRUE(S4.contains(5));
  96   EXPECT_FALSE(S4.contains(20));
  97   EXPECT_FALSE(S4.contains(43));
  98 }
  99
 100 TEST_F(ImmutableSetTest, RemoveIntSetTest) {
 101   ImmutableSet<int>::Factory f;
 102   ImmutableSet<int> S = f.GetEmptySet();
 103
 104   ImmutableSet<int> S2 = f.Add(f.Add(S, 4), 5);
 105   ImmutableSet<int> S3 = f.Add(S2, 3);
 106   ImmutableSet<int> S4 = f.Remove(S3, 3);
 107
 108   EXPECT_TRUE(S3.contains(3));
 109   EXPECT_FALSE(S2.contains(3));
 110   EXPECT_FALSE(S4.contains(3));
 111
 112   EXPECT_TRUE(S2 == S4);
 113   EXPECT_TRUE(S3 != S2);
 114   EXPECT_TRUE(S3 != S4);
 115
 116   EXPECT_TRUE(S3.contains(4));
 117   EXPECT_TRUE(S3.contains(5));
 118
 119   EXPECT_TRUE(S4.contains(4));
 120   EXPECT_TRUE(S4.contains(5));
 121 }
 122
 123
 124 static char *ptr; // tmp var
 125 struct MyIter {
 126   int counter;
 127   MyIter() : counter(0) {}
 128   void operator()(char c) {
 129     *ptr++ = c;
 130     ++counter;
 131   }
 132 };
 133
 134 TEST_F(ImmutableSetTest, CallbackCharSetTest) {
 135   ImmutableSet<char>::Factory f;
 136   ImmutableSet<char> S = f.GetEmptySet();
 137
 138   ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'a'), 'e'), 'i');
 139   ImmutableSet<char> S3 = f.Add(f.Add(S2, 'o'), 'u');
 140
 141   char buffer[6] = {0};
 142   ptr = buffer;
 143   S3.foreach<MyIter>();
 144
 145   ASSERT_EQ(buffer[0], 'a');
 146   ASSERT_EQ(buffer[1], 'e');
 147   ASSERT_EQ(buffer[2], 'i');
 148   ASSERT_EQ(buffer[3], 'o');
 149   ASSERT_EQ(buffer[4], 'u');
 150   ASSERT_EQ(buffer[5], 0);
 151 }
 152
 153 TEST_F(ImmutableSetTest, Callback2CharSetTest) {
 154   ImmutableSet<char>::Factory f;
 155   ImmutableSet<char> S = f.GetEmptySet();
 156
 157   ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'b'), 'c'), 'd');
 158   ImmutableSet<char> S3 = f.Add(f.Add(f.Add(S2, 'f'), 'g'), 'h');
 159
 160   char buffer[7] = {0};
 161   ptr = buffer;
 162   MyIter obj;
 163   S3.foreach<MyIter>(obj);
 164
 165   ASSERT_EQ(buffer[0], 'b');
 166   ASSERT_EQ(buffer[1], 'c');
 167   ASSERT_EQ(buffer[2], 'd');
 168   ASSERT_EQ(buffer[3], 'f');
 169   ASSERT_EQ(buffer[4], 'g');
 170   ASSERT_EQ(buffer[5], 'h');
 171   ASSERT_EQ(buffer[6], 0);
 172
 173   ASSERT_EQ(obj.counter, 6);
 174
 175   ptr = buffer;
 176   S2.foreach<MyIter>(obj);
 177   ASSERT_EQ(obj.counter, 6+3);
 178
 179   ptr = buffer;
 180   S.foreach<MyIter>(obj);
 181   ASSERT_EQ(obj.counter, 6+3+0);
 182 }
 183
 184 TEST_F(ImmutableSetTest, IterLongSetTest) {
 185   ImmutableSet<long>::Factory f;
 186   ImmutableSet<long> S = f.GetEmptySet();
 187
 188   ImmutableSet<long> S2 = f.Add(f.Add(f.Add(S, 0), 1), 2);
 189   ImmutableSet<long> S3 = f.Add(f.Add(f.Add(S2, 3), 4), 5);
 190
 191   int i = 0;
 192   for (ImmutableSet<long>::iterator I = S.begin(), E = S.end(); I != E; ++I) {
 193     ASSERT_EQ(*I, i++);
 194   }
 195   ASSERT_EQ(i, 0);
 196
 197   i = 0;
 198   for (ImmutableSet<long>::iterator I = S2.begin(), E = S2.end(); I != E; ++I) {
 199     ASSERT_EQ(*I, i++);
 200   }
 201   ASSERT_EQ(i, 3);
 202
 203   i = 0;
 204   for (ImmutableSet<long>::iterator I = S3.begin(), E = S3.end(); I != E; I++) {
 205     ASSERT_EQ(*I, i++);
 206   }
 207   ASSERT_EQ(i, 6);
 208 }
 209
 210 }