Debian Codegraph @

llvm-project/llvm/unittests/ADT/CombinationGeneratorTest.cpp

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