Skip to content

Commit 6871657

Browse files
c8efc8ef
authored
[ADT] refactor MoveOnly type in ADT unittest (#94421)
context: #94151 (review)
1 parent c0bb16e commit 6871657

File tree

7 files changed

+123
-126
lines changed

7 files changed

+123
-126
lines changed

‎llvm/unittests/ADT/CMakeLists.txt

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ add_llvm_unittest(ADTTests
1818
CoalescingBitVectorTest.cpp
1919
CombinationGeneratorTest.cpp
2020
ConcurrentHashtableTest.cpp
21+
CountCopyAndMove.cpp
2122
DAGDeltaAlgorithmTest.cpp
2223
DeltaAlgorithmTest.cpp
2324
DenseMapTest.cpp
@@ -52,7 +53,6 @@ add_llvm_unittest(ADTTests
5253
LazyAtomicPointerTest.cpp
5354
MappedIteratorTest.cpp
5455
MapVectorTest.cpp
55-
MoveOnly.cpp
5656
PackedVectorTest.cpp
5757
PagedVectorTest.cpp
5858
PointerEmbeddedIntTest.cpp

‎llvm/unittests/ADT/CountCopyAndMove.cpp

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
//===- llvm/unittest/ADT/CountCopyAndMove.cpp - Optional unit tests -------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
#include "CountCopyAndMove.h"
10+
11+
using namespace llvm;
12+
13+
int CountCopyAndMove::CopyConstructions = 0;
14+
int CountCopyAndMove::CopyAssignments = 0;
15+
int CountCopyAndMove::MoveConstructions = 0;
16+
int CountCopyAndMove::MoveAssignments = 0;
17+
int CountCopyAndMove::Destructions = 0;

‎llvm/unittests/ADT/CountCopyAndMove.h

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
//===- llvm/unittest/ADT/CountCopyAndMove.h - Optional unit tests ---------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
#ifndef LLVM_UNITTESTS_ADT_COUNTCOPYANDMOVE_H
10+
#define LLVM_UNITTESTS_ADT_COUNTCOPYANDMOVE_H
11+
12+
namespace llvm {
13+
14+
struct CountCopyAndMove {
15+
static int CopyConstructions;
16+
static int CopyAssignments;
17+
static int MoveConstructions;
18+
static int MoveAssignments;
19+
static int Destructions;
20+
int val;
21+
22+
CountCopyAndMove() = default;
23+
explicit CountCopyAndMove(int val) : val(val) {}
24+
CountCopyAndMove(const CountCopyAndMove &other) : val(other.val) {
25+
++CopyConstructions;
26+
}
27+
CountCopyAndMove &operator=(const CountCopyAndMove &other) {
28+
val = other.val;
29+
++CopyAssignments;
30+
return *this;
31+
}
32+
CountCopyAndMove(CountCopyAndMove &&other) : val(other.val) {
33+
++MoveConstructions;
34+
}
35+
CountCopyAndMove &operator=(CountCopyAndMove &&other) {
36+
val = other.val;
37+
++MoveAssignments;
38+
return *this;
39+
}
40+
~CountCopyAndMove() { ++Destructions; }
41+
42+
static void ResetCounts() {
43+
CopyConstructions = 0;
44+
CopyAssignments = 0;
45+
MoveConstructions = 0;
46+
MoveAssignments = 0;
47+
Destructions = 0;
48+
}
49+
50+
static int TotalCopies() { return CopyConstructions + CopyAssignments; }
51+
52+
static int TotalMoves() { return MoveConstructions + MoveAssignments; }
53+
};
54+
55+
} // end namespace llvm
56+
57+
#endif // LLVM_UNITTESTS_ADT_COUNTCOPYANDMOVE_H

‎llvm/unittests/ADT/DenseMapTest.cpp

Lines changed: 17 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "llvm/ADT/DenseMap.h"
10+
#include "CountCopyAndMove.h"
1011
#include "llvm/ADT/DenseMapInfo.h"
1112
#include "llvm/ADT/DenseMapInfoVariant.h"
1213
#include "llvm/ADT/StringRef.h"
@@ -346,29 +347,6 @@ TYPED_TEST(DenseMapTest, ConstIteratorTest) {
346347
EXPECT_TRUE(cit == cit2);
347348
}
348349

349-
namespace {
350-
// Simple class that counts how many moves and copy happens when growing a map
351-
struct CountCopyAndMove {
352-
static int Move;
353-
static int Copy;
354-
CountCopyAndMove() {}
355-
356-
CountCopyAndMove(const CountCopyAndMove &) { Copy++; }
357-
CountCopyAndMove &operator=(const CountCopyAndMove &) {
358-
Copy++;
359-
return *this;
360-
}
361-
CountCopyAndMove(CountCopyAndMove &&) { Move++; }
362-
CountCopyAndMove &operator=(const CountCopyAndMove &&) {
363-
Move++;
364-
return *this;
365-
}
366-
};
367-
int CountCopyAndMove::Copy = 0;
368-
int CountCopyAndMove::Move = 0;
369-
370-
} // anonymous namespace
371-
372350
// Test initializer list construction.
373351
TEST(DenseMapCustomTest, InitializerList) {
374352
DenseMap<int, int> M({{0, 0}, {0, 1}, {1, 2}});
@@ -401,18 +379,18 @@ TEST(DenseMapCustomTest, DefaultMinReservedSizeTest) {
401379
// Will allocate 64 buckets
402380
Map.reserve(1);
403381
unsigned MemorySize = Map.getMemorySize();
404-
CountCopyAndMove::Copy = 0;
405-
CountCopyAndMove::Move = 0;
382+
CountCopyAndMove::ResetCounts();
383+
406384
for (int i = 0; i < ExpectedMaxInitialEntries; ++i)
407385
Map.insert(std::pair<int, CountCopyAndMove>(std::piecewise_construct,
408386
std::forward_as_tuple(i),
409387
std::forward_as_tuple()));
410388
// Check that we didn't grow
411389
EXPECT_EQ(MemorySize, Map.getMemorySize());
412390
// Check that move was called the expected number of times
413-
EXPECT_EQ(ExpectedMaxInitialEntries, CountCopyAndMove::Move);
391+
EXPECT_EQ(ExpectedMaxInitialEntries, CountCopyAndMove::TotalMoves());
414392
// Check that no copy occurred
415-
EXPECT_EQ(0, CountCopyAndMove::Copy);
393+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
416394

417395
// Adding one extra element should grow the map
418396
Map.insert(std::pair<int, CountCopyAndMove>(
@@ -425,7 +403,7 @@ TEST(DenseMapCustomTest, DefaultMinReservedSizeTest) {
425403
// This relies on move-construction elision, and cannot be reliably tested.
426404
// EXPECT_EQ(ExpectedMaxInitialEntries + 2, CountCopyAndMove::Move);
427405
// Check that no copy occurred
428-
EXPECT_EQ(0, CountCopyAndMove::Copy);
406+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
429407
}
430408

431409
// Make sure creating the map with an initial size of N actually gives us enough
@@ -439,18 +417,18 @@ TEST(DenseMapCustomTest, InitialSizeTest) {
439417
for (auto Size : {1, 2, 48, 66}) {
440418
DenseMap<int, CountCopyAndMove> Map(Size);
441419
unsigned MemorySize = Map.getMemorySize();
442-
CountCopyAndMove::Copy = 0;
443-
CountCopyAndMove::Move = 0;
420+
CountCopyAndMove::ResetCounts();
421+
444422
for (int i = 0; i < Size; ++i)
445423
Map.insert(std::pair<int, CountCopyAndMove>(std::piecewise_construct,
446424
std::forward_as_tuple(i),
447425
std::forward_as_tuple()));
448426
// Check that we didn't grow
449427
EXPECT_EQ(MemorySize, Map.getMemorySize());
450428
// Check that move was called the expected number of times
451-
EXPECT_EQ(Size, CountCopyAndMove::Move);
429+
EXPECT_EQ(Size, CountCopyAndMove::TotalMoves());
452430
// Check that no copy occurred
453-
EXPECT_EQ(0, CountCopyAndMove::Copy);
431+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
454432
}
455433
}
456434

@@ -461,15 +439,14 @@ TEST(DenseMapCustomTest, InitFromIterator) {
461439
const int Count = 65;
462440
Values.reserve(Count);
463441
for (int i = 0; i < Count; i++)
464-
Values.emplace_back(i, CountCopyAndMove());
442+
Values.emplace_back(i, CountCopyAndMove(i));
465443

466-
CountCopyAndMove::Move = 0;
467-
CountCopyAndMove::Copy = 0;
444+
CountCopyAndMove::ResetCounts();
468445
DenseMap<int, CountCopyAndMove> Map(Values.begin(), Values.end());
469446
// Check that no move occurred
470-
EXPECT_EQ(0, CountCopyAndMove::Move);
447+
EXPECT_EQ(0, CountCopyAndMove::TotalMoves());
471448
// Check that copy was called the expected number of times
472-
EXPECT_EQ(Count, CountCopyAndMove::Copy);
449+
EXPECT_EQ(Count, CountCopyAndMove::TotalCopies());
473450
}
474451

475452
// Make sure reserve actually gives us enough buckets to insert N items
@@ -484,18 +461,17 @@ TEST(DenseMapCustomTest, ReserveTest) {
484461
DenseMap<int, CountCopyAndMove> Map;
485462
Map.reserve(Size);
486463
unsigned MemorySize = Map.getMemorySize();
487-
CountCopyAndMove::Copy = 0;
488-
CountCopyAndMove::Move = 0;
464+
CountCopyAndMove::ResetCounts();
489465
for (int i = 0; i < Size; ++i)
490466
Map.insert(std::pair<int, CountCopyAndMove>(std::piecewise_construct,
491467
std::forward_as_tuple(i),
492468
std::forward_as_tuple()));
493469
// Check that we didn't grow
494470
EXPECT_EQ(MemorySize, Map.getMemorySize());
495471
// Check that move was called the expected number of times
496-
EXPECT_EQ(Size, CountCopyAndMove::Move);
472+
EXPECT_EQ(Size, CountCopyAndMove::TotalMoves());
497473
// Check that no copy occurred
498-
EXPECT_EQ(0, CountCopyAndMove::Copy);
474+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
499475
}
500476
}
501477

‎llvm/unittests/ADT/MoveOnly.cpp

Lines changed: 0 additions & 15 deletions
This file was deleted.

‎llvm/unittests/ADT/MoveOnly.h

Lines changed: 0 additions & 42 deletions
This file was deleted.

‎llvm/unittests/ADT/STLForwardCompatTest.cpp

Lines changed: 31 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "llvm/ADT/STLForwardCompat.h"
10-
#include "MoveOnly.h"
10+
#include "CountCopyAndMove.h"
1111
#include "gtest/gtest.h"
1212

1313
namespace {
@@ -58,27 +58,29 @@ TEST(TransformTest, TransformStd) {
5858
}
5959

6060
TEST(TransformTest, MoveTransformStd) {
61-
using llvm::MoveOnly;
61+
using llvm::CountCopyAndMove;
6262

63-
std::optional<MoveOnly> A;
63+
std::optional<CountCopyAndMove> A;
6464

65-
MoveOnly::ResetCounts();
65+
CountCopyAndMove::ResetCounts();
6666
std::optional<int> B = llvm::transformOptional(
67-
std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
67+
std::move(A), [&](const CountCopyAndMove &M) { return M.val + 2; });
6868
EXPECT_FALSE(B.has_value());
69-
EXPECT_EQ(0u, MoveOnly::MoveConstructions);
70-
EXPECT_EQ(0u, MoveOnly::MoveAssignments);
71-
EXPECT_EQ(0u, MoveOnly::Destructions);
69+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
70+
EXPECT_EQ(0, CountCopyAndMove::MoveConstructions);
71+
EXPECT_EQ(0, CountCopyAndMove::MoveAssignments);
72+
EXPECT_EQ(0, CountCopyAndMove::Destructions);
7273

73-
A = MoveOnly(5);
74-
MoveOnly::ResetCounts();
74+
A = CountCopyAndMove(5);
75+
CountCopyAndMove::ResetCounts();
7576
std::optional<int> C = llvm::transformOptional(
76-
std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
77+
std::move(A), [&](const CountCopyAndMove &M) { return M.val + 2; });
7778
EXPECT_TRUE(C.has_value());
7879
EXPECT_EQ(7, *C);
79-
EXPECT_EQ(0u, MoveOnly::MoveConstructions);
80-
EXPECT_EQ(0u, MoveOnly::MoveAssignments);
81-
EXPECT_EQ(0u, MoveOnly::Destructions);
80+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
81+
EXPECT_EQ(0, CountCopyAndMove::MoveConstructions);
82+
EXPECT_EQ(0, CountCopyAndMove::MoveAssignments);
83+
EXPECT_EQ(0, CountCopyAndMove::Destructions);
8284
}
8385

8486
TEST(TransformTest, TransformLlvm) {
@@ -96,27 +98,29 @@ TEST(TransformTest, TransformLlvm) {
9698
}
9799

98100
TEST(TransformTest, MoveTransformLlvm) {
99-
using llvm::MoveOnly;
101+
using llvm::CountCopyAndMove;
100102

101-
std::optional<MoveOnly> A;
103+
std::optional<CountCopyAndMove> A;
102104

103-
MoveOnly::ResetCounts();
105+
CountCopyAndMove::ResetCounts();
104106
std::optional<int> B = llvm::transformOptional(
105-
std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
107+
std::move(A), [&](const CountCopyAndMove &M) { return M.val + 2; });
106108
EXPECT_FALSE(B.has_value());
107-
EXPECT_EQ(0u, MoveOnly::MoveConstructions);
108-
EXPECT_EQ(0u, MoveOnly::MoveAssignments);
109-
EXPECT_EQ(0u, MoveOnly::Destructions);
109+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
110+
EXPECT_EQ(0, CountCopyAndMove::MoveConstructions);
111+
EXPECT_EQ(0, CountCopyAndMove::MoveAssignments);
112+
EXPECT_EQ(0, CountCopyAndMove::Destructions);
110113

111-
A = MoveOnly(5);
112-
MoveOnly::ResetCounts();
114+
A = CountCopyAndMove(5);
115+
CountCopyAndMove::ResetCounts();
113116
std::optional<int> C = llvm::transformOptional(
114-
std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
117+
std::move(A), [&](const CountCopyAndMove &M) { return M.val + 2; });
115118
EXPECT_TRUE(C.has_value());
116119
EXPECT_EQ(7, *C);
117-
EXPECT_EQ(0u, MoveOnly::MoveConstructions);
118-
EXPECT_EQ(0u, MoveOnly::MoveAssignments);
119-
EXPECT_EQ(0u, MoveOnly::Destructions);
120+
EXPECT_EQ(0, CountCopyAndMove::TotalCopies());
121+
EXPECT_EQ(0, CountCopyAndMove::MoveConstructions);
122+
EXPECT_EQ(0, CountCopyAndMove::MoveAssignments);
123+
EXPECT_EQ(0, CountCopyAndMove::Destructions);
120124
}
121125

122126
TEST(TransformTest, ToUnderlying) {

0 commit comments

Comments
 (0)