← 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/Support/ValueHandleTest.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/Support/ValueHandleTest.cpp
 
1
//===- llvm/unittest/Support/ValueHandleTest.cpp - ValueHandle 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 "llvm/Support/ValueHandle.h"
 
11
 
 
12
#include "llvm/Constants.h"
 
13
#include "llvm/Instructions.h"
 
14
#include "llvm/LLVMContext.h"
 
15
#include "llvm/ADT/OwningPtr.h"
 
16
 
 
17
#include "gtest/gtest.h"
 
18
 
 
19
#include <memory>
 
20
 
 
21
using namespace llvm;
 
22
 
 
23
namespace {
 
24
 
 
25
class ValueHandle : public testing::Test {
 
26
protected:
 
27
  Constant *ConstantV;
 
28
  std::auto_ptr<BitCastInst> BitcastV;
 
29
 
 
30
  ValueHandle() :
 
31
    ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)),
 
32
    BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(getGlobalContext()))) {
 
33
  }
 
34
};
 
35
 
 
36
class ConcreteCallbackVH : public CallbackVH {
 
37
public:
 
38
  ConcreteCallbackVH() : CallbackVH() {}
 
39
  ConcreteCallbackVH(Value *V) : CallbackVH(V) {}
 
40
};
 
41
 
 
42
TEST_F(ValueHandle, WeakVH_BasicOperation) {
 
43
  WeakVH WVH(BitcastV.get());
 
44
  EXPECT_EQ(BitcastV.get(), WVH);
 
45
  WVH = ConstantV;
 
46
  EXPECT_EQ(ConstantV, WVH);
 
47
 
 
48
  // Make sure I can call a method on the underlying Value.  It
 
49
  // doesn't matter which method.
 
50
  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), WVH->getType());
 
51
  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*WVH).getType());
 
52
}
 
53
 
 
54
TEST_F(ValueHandle, WeakVH_Comparisons) {
 
55
  WeakVH BitcastWVH(BitcastV.get());
 
56
  WeakVH ConstantWVH(ConstantV);
 
57
 
 
58
  EXPECT_TRUE(BitcastWVH == BitcastWVH);
 
59
  EXPECT_TRUE(BitcastV.get() == BitcastWVH);
 
60
  EXPECT_TRUE(BitcastWVH == BitcastV.get());
 
61
  EXPECT_FALSE(BitcastWVH == ConstantWVH);
 
62
 
 
63
  EXPECT_TRUE(BitcastWVH != ConstantWVH);
 
64
  EXPECT_TRUE(BitcastV.get() != ConstantWVH);
 
65
  EXPECT_TRUE(BitcastWVH != ConstantV);
 
66
  EXPECT_FALSE(BitcastWVH != BitcastWVH);
 
67
 
 
68
  // Cast to Value* so comparisons work.
 
69
  Value *BV = BitcastV.get();
 
70
  Value *CV = ConstantV;
 
71
  EXPECT_EQ(BV < CV, BitcastWVH < ConstantWVH);
 
72
  EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantWVH);
 
73
  EXPECT_EQ(BV > CV, BitcastWVH > ConstantWVH);
 
74
  EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantWVH);
 
75
 
 
76
  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantWVH);
 
77
  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantWVH);
 
78
  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantWVH);
 
79
  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantWVH);
 
80
 
 
81
  EXPECT_EQ(BV < CV, BitcastWVH < ConstantV);
 
82
  EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantV);
 
83
  EXPECT_EQ(BV > CV, BitcastWVH > ConstantV);
 
84
  EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantV);
 
85
}
 
86
 
 
87
TEST_F(ValueHandle, WeakVH_FollowsRAUW) {
 
88
  WeakVH WVH(BitcastV.get());
 
89
  WeakVH WVH_Copy(WVH);
 
90
  WeakVH WVH_Recreated(BitcastV.get());
 
91
  BitcastV->replaceAllUsesWith(ConstantV);
 
92
  EXPECT_EQ(ConstantV, WVH);
 
93
  EXPECT_EQ(ConstantV, WVH_Copy);
 
94
  EXPECT_EQ(ConstantV, WVH_Recreated);
 
95
}
 
