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