1 //===- llvm/unittest/ADT/CombinationGeneratorTest.cpp ---------------------===// 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 "llvm/ADT/CombinationGenerator.h" 10 #include "llvm/ADT/ArrayRef.h" 11 #include "llvm/ADT/STLExtras.h" 12 #include "llvm/ADT/STLForwardCompat.h" 13 #include "llvm/ADT/iterator_range.h" 14 #include "llvm/Support/ErrorHandling.h" 15 #include "gmock/gmock.h" 16 #include "gtest/gtest.h" 17 #include <algorithm> 18 #include <cstddef> 19 #include <iterator> 20 #include <tuple> 21 #include <vector> 22 23 using namespace llvm; 24 25 namespace { 26 27 TEST(CombinationGenerator, Square) { 28 const std::vector<std::vector<int>> Choices{{0, 1}, {2, 3}}; 29 30 std::vector<std::vector<int>> Variants; 31 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 32 const size_t NumVariants = G.numCombinations(); 33 G.generate([&](ArrayRef<int> State) -> bool { 34 Variants.emplace_back(State); 35 return false; // keep going 36 }); 37 38 const std::vector<std::vector<int>> ExpectedVariants{ 39 {0, 2}, 40 {0, 3}, 41 {1, 2}, 42 {1, 3}, 43 }; 44 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 45 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 46 } 47 48 TEST(CombinationGenerator, MiddleColumn) { 49 const std::vector<std::vector<int>> Choices{{0}, {1, 2}, {3}}; 50 51 std::vector<std::vector<int>> Variants; 52 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 53 const size_t NumVariants = G.numCombinations(); 54 G.generate([&](ArrayRef<int> State) -> bool { 55 Variants.emplace_back(State); 56 return false; // keep going 57 }); 58 59 const std::vector<std::vector<int>> ExpectedVariants{ 60 {0, 1, 3}, 61 {0, 2, 3}, 62 }; 63 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 64 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 65 } 66 67 TEST(CombinationGenerator, SideColumns) { 68 const std::vector<std::vector<int>> Choices{{0, 1}, {2}, {3, 4}}; 69 70 std::vector<std::vector<int>> Variants; 71 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 72 const size_t NumVariants = G.numCombinations(); 73 G.generate([&](ArrayRef<int> State) -> bool { 74 Variants.emplace_back(State); 75 return false; // keep going 76 }); 77 78 const std::vector<std::vector<int>> ExpectedVariants{ 79 {0, 2, 3}, 80 {0, 2, 4}, 81 {1, 2, 3}, 82 {1, 2, 4}, 83 }; 84 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 85 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 86 } 87 88 TEST(CombinationGenerator, LeftColumn) { 89 const std::vector<std::vector<int>> Choices{{0, 1}, {2}}; 90 91 std::vector<std::vector<int>> Variants; 92 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 93 const size_t NumVariants = G.numCombinations(); 94 G.generate([&](ArrayRef<int> State) -> bool { 95 Variants.emplace_back(State); 96 return false; // keep going 97 }); 98 99 const std::vector<std::vector<int>> ExpectedVariants{ 100 {0, 2}, 101 {1, 2}, 102 }; 103 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 104 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 105 } 106 107 TEST(CombinationGenerator, RightColumn) { 108 const std::vector<std::vector<int>> Choices{{0}, {1, 2}}; 109 110 std::vector<std::vector<int>> Variants; 111 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 112 const size_t NumVariants = G.numCombinations(); 113 G.generate([&](ArrayRef<int> State) -> bool { 114 Variants.emplace_back(State); 115 return false; // keep going 116 }); 117 118 const std::vector<std::vector<int>> ExpectedVariants{ 119 {0, 1}, 120 {0, 2}, 121 }; 122 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 123 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 124 } 125 126 TEST(CombinationGenerator, Column) { 127 const std::vector<std::vector<int>> Choices{{0, 1}}; 128 129 std::vector<std::vector<int>> Variants; 130 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 131 const size_t NumVariants = G.numCombinations(); 132 G.generate([&](ArrayRef<int> State) -> bool { 133 Variants.emplace_back(State); 134 return false; // keep going 135 }); 136 137 const std::vector<std::vector<int>> ExpectedVariants{ 138 {0}, 139 {1}, 140 }; 141 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 142 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 143 } 144 145 TEST(CombinationGenerator, Row) { 146 const std::vector<std::vector<int>> Choices{{0}, {1}}; 147 148 std::vector<std::vector<int>> Variants; 149 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 150 const size_t NumVariants = G.numCombinations(); 151 G.generate([&](ArrayRef<int> State) -> bool { 152 Variants.emplace_back(State); 153 return false; // keep going 154 }); 155 156 const std::vector<std::vector<int>> ExpectedVariants{ 157 {0, 1}, 158 }; 159 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 160 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 161 } 162 163 TEST(CombinationGenerator, Singleton) { 164 const std::vector<std::vector<int>> Choices{{0}}; 165 166 std::vector<std::vector<int>> Variants; 167 CombinationGenerator<int, std::vector<int>, 4> G(Choices); 168 const size_t NumVariants = G.numCombinations(); 169 G.generate([&](ArrayRef<int> State) -> bool { 170 Variants.emplace_back(State); 171 return false; // keep going 172 }); 173 174 const std::vector<std::vector<int>> ExpectedVariants{ 175 {0}, 176 }; 177 ASSERT_THAT(Variants, ::testing::SizeIs(NumVariants)); 178 ASSERT_THAT(Variants, ::testing::ContainerEq(ExpectedVariants)); 179 } 180 181 } // end anonymous namespace 182