96
 
 
97
TEST_F(ValueHandle, WeakVH_NullOnDeletion) {
 
98
  WeakVH WVH(BitcastV.get());
 
99
  WeakVH WVH_Copy(WVH);
 
100
  WeakVH WVH_Recreated(BitcastV.get());
 
101
  BitcastV.reset();
 
102
  Value *null_value = NULL;
 
103
  EXPECT_EQ(null_value, WVH);
 
104
  EXPECT_EQ(null_value, WVH_Copy);
 
105
  EXPECT_EQ(null_value, WVH_Recreated);
 
106
}
 
107
 
 
108
 
 
109
TEST_F(ValueHandle, AssertingVH_BasicOperation) {
 
110
  AssertingVH<CastInst> AVH(BitcastV.get());
 
111
  CastInst *implicit_to_exact_type = AVH;
 
112
  implicit_to_exact_type = implicit_to_exact_type;  // Avoid warning.
 
113
 
 
114
  AssertingVH<Value> GenericAVH(BitcastV.get());
 
115
  EXPECT_EQ(BitcastV.get(), GenericAVH);
 
116
  GenericAVH = ConstantV;
 
117
  EXPECT_EQ(ConstantV, GenericAVH);
 
118
 
 
119
  // Make sure I can call a method on the underlying CastInst.  It
 
120
  // doesn't matter which method.
 
121
  EXPECT_FALSE(AVH->mayWriteToMemory());
 
122
  EXPECT_FALSE((*AVH).mayWriteToMemory());
 
123
}
 
124
 
 
125
TEST_F(ValueHandle, AssertingVH_Const) {
 
126
  const CastInst *ConstBitcast = BitcastV.get();
 
127
  AssertingVH<const CastInst> AVH(ConstBitcast);
 
128
  const CastInst *implicit_to_exact_type = AVH;
 
129
  implicit_to_exact_type = implicit_to_exact_type;  // Avoid warning.
 
130
}
 
131
 
 
132
TEST_F(ValueHandle, AssertingVH_Comparisons) {
 
133
  AssertingVH<Value> BitcastAVH(BitcastV.get());
 
134
  AssertingVH<Value> ConstantAVH(ConstantV);
 
135
 
 
136
  EXPECT_TRUE(BitcastAVH == BitcastAVH);
 
137
  EXPECT_TRUE(BitcastV.get() == BitcastAVH);
 
138
  EXPECT_TRUE(BitcastAVH == BitcastV.get());
 
139
  EXPECT_FALSE(BitcastAVH == ConstantAVH);
 
140
 
 
141
  EXPECT_TRUE(BitcastAVH != ConstantAVH);
 
142
  EXPECT_TRUE(BitcastV.get() != ConstantAVH);
 
143
  EXPECT_TRUE(BitcastAVH != ConstantV);
 
144
  EXPECT_FALSE(BitcastAVH != BitcastAVH);
 
145
 
 
146
  // Cast to Value* so comparisons work.
 
147
  Value *BV = BitcastV.get();
 
148
  Value *CV = ConstantV;
 
149
  EXPECT_EQ(BV < CV, BitcastAVH < ConstantAVH);
 
150
  EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantAVH);
 
151
  EXPECT_EQ(BV > CV, BitcastAVH > ConstantAVH);
 
152
  EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantAVH);
 
153
 
 
154
  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantAVH);
 
155
  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantAVH);
 
156
  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantAVH);
 
157
  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantAVH);
 
158
 
 
159
  EXPECT_EQ(BV < CV, BitcastAVH < ConstantV);
 
160
  EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantV);
 
161
  EXPECT_EQ(BV > CV, BitcastAVH > ConstantV);
 
162
  EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantV);
 
163
}
 
