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
20using namespace llvm;
21
22namespace {
23
24TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
31 Variants.emplace_back(args&: 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
45TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
52 Variants.emplace_back(args&: 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
64TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
71 Variants.emplace_back(args&: 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
85TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
92 Variants.emplace_back(args&: 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
104TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
111 Variants.emplace_back(args&: 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
123TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
130 Variants.emplace_back(args&: 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
142TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
149 Variants.emplace_back(args&: 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
160TEST(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(Callback: [&](ArrayRef<int> State) -> bool {
167 Variants.emplace_back(args&: 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

source code of llvm/unittests/ADT/CombinationGeneratorTest.cpp