← Back to branch summary

~ubuntu-branches/ubuntu/maverick/clamav/maverick-backports

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/unittests/ADT/ImmutableSetTest.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Stephen Gran, Stephen Gran, Michael Tautschnig
  • Date: 2010-04-26 21:41:18 UTC
  • mfrom: (2.1.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100426214118-i6lo606wnh7ywfj6
Tags: 0.96+dfsg-4
http://bugs.debian.org/579271
http://bugs.debian.org/579068
[ Stephen Gran ]
* Fixed typo in clamav-milter's postinst

[ Michael Tautschnig ]
* Fixed typo in clamav-freshclam's postinst (closes: #579271)
* Debconf translation updates
  - Portuguese (closes: #579068)

Show diffs side-by-side

added added

removed removed

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