|
150
|
1 //===- unittest/IR/OpenMPContextTest.cpp - OpenMP Context handling tests --===//
|
|
|
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/Frontend/OpenMP/OMPConstants.h"
|
|
|
10 #include "llvm/Frontend/OpenMP/OMPContext.h"
|
|
252
|
11 #include "llvm/TargetParser/Triple.h"
|
|
150
|
12 #include "gtest/gtest.h"
|
|
|
13
|
|
|
14 using namespace llvm;
|
|
|
15 using namespace omp;
|
|
|
16
|
|
|
17 namespace {
|
|
|
18
|
|
|
19 class OpenMPContextTest : public testing::Test {
|
|
|
20 protected:
|
|
|
21 void SetUp() override {}
|
|
|
22
|
|
|
23 void TearDown() override {}
|
|
|
24 };
|
|
|
25
|
|
|
26 TEST_F(OpenMPContextTest, RoundTripAndAssociation) {
|
|
|
27 #define OMP_TRAIT_SET(Enum, Str) \
|
|
|
28 EXPECT_EQ(TraitSet::Enum, \
|
|
|
29 getOpenMPContextTraitSetKind( \
|
|
|
30 getOpenMPContextTraitSetName(TraitSet::Enum))); \
|
|
|
31 EXPECT_EQ(Str, \
|
|
|
32 getOpenMPContextTraitSetName(getOpenMPContextTraitSetKind(Str)));
|
|
|
33 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty) \
|
|
|
34 EXPECT_EQ(TraitSelector::Enum, \
|
|
|
35 getOpenMPContextTraitSelectorKind( \
|
|
|
36 getOpenMPContextTraitSelectorName(TraitSelector::Enum))); \
|
|
|
37 EXPECT_EQ(Str, getOpenMPContextTraitSelectorName( \
|
|
|
38 getOpenMPContextTraitSelectorKind(Str)));
|
|
|
39 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
|
|
|
40 EXPECT_EQ(TraitProperty::Enum, \
|
|
|
41 getOpenMPContextTraitPropertyKind( \
|
|
221
|
42 TraitSet::TraitSetEnum, TraitSelector::TraitSelectorEnum, \
|
|
|
43 getOpenMPContextTraitPropertyName(TraitProperty::Enum, Str))); \
|
|
173
|
44 EXPECT_EQ(Str, getOpenMPContextTraitPropertyName( \
|
|
221
|
45 getOpenMPContextTraitPropertyKind( \
|
|
|
46 TraitSet::TraitSetEnum, \
|
|
|
47 TraitSelector::TraitSelectorEnum, Str), \
|
|
|
48 Str)); \
|
|
150
|
49 EXPECT_EQ(TraitSet::TraitSetEnum, \
|
|
|
50 getOpenMPContextTraitSetForProperty(TraitProperty::Enum)); \
|
|
|
51 EXPECT_EQ(TraitSelector::TraitSelectorEnum, \
|
|
|
52 getOpenMPContextTraitSelectorForProperty(TraitProperty::Enum));
|
|
|
53 #include "llvm/Frontend/OpenMP/OMPKinds.def"
|
|
|
54 }
|
|
|
55
|
|
|
56 TEST_F(OpenMPContextTest, ValidNesting) {
|
|
|
57 bool AllowsTraitScore, ReqProperty;
|
|
|
58 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty) \
|
|
|
59 EXPECT_TRUE(isValidTraitSelectorForTraitSet(TraitSelector::Enum, \
|
|
|
60 TraitSet::TraitSetEnum, \
|
|
|
61 AllowsTraitScore, ReqProperty)); \
|
|
|
62 EXPECT_EQ(RequiresProperty, ReqProperty);
|
|
|
63 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \
|
|
|
64 EXPECT_TRUE(isValidTraitPropertyForTraitSetAndSelector( \
|
|
|
65 TraitProperty::Enum, TraitSelector::TraitSelectorEnum, \
|
|
|
66 TraitSet::TraitSetEnum));
|
|
|
67 #include "llvm/Frontend/OpenMP/OMPKinds.def"
|
|
|
68 }
|
|
|
69
|
|
|
70 TEST_F(OpenMPContextTest, ApplicabilityNonConstruct) {
|
|
|
71 OMPContext HostLinux(false, Triple("x86_64-unknown-linux"));
|
|
|
72 OMPContext DeviceLinux(true, Triple("x86_64-unknown-linux"));
|
|
|
73 OMPContext HostNVPTX(false, Triple("nvptx64-nvidia-cuda"));
|
|
|
74 OMPContext DeviceNVPTX(true, Triple("nvptx64-nvidia-cuda"));
|
|
|
75
|
|
|
76 VariantMatchInfo Empty;
|
|
|
77 EXPECT_TRUE(isVariantApplicableInContext(Empty, HostLinux));
|
|
|
78 EXPECT_TRUE(isVariantApplicableInContext(Empty, DeviceLinux));
|
|
|
79 EXPECT_TRUE(isVariantApplicableInContext(Empty, HostNVPTX));
|
|
|
80 EXPECT_TRUE(isVariantApplicableInContext(Empty, DeviceNVPTX));
|
|
|
81
|
|
|
82 VariantMatchInfo UserCondFalse;
|
|
221
|
83 UserCondFalse.addTrait(TraitProperty::user_condition_false, "");
|
|
150
|
84 EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, HostLinux));
|
|
|
85 EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, DeviceLinux));
|
|
|
86 EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, HostNVPTX));
|
|
|
87 EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, DeviceNVPTX));
|
|
|
88
|
|
|
89 VariantMatchInfo DeviceArchArm;
|
|
221
|
90 DeviceArchArm.addTrait(TraitProperty::device_arch_arm, "");
|
|
150
|
91 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, HostLinux));
|
|
|
92 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, DeviceLinux));
|
|
|
93 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, HostNVPTX));
|
|
|
94 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, DeviceNVPTX));
|
|
|
95
|
|
|
96 VariantMatchInfo LLVMHostUserCondTrue;
|
|
221
|
97 LLVMHostUserCondTrue.addTrait(TraitProperty::implementation_vendor_llvm, "");
|
|
|
98 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_host, "");
|
|
|
99 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_any, "");
|
|
|
100 LLVMHostUserCondTrue.addTrait(TraitProperty::user_condition_true, "");
|
|
150
|
101 EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrue, HostLinux));
|
|
|
102 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue, DeviceLinux));
|
|
|
103 EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrue, HostNVPTX));
|
|
|
104 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue, DeviceNVPTX));
|
|
|
105
|
|
|
106 VariantMatchInfo LLVMHostUserCondTrueCPU = LLVMHostUserCondTrue;
|
|
221
|
107 LLVMHostUserCondTrueCPU.addTrait(TraitProperty::device_kind_cpu, "");
|
|
150
|
108 EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU, HostLinux));
|
|
|
109 EXPECT_FALSE(
|
|
|
110 isVariantApplicableInContext(LLVMHostUserCondTrueCPU, DeviceLinux));
|
|
|
111 EXPECT_FALSE(
|
|
|
112 isVariantApplicableInContext(LLVMHostUserCondTrueCPU, HostNVPTX));
|
|
|
113 EXPECT_FALSE(
|
|
|
114 isVariantApplicableInContext(LLVMHostUserCondTrueCPU, DeviceNVPTX));
|
|
|
115
|
|
|
116 VariantMatchInfo GPU;
|
|
221
|
117 GPU.addTrait(TraitProperty::device_kind_gpu, "");
|
|
150
|
118 EXPECT_FALSE(isVariantApplicableInContext(GPU, HostLinux));
|
|
|
119 EXPECT_FALSE(isVariantApplicableInContext(GPU, DeviceLinux));
|
|
|
120 EXPECT_TRUE(isVariantApplicableInContext(GPU, HostNVPTX));
|
|
|
121 EXPECT_TRUE(isVariantApplicableInContext(GPU, DeviceNVPTX));
|
|
|
122
|
|
|
123 VariantMatchInfo NoHost;
|
|
221
|
124 NoHost.addTrait(TraitProperty::device_kind_nohost, "");
|
|
150
|
125 EXPECT_FALSE(isVariantApplicableInContext(NoHost, HostLinux));
|
|
|
126 EXPECT_TRUE(isVariantApplicableInContext(NoHost, DeviceLinux));
|
|
|
127 EXPECT_FALSE(isVariantApplicableInContext(NoHost, HostNVPTX));
|
|
|
128 EXPECT_TRUE(isVariantApplicableInContext(NoHost, DeviceNVPTX));
|
|
|
129 }
|
|
|
130
|
|
|
131 TEST_F(OpenMPContextTest, ApplicabilityAllTraits) {
|
|
|
132 OMPContext HostLinuxParallelParallel(false, Triple("x86_64-unknown-linux"));
|
|
|
133 HostLinuxParallelParallel.addTrait(
|
|
|
134 TraitProperty::construct_parallel_parallel);
|
|
|
135 HostLinuxParallelParallel.addTrait(
|
|
|
136 TraitProperty::construct_parallel_parallel);
|
|
|
137 OMPContext DeviceLinuxTargetParallel(true, Triple("x86_64-unknown-linux"));
|
|
|
138 DeviceLinuxTargetParallel.addTrait(TraitProperty::construct_target_target);
|
|
|
139 DeviceLinuxTargetParallel.addTrait(
|
|
|
140 TraitProperty::construct_parallel_parallel);
|
|
|
141 OMPContext HostNVPTXFor(false, Triple("nvptx64-nvidia-cuda"));
|
|
|
142 HostNVPTXFor.addTrait(TraitProperty::construct_for_for);
|
|
|
143 OMPContext DeviceNVPTXTargetTeamsParallel(true,
|
|
|
144 Triple("nvptx64-nvidia-cuda"));
|
|
|
145 DeviceNVPTXTargetTeamsParallel.addTrait(
|
|
|
146 TraitProperty::construct_target_target);
|
|
|
147 DeviceNVPTXTargetTeamsParallel.addTrait(TraitProperty::construct_teams_teams);
|
|
|
148 DeviceNVPTXTargetTeamsParallel.addTrait(
|
|
|
149 TraitProperty::construct_parallel_parallel);
|
|
|
150
|
|
|
151 { // non-construct variants
|
|
|
152 VariantMatchInfo Empty;
|
|
|
153 EXPECT_TRUE(isVariantApplicableInContext(Empty, HostLinuxParallelParallel));
|
|
|
154 EXPECT_TRUE(isVariantApplicableInContext(Empty, DeviceLinuxTargetParallel));
|
|
|
155 EXPECT_TRUE(isVariantApplicableInContext(Empty, HostNVPTXFor));
|
|
|
156 EXPECT_TRUE(
|
|
|
157 isVariantApplicableInContext(Empty, DeviceNVPTXTargetTeamsParallel));
|
|
|
158
|
|
|
159 VariantMatchInfo UserCondFalse;
|
|
221
|
160 UserCondFalse.addTrait(TraitProperty::user_condition_false, "");
|
|
150
|
161 EXPECT_FALSE(
|
|
|
162 isVariantApplicableInContext(UserCondFalse, HostLinuxParallelParallel));
|
|
|
163 EXPECT_FALSE(
|
|
|
164 isVariantApplicableInContext(UserCondFalse, DeviceLinuxTargetParallel));
|
|
|
165 EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, HostNVPTXFor));
|
|
|
166 EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse,
|
|
|
167 DeviceNVPTXTargetTeamsParallel));
|
|
|
168
|
|
|
169 VariantMatchInfo DeviceArchArm;
|
|
221
|
170 DeviceArchArm.addTrait(TraitProperty::device_arch_arm, "");
|
|
150
|
171 EXPECT_FALSE(
|
|
|
172 isVariantApplicableInContext(DeviceArchArm, HostLinuxParallelParallel));
|
|
|
173 EXPECT_FALSE(
|
|
|
174 isVariantApplicableInContext(DeviceArchArm, DeviceLinuxTargetParallel));
|
|
|
175 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, HostNVPTXFor));
|
|
|
176 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm,
|
|
|
177 DeviceNVPTXTargetTeamsParallel));
|
|
|
178
|
|
|
179 APInt Score(32, 1000);
|
|
|
180 VariantMatchInfo LLVMHostUserCondTrue;
|
|
221
|
181 LLVMHostUserCondTrue.addTrait(TraitProperty::implementation_vendor_llvm,
|
|
|
182 "");
|
|
|
183 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_host, "");
|
|
|
184 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_any, "");
|
|
|
185 LLVMHostUserCondTrue.addTrait(TraitProperty::user_condition_true, "",
|
|
|
186 &Score);
|
|
150
|
187 EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrue,
|
|
|
188 HostLinuxParallelParallel));
|
|
|
189 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue,
|
|
|
190 DeviceLinuxTargetParallel));
|
|
|
191 EXPECT_TRUE(
|
|
|
192 isVariantApplicableInContext(LLVMHostUserCondTrue, HostNVPTXFor));
|
|
|
193 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue,
|
|
|
194 DeviceNVPTXTargetTeamsParallel));
|
|
|
195
|
|
|
196 VariantMatchInfo LLVMHostUserCondTrueCPU = LLVMHostUserCondTrue;
|
|
221
|
197 LLVMHostUserCondTrueCPU.addTrait(TraitProperty::device_kind_cpu, "");
|
|
150
|
198 EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU,
|
|
|
199 HostLinuxParallelParallel));
|
|
|
200 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU,
|
|
|
201 DeviceLinuxTargetParallel));
|
|
|
202 EXPECT_FALSE(
|
|
|
203 isVariantApplicableInContext(LLVMHostUserCondTrueCPU, HostNVPTXFor));
|
|
|
204 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU,
|
|
|
205 DeviceNVPTXTargetTeamsParallel));
|
|
|
206
|
|
|
207 VariantMatchInfo GPU;
|
|
221
|
208 GPU.addTrait(TraitProperty::device_kind_gpu, "");
|
|
150
|
209 EXPECT_FALSE(isVariantApplicableInContext(GPU, HostLinuxParallelParallel));
|
|
|
210 EXPECT_FALSE(isVariantApplicableInContext(GPU, DeviceLinuxTargetParallel));
|
|
|
211 EXPECT_TRUE(isVariantApplicableInContext(GPU, HostNVPTXFor));
|
|
|
212 EXPECT_TRUE(
|
|
|
213 isVariantApplicableInContext(GPU, DeviceNVPTXTargetTeamsParallel));
|
|
|
214
|
|
|
215 VariantMatchInfo NoHost;
|
|
221
|
216 NoHost.addTrait(TraitProperty::device_kind_nohost, "");
|
|
150
|
217 EXPECT_FALSE(
|
|
|
218 isVariantApplicableInContext(NoHost, HostLinuxParallelParallel));
|
|
|
219 EXPECT_TRUE(
|
|
|
220 isVariantApplicableInContext(NoHost, DeviceLinuxTargetParallel));
|
|
|
221 EXPECT_FALSE(isVariantApplicableInContext(NoHost, HostNVPTXFor));
|
|
|
222 EXPECT_TRUE(
|
|
|
223 isVariantApplicableInContext(NoHost, DeviceNVPTXTargetTeamsParallel));
|
|
|
224 }
|
|
|
225 { // variants with all sets
|
|
|
226 VariantMatchInfo DeviceArchArmParallel;
|
|
221
|
227 DeviceArchArmParallel.addTrait(TraitProperty::construct_parallel_parallel,
|
|
|
228 "");
|
|
|
229 DeviceArchArmParallel.addTrait(TraitProperty::device_arch_arm, "");
|
|
150
|
230 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArmParallel,
|
|
|
231 HostLinuxParallelParallel));
|
|
|
232 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArmParallel,
|
|
|
233 DeviceLinuxTargetParallel));
|
|
|
234 EXPECT_FALSE(
|
|
|
235 isVariantApplicableInContext(DeviceArchArmParallel, HostNVPTXFor));
|
|
|
236 EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArmParallel,
|
|
|
237 DeviceNVPTXTargetTeamsParallel));
|
|
|
238
|
|
|
239 VariantMatchInfo LLVMHostUserCondTrueParallel;
|
|
|
240 LLVMHostUserCondTrueParallel.addTrait(
|
|
221
|
241 TraitProperty::implementation_vendor_llvm, "");
|
|
|
242 LLVMHostUserCondTrueParallel.addTrait(TraitProperty::device_kind_host, "");
|
|
|
243 LLVMHostUserCondTrueParallel.addTrait(TraitProperty::device_kind_any, "");
|
|
|
244 LLVMHostUserCondTrueParallel.addTrait(TraitProperty::user_condition_true,
|
|
|
245 "");
|
|
150
|
246 LLVMHostUserCondTrueParallel.addTrait(
|
|
221
|
247 TraitProperty::construct_parallel_parallel, "");
|
|
150
|
248 EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel,
|
|
|
249 HostLinuxParallelParallel));
|
|
|
250 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel,
|
|
|
251 DeviceLinuxTargetParallel));
|
|
|
252 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel,
|
|
|
253 HostNVPTXFor));
|
|
|
254 EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel,
|
|
|
255 DeviceNVPTXTargetTeamsParallel));
|
|
|
256
|
|
|
257 VariantMatchInfo LLVMHostUserCondTrueParallelParallel =
|
|
|
258 LLVMHostUserCondTrueParallel;
|
|
|
259 LLVMHostUserCondTrueParallelParallel.addTrait(
|
|
221
|
260 TraitProperty::construct_parallel_parallel, "");
|
|
150
|
261 EXPECT_TRUE(isVariantApplicableInContext(
|
|
|
262 LLVMHostUserCondTrueParallelParallel, HostLinuxParallelParallel));
|
|
|
263 EXPECT_FALSE(isVariantApplicableInContext(
|
|
|
264 LLVMHostUserCondTrueParallelParallel, DeviceLinuxTargetParallel));
|
|
|
265 EXPECT_FALSE(isVariantApplicableInContext(
|
|
|
266 LLVMHostUserCondTrueParallelParallel, HostNVPTXFor));
|
|
|
267 EXPECT_FALSE(isVariantApplicableInContext(
|
|
|
268 LLVMHostUserCondTrueParallelParallel, DeviceNVPTXTargetTeamsParallel));
|
|
|
269
|
|
|
270 VariantMatchInfo LLVMHostUserCondTrueParallelParallelParallel =
|
|
|
271 LLVMHostUserCondTrueParallelParallel;
|
|
|
272 LLVMHostUserCondTrueParallelParallelParallel.addTrait(
|
|
221
|
273 TraitProperty::construct_parallel_parallel, "");
|
|
150
|
274 EXPECT_FALSE(isVariantApplicableInContext(
|
|
|
275 LLVMHostUserCondTrueParallelParallelParallel,
|
|
|
276 HostLinuxParallelParallel));
|
|
|
277 EXPECT_FALSE(isVariantApplicableInContext(
|
|
|
278 LLVMHostUserCondTrueParallelParallelParallel,
|
|
|
279 DeviceLinuxTargetParallel));
|
|
|
280 EXPECT_FALSE(isVariantApplicableInContext(
|
|
|
281 LLVMHostUserCondTrueParallelParallelParallel, HostNVPTXFor));
|
|
|
282 EXPECT_FALSE(isVariantApplicableInContext(
|
|
|
283 LLVMHostUserCondTrueParallelParallelParallel,
|
|
|
284 DeviceNVPTXTargetTeamsParallel));
|
|
|
285
|
|
|
286 VariantMatchInfo GPUTargetTeams;
|
|
221
|
287 GPUTargetTeams.addTrait(TraitProperty::construct_target_target, "");
|
|
|
288 GPUTargetTeams.addTrait(TraitProperty::construct_teams_teams, "");
|
|
|
289 GPUTargetTeams.addTrait(TraitProperty::device_kind_gpu, "");
|
|
150
|
290 EXPECT_FALSE(isVariantApplicableInContext(GPUTargetTeams,
|
|
|
291 HostLinuxParallelParallel));
|
|
|
292 EXPECT_FALSE(isVariantApplicableInContext(GPUTargetTeams,
|
|
|
293 DeviceLinuxTargetParallel));
|
|
|
294 EXPECT_FALSE(isVariantApplicableInContext(GPUTargetTeams, HostNVPTXFor));
|
|
|
295 EXPECT_TRUE(isVariantApplicableInContext(GPUTargetTeams,
|
|
|
296 DeviceNVPTXTargetTeamsParallel));
|
|
|
297
|
|
|
298 VariantMatchInfo GPUTargetParallel;
|
|
221
|
299 GPUTargetParallel.addTrait(TraitProperty::construct_target_target, "");
|
|
|
300 GPUTargetParallel.addTrait(TraitProperty::construct_parallel_parallel, "");
|
|
|
301 GPUTargetParallel.addTrait(TraitProperty::device_kind_gpu, "");
|
|
150
|
302 EXPECT_FALSE(isVariantApplicableInContext(GPUTargetParallel,
|
|
|
303 HostLinuxParallelParallel));
|
|
|
304 EXPECT_FALSE(isVariantApplicableInContext(GPUTargetParallel,
|
|
|
305 DeviceLinuxTargetParallel));
|
|
|
306 EXPECT_FALSE(isVariantApplicableInContext(GPUTargetParallel, HostNVPTXFor));
|
|
|
307 EXPECT_TRUE(isVariantApplicableInContext(GPUTargetParallel,
|
|
|
308 DeviceNVPTXTargetTeamsParallel));
|
|
|
309 }
|
|
|
310 }
|
|
|
311
|
|
|
312 TEST_F(OpenMPContextTest, ScoringSimple) {
|
|
|
313 // TODO: Add scoring tests (via getBestVariantMatchForContext).
|
|
|
314 }
|
|
|
315
|
|
|
316 } // namespace
|