164
 
 
165
TEST_F(ValueHandle, AssertingVH_DoesNotFollowRAUW) {
 
166
  AssertingVH<Value> AVH(BitcastV.get());
 
167
  BitcastV->replaceAllUsesWith(ConstantV);
 
168
  EXPECT_EQ(BitcastV.get(), AVH);
 
169
}
 
170
 
 
171
#ifdef NDEBUG
 
172
 
 
173
TEST_F(ValueHandle, AssertingVH_ReducesToPointer) {
 
174
  EXPECT_EQ(sizeof(CastInst *), sizeof(AssertingVH<CastInst>));
 
175
}
 
176
 
 
177
#else  // !NDEBUG
 
178
 
 
179
#ifdef GTEST_HAS_DEATH_TEST
 
180
 
 
181
TEST_F(ValueHandle, AssertingVH_Asserts) {
 
182
  AssertingVH<Value> AVH(BitcastV.get());
 
183
  EXPECT_DEATH({BitcastV.reset();},
 
184
               "An asserting value handle still pointed to this value!");
 
185
  AssertingVH<Value> Copy(AVH);
 
186
  AVH = NULL;
 
187
  EXPECT_DEATH({BitcastV.reset();},
 
188
               "An asserting value handle still pointed to this value!");
 
189
  Copy = NULL;
 
190
  BitcastV.reset();
 
191
}
 
192
 
 
193
#endif  // GTEST_HAS_DEATH_TEST
 
194
 
 
195
#endif  // NDEBUG
 
196
 
 
197
TEST_F(ValueHandle, CallbackVH_BasicOperation) {
 
198
  ConcreteCallbackVH CVH(BitcastV.get());
 
199
  EXPECT_EQ(BitcastV.get(), CVH);
 
200
  CVH = ConstantV;
 
201
  EXPECT_EQ(ConstantV, CVH);
 
202
 
 
203
  // Make sure I can call a method on the underlying Value.  It
 
204
  // doesn't matter which method.
 
205
  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), CVH->getType());
 
206
  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*CVH).getType());
 
207
}
 
208
 
 
209
TEST_F(ValueHandle, CallbackVH_Comparisons) {
 
210
  ConcreteCallbackVH BitcastCVH(BitcastV.get());
 
211
  ConcreteCallbackVH ConstantCVH(ConstantV);
 
212
 
 
213
  EXPECT_TRUE(BitcastCVH == BitcastCVH);
 
214
  EXPECT_TRUE(BitcastV.get() == BitcastCVH);
 
215
  EXPECT_TRUE(BitcastCVH == BitcastV.get());
 
216
  EXPECT_FALSE(BitcastCVH == ConstantCVH);
 
217
 
 
218
  EXPECT_TRUE(BitcastCVH != ConstantCVH);
 
219
  EXPECT_TRUE(BitcastV.get() != ConstantCVH);
 
220
  EXPECT_TRUE(BitcastCVH != ConstantV);
 
221
  EXPECT_FALSE(BitcastCVH != BitcastCVH);
 
222
 
 
223
  // Cast to Value* so comparisons work.
 
224
  Value *BV = BitcastV.get();
 
225
  Value *CV = ConstantV;
 
226
  EXPECT_EQ(BV < CV, BitcastCVH < ConstantCVH);
 
227
  EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantCVH);
 
228
  EXPECT_EQ(BV > CV, BitcastCVH > ConstantCVH);
 
229
  EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantCVH);
 
230
 
 
231
  EXPECT_EQ(BV < CV, BitcastV.get() < ConstantCVH);
 
232
  EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantCVH);
 
233
  EXPECT_EQ(BV > CV, BitcastV.get() > ConstantCVH);
 
234
  EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantCVH);
 
235
 
 
236
  EXPECT_EQ(BV < CV, BitcastCVH < ConstantV);
 
237
  EXPECT_EQ(BV <= CV, BitcastCVH <= ConstantV);
 
238
  EXPECT_EQ(BV > CV, BitcastCVH > ConstantV);
 
239
  EXPECT_EQ(BV >= CV, BitcastCVH >= ConstantV);
 
240
}
 
