blob: 6db6783bb89f935b96868262417dfea71185046b (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
//===- StorageUniquerTest.cpp - StorageUniquer Tests ----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "mlir/Support/StorageUniquer.h"
#include "gmock/gmock.h"
using namespace mlir;
namespace {
/// Simple storage class used for testing.
template <typename ConcreteT, typename... Args>
struct SimpleStorage : public StorageUniquer::BaseStorage {
using Base = SimpleStorage<ConcreteT, Args...>;
using KeyTy = std::tuple<Args...>;
SimpleStorage(KeyTy key) : key(key) {}
/// Get an instance of this storage instance.
template <typename... ParamsT>
static ConcreteT *get(StorageUniquer &uniquer, ParamsT &&...params) {
return uniquer.get<ConcreteT>(
/*initFn=*/{}, std::make_tuple(std::forward<ParamsT>(params)...));
}
/// Construct an instance with the given storage allocator.
static ConcreteT *construct(StorageUniquer::StorageAllocator &alloc,
KeyTy key) {
return new (alloc.allocate<ConcreteT>())
ConcreteT(std::forward<KeyTy>(key));
}
bool operator==(const KeyTy &key) const { return this->key == key; }
KeyTy key;
};
} // namespace
TEST(StorageUniquerTest, NonTrivialDestructor) {
struct NonTrivialStorage : public SimpleStorage<NonTrivialStorage, bool *> {
using Base::Base;
~NonTrivialStorage() {
bool *wasDestructed = std::get<0>(key);
*wasDestructed = true;
}
};
// Verify that the storage instance destructor was properly called.
bool wasDestructed = false;
{
StorageUniquer uniquer;
uniquer.registerParametricStorageType<NonTrivialStorage>();
NonTrivialStorage::get(uniquer, &wasDestructed);
}
EXPECT_TRUE(wasDestructed);
}
|
