| //===- SetOperations.cpp - Unit tests for set operations ------------------===// |
| // |
| // 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 "llvm/ADT/SetOperations.h" |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| |
| #include <set> |
| |
| using namespace llvm; |
| |
| using testing::IsEmpty; |
| |
| 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.clear(); |
| Set2 = {1, 2}; |
| // Set1 should be the union of input sets Set1 and Set2, which in this case |
| // will be Set2. |
| ExpectedSet1 = Set2; |
| // Set2 should not be touched. |
| ExpectedSet2 = Set2; |
| |
| set_union(Set1, Set2); |
| EXPECT_EQ(ExpectedSet1, Set1); |
| EXPECT_EQ(ExpectedSet2, Set2); |
| } |
| |
| 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 = {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); |
| } |
| |
| 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); |
| |
| 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 = {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 |
| // is empty as they are non-overlapping. Test this again with the input sets |
| // reversed, since the code takes a different path depending on which input |
| // set is smaller. |
| EXPECT_THAT(Result, IsEmpty()); |
| EXPECT_EQ(ExpectedSet1, Set1); |
| EXPECT_EQ(ExpectedSet2, Set2); |
| } |
| |
| 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_difference(Set1, Set2); |
| EXPECT_EQ(ExpectedResult, Result); |
| EXPECT_EQ(ExpectedSet1, Set1); |
| EXPECT_EQ(ExpectedSet2, Set2); |
| |
| Set1 = {1, 2, 3, 4}; |
| Set2 = {1, 2, 3, 4}; |
| // Set1 and Set2 should not be touched. |
| ExpectedSet1 = Set1; |
| ExpectedSet2 = Set2; |
| |
| Result = set_difference(Set1, Set2); |
| // Result should be Set1 - Set2, which should be empty. |
| EXPECT_THAT(Result, IsEmpty()); |
| EXPECT_EQ(ExpectedSet1, Set1); |
| EXPECT_EQ(ExpectedSet2, Set2); |
| |
| Set1 = {1, 2, 3, 4}; |
| Set2 = {5, 6}; |
| // Result should be Set1 - Set2, which should be Set1 as they are |
| // non-overlapping. |
| ExpectedResult = Set1; |
| // Set1 and Set2 should not be touched. |
| ExpectedSet1 = Set1; |
| ExpectedSet2 = Set2; |
| |
| Result = set_difference(Set1, Set2); |
| EXPECT_EQ(ExpectedResult, Result); |
| EXPECT_EQ(ExpectedSet1, Set1); |
| EXPECT_EQ(ExpectedSet2, Set2); |
| } |
| |
| 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 = {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); |
| |
| Set1 = {1, 2, 3, 4}; |
| Set2 = {5, 6}; |
| // Set1 should get Set1 - Set2, which should be Set1 as they are |
| // non-overlapping. |
| ExpectedSet1 = Set1; |
| // Set2 should not be touched. |
| ExpectedSet2 = Set2; |
| |
| set_subtract(Set1, Set2); |
| EXPECT_EQ(ExpectedSet1, Set1); |
| EXPECT_EQ(ExpectedSet2, Set2); |
| } |
| |
| TEST(SetOperationsTest, SetSubtractRemovedRemaining) { |
| std::set<int> Removed, Remaining; |
| |
| 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; |
| // 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); |
| |
| 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); |
| EXPECT_THAT(Remaining, IsEmpty()); |
| |
| Set1 = {1, 2, 3, 4}; |
| Set2 = {5, 6}; |
| Removed.clear(); |
| Remaining.clear(); |
| // Set1 should get Set1 - Set2, which should be Set1 as they are |
| // non-overlapping. |
| ExpectedSet1 = {1, 2, 3, 4}; |
| // Set2 should not be touched. |
| ExpectedSet2 = Set2; |
| // 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); |
| } |
| |
| TEST(SetOperationsTest, SetIsSubset) { |
| std::set<int> Set1 = {1, 2, 3, 4}; |
| std::set<int> Set2 = {3, 4}; |
| EXPECT_FALSE(set_is_subset(Set1, Set2)); |
| |
| Set1 = {1, 2, 3, 4}; |
| Set2 = {1, 2, 3, 4}; |
| EXPECT_TRUE(set_is_subset(Set1, Set2)); |
| |
| Set1 = {1, 2}; |
| Set2 = {1, 2, 3, 4}; |
| EXPECT_TRUE(set_is_subset(Set1, Set2)); |
| |
| Set1 = {1, 2}; |
| Set2 = {3, 4}; |
| EXPECT_FALSE(set_is_subset(Set1, Set2)); |
| } |
| |
| } // namespace |