241
 
 
242
TEST_F(ValueHandle, CallbackVH_CallbackOnDeletion) {
 
243
  class RecordingVH : public CallbackVH {
 
244
  public:
 
245
    int DeletedCalls;
 
246
    int AURWCalls;
 
247
 
 
248
    RecordingVH() : DeletedCalls(0), AURWCalls(0) {}
 
249
    RecordingVH(Value *V) : CallbackVH(V), DeletedCalls(0), AURWCalls(0) {}
 
250
 
 
251
  private:
 
252
    virtual void deleted() { DeletedCalls++; CallbackVH::deleted(); }
 
253
    virtual void allUsesReplacedWith(Value *) { AURWCalls++; }
 
254
  };
 
255
 
 
256
  RecordingVH RVH;
 
257
  RVH = BitcastV.get();
 
258
  EXPECT_EQ(0, RVH.DeletedCalls);
 
259
  EXPECT_EQ(0, RVH.AURWCalls);
 
260
  BitcastV.reset();
 
261
  EXPECT_EQ(1, RVH.DeletedCalls);
 
262
  EXPECT_EQ(0, RVH.AURWCalls);
 
263
}
 
264
 
 
265
TEST_F(ValueHandle, CallbackVH_CallbackOnRAUW) {
 
266
  class RecordingVH : public CallbackVH {
 
267
  public:
 
268
    int DeletedCalls;
 
269
    Value *AURWArgument;
 
270
 
 
271
    RecordingVH() : DeletedCalls(0), AURWArgument(NULL) {}
 
272
    RecordingVH(Value *V)
 
273
      : CallbackVH(V), DeletedCalls(0), AURWArgument(NULL) {}
 
274
 
 
275
  private:
 
276
    virtual void deleted() { DeletedCalls++; CallbackVH::deleted(); }
 
277
    virtual void allUsesReplacedWith(Value *new_value) {
 
278
      EXPECT_EQ(NULL, AURWArgument);
 
279
      AURWArgument = new_value;
 
280
    }
 
281
  };
 
282
 
 
283
  RecordingVH RVH;
 
284
  RVH = BitcastV.get();
 
285
  EXPECT_EQ(0, RVH.DeletedCalls);
 
286
  EXPECT_EQ(NULL, RVH.AURWArgument);
 
287
  BitcastV->replaceAllUsesWith(ConstantV);
 
288
  EXPECT_EQ(0, RVH.DeletedCalls);
 
289
  EXPECT_EQ(ConstantV, RVH.AURWArgument);
 
290
}
 
291
 
 
292
TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) {
 
293
  class RecoveringVH : public CallbackVH {
 
294
  public:
 
295
    int DeletedCalls;
 
296
    Value *AURWArgument;
 
297
    LLVMContext *Context;
 
298
 
 
299
    RecoveringVH() : DeletedCalls(0), AURWArgument(NULL), 
 
300
                     Context(&getGlobalContext()) {}
 
301
    RecoveringVH(Value *V)
 
302
      : CallbackVH(V), DeletedCalls(0), AURWArgument(NULL), 
 
303
        Context(&getGlobalContext()) {}
 
304
 
 
305
  private:
 
306
    virtual void deleted() {
 
307
      getValPtr()->replaceAllUsesWith(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())));
 
308
      setValPtr(NULL);
 
309
    }
 
310
    virtual void allUsesReplacedWith(Value *new_value) {
 
311
      ASSERT_TRUE(NULL != getValPtr());
 
312
      EXPECT_EQ(1U, getValPtr()->getNumUses());
 
313
      EXPECT_EQ(NULL, AURWArgument);
 
314
      AURWArgument = new_value;
 
315
    }
 
316
  };
 
317
 
 
318
  // Normally, if a value has uses, deleting it will crash.  However, we can use
 
319
  // a CallbackVH to remove the uses before the check for no uses.
 
320
  RecoveringVH RVH;
 
321
  RVH = BitcastV.get();
 
