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