[llvm] 687fc08 - [ADT] Use UnorderedElementsAre in SetOperationsTest.cpp (NFC) (#99596)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 18 21:29:51 PDT 2024
Author: Kazu Hirata
Date: 2024-07-18T21:29:47-07:00
New Revision: 687fc08e7c7755f68838040edb00d4f64e0bebe7
URL: https://github.com/llvm/llvm-project/commit/687fc08e7c7755f68838040edb00d4f64e0bebe7
DIFF: https://github.com/llvm/llvm-project/commit/687fc08e7c7755f68838040edb00d4f64e0bebe7.diff
LOG: [ADT] Use UnorderedElementsAre in SetOperationsTest.cpp (NFC) (#99596)
Added:
Modified:
llvm/unittests/ADT/SetOperationsTest.cpp
Removed:
################################################################################
diff --git a/llvm/unittests/ADT/SetOperationsTest.cpp b/llvm/unittests/ADT/SetOperationsTest.cpp
index da84c8afbd2ba..f99f5c9b2af10 100644
--- a/llvm/unittests/ADT/SetOperationsTest.cpp
+++ b/llvm/unittests/ADT/SetOperationsTest.cpp
@@ -25,50 +25,43 @@ namespace {
TEST(SetOperationsTest, SetUnion) {
std::set<int> Set1 = {1, 2, 3, 4};
std::set<int> Set2 = {5, 6, 7, 8};
- // Set1 should be the union of input sets Set1 and Set2.
- std::set<int> ExpectedSet1 = {1, 2, 3, 4, 5, 6, 7, 8};
- // Set2 should not be touched.
- std::set<int> ExpectedSet2 = Set2;
set_union(Set1, Set2);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set1 should be the union of input sets Set1 and Set2.
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4, 5, 6, 7, 8));
+ // Set2 should not be touched.
+ EXPECT_THAT(Set2, UnorderedElementsAre(5, 6, 7, 8));
Set1.clear();
Set2 = {1, 2};
+
+ set_union(Set1, Set2);
// Set1 should be the union of input sets Set1 and Set2, which in this case
// will be Set2.
- ExpectedSet1 = Set2;
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2));
// Set2 should not be touched.
- ExpectedSet2 = Set2;
-
- set_union(Set1, Set2);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ EXPECT_THAT(Set2, UnorderedElementsAre(1, 2));
}
TEST(SetOperationsTest, SetIntersect) {
std::set<int> Set1 = {1, 2, 3, 4};
std::set<int> Set2 = {3, 4, 5, 6};
- // Set1 should be the intersection of sets Set1 and Set2.
- std::set<int> ExpectedSet1 = {3, 4};
- // Set2 should not be touched.
- std::set<int> ExpectedSet2 = Set2;
set_intersect(Set1, Set2);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set1 should be the intersection of sets Set1 and Set2.
+ EXPECT_THAT(Set1, UnorderedElementsAre(3, 4));
+ // Set2 should not be touched.
+ EXPECT_THAT(Set2, UnorderedElementsAre(3, 4, 5, 6));
Set1 = {1, 2, 3, 4};
Set2 = {5, 6};
- // Set2 should not be touched.
- ExpectedSet2 = Set2;
set_intersect(Set1, Set2);
// Set1 should be the intersection of sets Set1 and Set2, which
// is empty as they are non-overlapping.
EXPECT_THAT(Set1, IsEmpty());
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set2 should not be touched.
+ EXPECT_THAT(Set2, UnorderedElementsAre(5, 6));
// Check that set_intersect works on SetVector via remove_if.
SmallSetVector<int, 4> SV;
@@ -85,35 +78,27 @@ TEST(SetOperationsTest, SetIntersection) {
std::set<int> Set1 = {1, 2, 3, 4};
std::set<int> Set2 = {3, 4, 5, 6};
std::set<int> Result;
- // Result should be the intersection of sets Set1 and Set2.
- std::set<int> ExpectedResult = {3, 4};
- // Set1 and Set2 should not be touched.
- std::set<int> ExpectedSet1 = Set1;
- std::set<int> ExpectedSet2 = Set2;
Result = set_intersection(Set1, Set2);
- EXPECT_EQ(ExpectedResult, Result);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Result should be the intersection of sets Set1 and Set2.
+ EXPECT_THAT(Result, UnorderedElementsAre(3, 4));
+ // Set1 and Set2 should not be touched.
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4));
+ EXPECT_THAT(Set2, UnorderedElementsAre(3, 4, 5, 6));
Set1 = {1, 2, 3, 4};
Set2 = {5, 6};
- // Set1 and Set2 should not be touched.
- ExpectedSet1 = Set1;
- ExpectedSet2 = Set2;
Result = set_intersection(Set1, Set2);
// Result should be the intersection of sets Set1 and Set2, which
// is empty as they are non-overlapping.
EXPECT_THAT(Result, IsEmpty());
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set1 and Set2 should not be touched.
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4));
+ EXPECT_THAT(Set2, UnorderedElementsAre(5, 6));
Set1 = {5, 6};
Set2 = {1, 2, 3, 4};
- // Set1 and Set2 should not be touched.
- ExpectedSet1 = Set1;
- ExpectedSet2 = Set2;
Result = set_intersection(Set1, Set2);
// Result should be the intersection of sets Set1 and Set2, which
@@ -121,85 +106,73 @@ TEST(SetOperationsTest, SetIntersection) {
// reversed, since the code takes a
diff erent path depending on which input
// set is smaller.
EXPECT_THAT(Result, IsEmpty());
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set1 and Set2 should not be touched.
+ EXPECT_THAT(Set1, UnorderedElementsAre(5, 6));
+ EXPECT_THAT(Set2, UnorderedElementsAre(1, 2, 3, 4));
}
TEST(SetOperationsTest, SetDifference) {
std::set<int> Set1 = {1, 2, 3, 4};
std::set<int> Set2 = {3, 4, 5, 6};
std::set<int> Result;
- // Result should be Set1 - Set2, leaving only {1, 2}.
- std::set<int> ExpectedResult = {1, 2};
- // Set1 and Set2 should not be touched.
- std::set<int> ExpectedSet1 = Set1;
- std::set<int> ExpectedSet2 = Set2;
Result = set_
diff erence(Set1, Set2);
- EXPECT_EQ(ExpectedResult, Result);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Result should be Set1 - Set2, leaving only {1, 2}.
+ EXPECT_THAT(Result, UnorderedElementsAre(1, 2));
+ // Set1 and Set2 should not be touched.
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4));
+ EXPECT_THAT(Set2, UnorderedElementsAre(3, 4, 5, 6));
Set1 = {1, 2, 3, 4};
Set2 = {1, 2, 3, 4};
- // Set1 and Set2 should not be touched.
- ExpectedSet1 = Set1;
- ExpectedSet2 = Set2;
Result = set_
diff erence(Set1, Set2);
// Result should be Set1 - Set2, which should be empty.
EXPECT_THAT(Result, IsEmpty());
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set1 and Set2 should not be touched.
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4));
+ EXPECT_THAT(Set2, UnorderedElementsAre(1, 2, 3, 4));
Set1 = {1, 2, 3, 4};
Set2 = {5, 6};
+
+ Result = set_
diff erence(Set1, Set2);
// Result should be Set1 - Set2, which should be Set1 as they are
// non-overlapping.
- ExpectedResult = Set1;
+ EXPECT_THAT(Result, UnorderedElementsAre(1, 2, 3, 4));
// Set1 and Set2 should not be touched.
- ExpectedSet1 = Set1;
- ExpectedSet2 = Set2;
-
- Result = set_
diff erence(Set1, Set2);
- EXPECT_EQ(ExpectedResult, Result);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4));
+ EXPECT_THAT(Set2, UnorderedElementsAre(5, 6));
}
TEST(SetOperationsTest, SetSubtract) {
std::set<int> Set1 = {1, 2, 3, 4};
std::set<int> Set2 = {3, 4, 5, 6};
- // Set1 should get Set1 - Set2, leaving only {1, 2}.
- std::set<int> ExpectedSet1 = {1, 2};
- // Set2 should not be touched.
- std::set<int> ExpectedSet2 = Set2;
set_subtract(Set1, Set2);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set1 should get Set1 - Set2, leaving only {1, 2}.
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2));
+ // Set2 should not be touched.
+ EXPECT_THAT(Set2, UnorderedElementsAre(3, 4, 5, 6));
Set1 = {1, 2, 3, 4};
Set2 = {1, 2, 3, 4};
- // Set2 should not be touched.
- ExpectedSet2 = Set2;
set_subtract(Set1, Set2);
// Set1 should get Set1 - Set2, which should be empty.
EXPECT_THAT(Set1, IsEmpty());
- EXPECT_EQ(ExpectedSet2, Set2);
+ // Set2 should not be touched.
+ EXPECT_THAT(Set2, UnorderedElementsAre(1, 2, 3, 4));
Set1 = {1, 2, 3, 4};
Set2 = {5, 6};
+
+ set_subtract(Set1, Set2);
// Set1 should get Set1 - Set2, which should be Set1 as they are
// non-overlapping.
- ExpectedSet1 = Set1;
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4));
// Set2 should not be touched.
- ExpectedSet2 = Set2;
-
- set_subtract(Set1, Set2);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
+ EXPECT_THAT(Set2, UnorderedElementsAre(5, 6));
}
TEST(SetOperationsTest, SetSubtractSmallPtrSet) {
@@ -239,56 +212,47 @@ TEST(SetOperationsTest, SetSubtractRemovedRemaining) {
std::set<int> Set1 = {1, 2, 3, 4};
std::set<int> Set2 = {3, 4, 5, 6};
+
+ set_subtract(Set1, Set2, Removed, Remaining);
// Set1 should get Set1 - Set2, leaving only {1, 2}.
- std::set<int> ExpectedSet1 = {1, 2};
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2));
// Set2 should not be touched.
- std::set<int> ExpectedSet2 = Set2;
+ EXPECT_THAT(Set2, UnorderedElementsAre(3, 4, 5, 6));
// We should get back that {3, 4} from Set2 were removed from Set1, and {5, 6}
// were not removed from Set1.
- std::set<int> ExpectedRemoved = {3, 4};
- std::set<int> ExpectedRemaining = {5, 6};
-
- set_subtract(Set1, Set2, Removed, Remaining);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
- EXPECT_EQ(ExpectedRemoved, Removed);
- EXPECT_EQ(ExpectedRemaining, Remaining);
+ EXPECT_THAT(Removed, UnorderedElementsAre(3, 4));
+ EXPECT_THAT(Remaining, UnorderedElementsAre(5, 6));
Set1 = {1, 2, 3, 4};
Set2 = {1, 2, 3, 4};
Removed.clear();
Remaining.clear();
- // Set2 should not be touched.
- ExpectedSet2 = Set2;
- // Set should get back that all of Set2 was removed from Set1, and nothing
- // left in Set2 was not removed from Set1.
- ExpectedRemoved = Set2;
set_subtract(Set1, Set2, Removed, Remaining);
// Set1 should get Set1 - Set2, which should be empty.
EXPECT_THAT(Set1, IsEmpty());
- EXPECT_EQ(ExpectedSet2, Set2);
- EXPECT_EQ(ExpectedRemoved, Removed);
+ // Set2 should not be touched.
+ EXPECT_THAT(Set2, UnorderedElementsAre(1, 2, 3, 4));
+ // Set should get back that all of Set2 was removed from Set1, and nothing
+ // left in Set2 was not removed from Set1.
+ EXPECT_THAT(Removed, UnorderedElementsAre(1, 2, 3, 4));
EXPECT_THAT(Remaining, IsEmpty());
Set1 = {1, 2, 3, 4};
Set2 = {5, 6};
Removed.clear();
Remaining.clear();
+
+ set_subtract(Set1, Set2, Removed, Remaining);
// Set1 should get Set1 - Set2, which should be Set1 as they are
// non-overlapping.
- ExpectedSet1 = {1, 2, 3, 4};
+ EXPECT_THAT(Set1, UnorderedElementsAre(1, 2, 3, 4));
// Set2 should not be touched.
- ExpectedSet2 = Set2;
+ EXPECT_THAT(Set2, UnorderedElementsAre(5, 6));
+ EXPECT_THAT(Removed, IsEmpty());
// Set should get back that none of Set2 was removed from Set1, and all
// of Set2 was not removed from Set1.
- ExpectedRemaining = Set2;
-
- set_subtract(Set1, Set2, Removed, Remaining);
- EXPECT_EQ(ExpectedSet1, Set1);
- EXPECT_EQ(ExpectedSet2, Set2);
- EXPECT_THAT(Removed, IsEmpty());
- EXPECT_EQ(ExpectedRemaining, Remaining);
+ EXPECT_THAT(Remaining, UnorderedElementsAre(5, 6));
}
TEST(SetOperationsTest, SetIsSubset) {
More information about the llvm-commits
mailing list