322
  std::auto_ptr<BinaryOperator> BitcastUser(
 
323
    BinaryOperator::CreateAdd(RVH, 
 
324
                              Constant::getNullValue(Type::getInt32Ty(getGlobalContext()))));
 
325
  EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
 
326
  BitcastV.reset();  // Would crash without the ValueHandler.
 
327
  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())), RVH.AURWArgument);
 
328
  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())),
 
329
            BitcastUser->getOperand(0));
 
330
}
 
331
 
 
332
TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
 
333
  // When a CallbackVH modifies other ValueHandles in its callbacks,
 
334
  // that shouldn't interfere with non-modified ValueHandles receiving
 
335
  // their appropriate callbacks.
 
336
  //
 
337
  // We create the active CallbackVH in the middle of a palindromic
 
338
  // arrangement of other VHs so that the bad behavior would be
 
339
  // triggered in whichever order callbacks run.
 
340
 
 
341
  class DestroyingVH : public CallbackVH {
 
342
  public:
 
343
    OwningPtr<WeakVH> ToClear[2];
 
344
    DestroyingVH(Value *V) {
 
345
      ToClear[0].reset(new WeakVH(V));
 
346
      setValPtr(V);
 
347
      ToClear[1].reset(new WeakVH(V));
 
348
    }
 
349
    virtual void deleted() {
 
350
      ToClear[0].reset();
 
351
      ToClear[1].reset();
 
352
      CallbackVH::deleted();
 
353
    }
 
354
    virtual void allUsesReplacedWith(Value *) {
 
355
      ToClear[0].reset();
 
356
      ToClear[1].reset();
 
357
    }
 
358
  };
 
359
 
 
360
  {
 
361
    WeakVH ShouldBeVisited1(BitcastV.get());
 
362
    DestroyingVH C(BitcastV.get());
 
363
    WeakVH ShouldBeVisited2(BitcastV.get());
 
364
 
 
365
    BitcastV->replaceAllUsesWith(ConstantV);
 
366
    EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited1));
 
367
    EXPECT_EQ(ConstantV, static_cast<Value*>(ShouldBeVisited2));
 
368
  }
 
369
 
 
370
  {
 
371
    WeakVH ShouldBeVisited1(BitcastV.get());
 
372
    DestroyingVH C(BitcastV.get());
 
373
    WeakVH ShouldBeVisited2(BitcastV.get());
 
374
 
 
375
    BitcastV.reset();
 
376
    EXPECT_EQ(NULL, static_cast<Value*>(ShouldBeVisited1));
 
377
    EXPECT_EQ(NULL, static_cast<Value*>(ShouldBeVisited2));
 
378
  }
 
379
}
 
380
 
 
381
TEST_F(ValueHandle, AssertingVHCheckedLast) {
 
382
  // If a CallbackVH exists to clear out a group of AssertingVHs on
 
383
  // Value deletion, the CallbackVH should get a chance to do so
 
384
  // before the AssertingVHs assert.
 
385
 
 
386
  class ClearingVH : public CallbackVH {
 
387
  public:
 
388
    AssertingVH<Value> *ToClear[2];
 
389
    ClearingVH(Value *V,
 
390
               AssertingVH<Value> &A0, AssertingVH<Value> &A1)
 
391
      : CallbackVH(V) {
 
392
      ToClear[0] = &A0;
 
393
      ToClear[1] = &A1;
 
394
    }
 
395
 
 
396
    virtual void deleted() {
 
397
      *ToClear[0] = 0;
 
398
      *ToClear[1] = 0;
 
399
      CallbackVH::deleted();
 
400
    }
 
401
  };
 
402
 
 
403
  AssertingVH<Value> A1, A2;
 
404
  A1 = BitcastV.get();
 
405
  ClearingVH C(BitcastV.get(), A1, A2);
 
406
  A2 = BitcastV.get();
 
407
  // C.deleted() should run first, clearing the two AssertingVHs,
 
408
  // which should prevent them from asserting.
 
409
  BitcastV.reset();
 
410
}
 
411
 
 
412
}