OR-Tools  9.3
solvers_proto_validation_test.cc
Go to the documentation of this file.
1// Copyright 2010-2021 Google LLC
2// Licensed under the Apache License, Version 2.0 (the "License");
3// you may not use this file except in compliance with the License.
4// You may obtain a copy of the License at
5//
6// http://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software
9// distributed under the License is distributed on an "AS IS" BASIS,
10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11// See the License for the specific language governing permissions and
12// limitations under the License.
13
14#include "ortools/pdlp/solvers_proto_validation.h"
15
16#include "absl/status/status.h"
17#include "gmock/gmock.h"
18#include "gtest/gtest.h"
19#include "ortools/pdlp/solvers.pb.h"
20
21namespace operations_research::pdlp {
22namespace {
23
24using ::testing::HasSubstr;
25
26TEST(ValidateTerminationCriteria, DefaultIsValid) {
27 TerminationCriteria criteria;
28 const absl::Status status = ValidateTerminationCriteria(criteria);
29 EXPECT_TRUE(status.ok()) << status;
30}
31
32TEST(ValidateTerminationCriteria, BadOptimalityNorm) {
33 TerminationCriteria criteria;
34 criteria.set_optimality_norm(OPTIMALITY_NORM_UNSPECIFIED);
35 const absl::Status status = ValidateTerminationCriteria(criteria);
36 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
37 EXPECT_THAT(status.message(), HasSubstr("optimality_norm"));
38}
39
40TEST(ValidateTerminationCriteria, BadEpsOptimalAbsolute) {
41 TerminationCriteria criteria;
42 criteria.set_eps_optimal_absolute(-1.0);
43 const absl::Status status = ValidateTerminationCriteria(criteria);
44 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
45 EXPECT_THAT(status.message(), HasSubstr("eps_optimal_absolute"));
46}
47
48TEST(ValidateTerminationCriteria, BadEpsOptimalRelative) {
49 TerminationCriteria criteria;
50 criteria.set_eps_optimal_relative(-1.0);
51 const absl::Status status = ValidateTerminationCriteria(criteria);
52 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
53 EXPECT_THAT(status.message(), HasSubstr("eps_optimal_relative"));
54}
55
56TEST(ValidateTerminationCriteria, BadEpsPriamlInfeasible) {
57 TerminationCriteria criteria;
58 criteria.set_eps_primal_infeasible(-1.0);
59 const absl::Status status = ValidateTerminationCriteria(criteria);
60 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
61 EXPECT_THAT(status.message(), HasSubstr("eps_primal_infeasible"));
62}
63
64TEST(ValidateTerminationCriteria, BadEpsDualInfeasible) {
65 TerminationCriteria criteria;
66 criteria.set_eps_dual_infeasible(-1.0);
67 const absl::Status status = ValidateTerminationCriteria(criteria);
68 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
69 EXPECT_THAT(status.message(), HasSubstr("eps_dual_infeasible"));
70}
71
72TEST(ValidateTerminationCriteria, BadTimeSecLimit) {
73 TerminationCriteria criteria;
74 criteria.set_time_sec_limit(-1.0);
75 const absl::Status status = ValidateTerminationCriteria(criteria);
76 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
77 EXPECT_THAT(status.message(), HasSubstr("time_sec_limit"));
78}
79
80TEST(ValidateTerminationCriteria, BadIterationLimit) {
81 TerminationCriteria criteria;
82 criteria.set_iteration_limit(-1);
83 const absl::Status status = ValidateTerminationCriteria(criteria);
84 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
85 EXPECT_THAT(status.message(), HasSubstr("iteration_limit"));
86}
87
88TEST(ValidateTerminationCriteria, BadKktMatrixPassLimit) {
89 TerminationCriteria criteria;
90 criteria.set_kkt_matrix_pass_limit(-1.0);
91 const absl::Status status = ValidateTerminationCriteria(criteria);
92 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
93 EXPECT_THAT(status.message(), HasSubstr("kkt_matrix_pass_limit"));
94}
95
96TEST(ValidateAdaptiveLinesearchParams, DefaultIsValid) {
97 AdaptiveLinesearchParams params;
98 const absl::Status status = ValidateAdaptiveLinesearchParams(params);
99 EXPECT_TRUE(status.ok()) << status;
100}
101
102TEST(ValidateAdaptiveLinesearchParams, BadReductionExponent) {
103 AdaptiveLinesearchParams params;
104 params.set_step_size_reduction_exponent(0.0);
105 const absl::Status status = ValidateAdaptiveLinesearchParams(params);
106 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
107 EXPECT_THAT(status.message(), HasSubstr("step_size_reduction_exponent"));
108}
109
110TEST(ValidateAdaptiveLinesearchParams, BadGrowthExponent) {
111 AdaptiveLinesearchParams params;
112 params.set_step_size_growth_exponent(0.0);
113 const absl::Status status = ValidateAdaptiveLinesearchParams(params);
114 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
115 EXPECT_THAT(status.message(), HasSubstr("step_size_growth_exponent"));
116}
117
118TEST(ValidateMalitskyPockParams, DefaultIsValid) {
119 MalitskyPockParams params;
120 const absl::Status status = ValidateMalitskyPockParams(params);
121 EXPECT_TRUE(status.ok()) << status;
122}
123
124TEST(ValidateMalitskyPockParams, BadDownscalingFactor) {
125 MalitskyPockParams params0;
126 params0.set_step_size_downscaling_factor(0.0);
127 const absl::Status status0 = ValidateMalitskyPockParams(params0);
128 EXPECT_EQ(status0.code(), absl::StatusCode::kInvalidArgument);
129 EXPECT_THAT(status0.message(), HasSubstr("step_size_downscaling_factor"));
130
131 MalitskyPockParams params1;
132 params1.set_step_size_downscaling_factor(1.0);
133 const absl::Status status1 = ValidateMalitskyPockParams(params1);
134 EXPECT_EQ(status1.code(), absl::StatusCode::kInvalidArgument);
135 EXPECT_THAT(status1.message(), HasSubstr("step_size_downscaling_factor"));
136}
137
138TEST(ValidateMalitskyPockParams, BadConstractionFactor) {
139 MalitskyPockParams params0;
140 params0.set_linesearch_contraction_factor(0.0);
141 const absl::Status status0 = ValidateMalitskyPockParams(params0);
142 EXPECT_EQ(status0.code(), absl::StatusCode::kInvalidArgument);
143 EXPECT_THAT(status0.message(), HasSubstr("linesearch_contraction_factor"));
144
145 MalitskyPockParams params1;
146 params1.set_linesearch_contraction_factor(1.0);
147 const absl::Status status1 = ValidateMalitskyPockParams(params1);
148 EXPECT_EQ(status1.code(), absl::StatusCode::kInvalidArgument);
149 EXPECT_THAT(status1.message(), HasSubstr("linesearch_contraction_factor"));
150}
151
152TEST(ValidateMalitskyPockParams, BadStepSizeInterpolation) {
153 MalitskyPockParams params;
154 params.set_step_size_interpolation(-1.0);
155 const absl::Status status = ValidateMalitskyPockParams(params);
156 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
157 EXPECT_THAT(status.message(), HasSubstr("step_size_interpolation"));
158}
159
160TEST(ValidatePrimalDualHybridGradientParams, DefaultIsValid) {
161 PrimalDualHybridGradientParams params;
162 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
163 EXPECT_TRUE(status.ok()) << status;
164}
165
166TEST(ValidatePrimalDualHybridGradientParams, BadTerminationCriteria) {
167 PrimalDualHybridGradientParams params;
168 params.mutable_termination_criteria()->set_eps_dual_infeasible(-1);
169 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
170 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
171 EXPECT_THAT(status.message(), HasSubstr("eps_dual_infeasible"));
172}
173
174TEST(ValidatePrimalDualHybridGradientParams, BadNumThreads) {
175 PrimalDualHybridGradientParams params;
176 params.set_num_threads(0);
177 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
178 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
179 EXPECT_THAT(status.message(), HasSubstr("num_threads"));
180}
181
182TEST(ValidatePrimalDualHybridGradientParams, BadVerbosityLevel) {
183 PrimalDualHybridGradientParams params;
184 params.set_verbosity_level(-1);
185 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
186 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
187 EXPECT_THAT(status.message(), HasSubstr("verbosity_level"));
188}
189
190TEST(ValidatePrimalDualHybridGradientParams, BadMajorIterationFrequency) {
191 PrimalDualHybridGradientParams params;
192 params.set_major_iteration_frequency(0);
193 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
194 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
195 EXPECT_THAT(status.message(), HasSubstr("major_iteration_frequency"));
196}
197
198TEST(ValidatePrimalDualHybridGradientParams, BadTerminationCheckFrequency) {
199 PrimalDualHybridGradientParams params;
200 params.set_termination_check_frequency(0);
201 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
202 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
203 EXPECT_THAT(status.message(), HasSubstr("termination_check_frequency"));
204}
205
206TEST(ValidatePrimalDualHybridGradientParams, BadRestartStrategy) {
207 PrimalDualHybridGradientParams params;
208 params.set_restart_strategy(
209 PrimalDualHybridGradientParams::RESTART_STRATEGY_UNSPECIFIED);
210 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
211 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
212 EXPECT_THAT(status.message(), HasSubstr("restart_strategy"));
213}
214
215TEST(ValidatePrimalDualHybridGradientParams, BadPrimalWeightUpdateSmoothing) {
216 PrimalDualHybridGradientParams params_high;
217 params_high.set_primal_weight_update_smoothing(1.1);
218 const absl::Status status_high =
219 ValidatePrimalDualHybridGradientParams(params_high);
220 EXPECT_EQ(status_high.code(), absl::StatusCode::kInvalidArgument);
221 EXPECT_THAT(status_high.message(),
222 HasSubstr("primal_weight_update_smoothing"));
223
224 PrimalDualHybridGradientParams params_low;
225 params_low.set_primal_weight_update_smoothing(-0.1);
226 const absl::Status status_low =
227 ValidatePrimalDualHybridGradientParams(params_low);
228 EXPECT_EQ(status_low.code(), absl::StatusCode::kInvalidArgument);
229 EXPECT_THAT(status_low.message(),
230 HasSubstr("primal_weight_update_smoothing"));
231}
232
233TEST(ValidatePrimalDualHybridGradientParams, BadInitialPrimalWeight) {
234 PrimalDualHybridGradientParams params;
235 params.set_initial_primal_weight(-1);
236 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
237 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
238 EXPECT_THAT(status.message(), HasSubstr("initial_primal_weight"));
239}
240
241TEST(ValidatePrimalDualHybridGradientParams, BadLInfRuizIterations) {
242 PrimalDualHybridGradientParams params;
243 params.set_l_inf_ruiz_iterations(-1);
244 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
245 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
246 EXPECT_THAT(status.message(), HasSubstr("l_inf_ruiz_iterations"));
247}
248
249TEST(ValidatePrimalDualHybridGradientParams, BadSufficientReductionForRestart) {
250 PrimalDualHybridGradientParams params_high;
251 params_high.set_sufficient_reduction_for_restart(1.0);
252 const absl::Status status_high =
253 ValidatePrimalDualHybridGradientParams(params_high);
254 EXPECT_EQ(status_high.code(), absl::StatusCode::kInvalidArgument);
255 EXPECT_THAT(status_high.message(),
256 HasSubstr("sufficient_reduction_for_restart"));
257
258 PrimalDualHybridGradientParams params_low;
259 params_low.set_sufficient_reduction_for_restart(0.0);
260 const absl::Status status_low =
261 ValidatePrimalDualHybridGradientParams(params_low);
262 EXPECT_EQ(status_low.code(), absl::StatusCode::kInvalidArgument);
263 EXPECT_THAT(status_low.message(),
264 HasSubstr("sufficient_reduction_for_restart"));
265}
266
267TEST(ValidatePrimalDualHybridGradientParams, BadNecessaryReductionForRestart) {
268 PrimalDualHybridGradientParams params_high;
269 params_high.set_necessary_reduction_for_restart(1.0);
270 const absl::Status status_high =
271 ValidatePrimalDualHybridGradientParams(params_high);
272 EXPECT_EQ(status_high.code(), absl::StatusCode::kInvalidArgument);
273 EXPECT_THAT(status_high.message(),
274 HasSubstr("necessary_reduction_for_restart"));
275
276 PrimalDualHybridGradientParams params_low;
277 params_low.set_sufficient_reduction_for_restart(0.5);
278 params_low.set_necessary_reduction_for_restart(0.4);
279 const absl::Status status_low =
280 ValidatePrimalDualHybridGradientParams(params_low);
281 EXPECT_EQ(status_low.code(), absl::StatusCode::kInvalidArgument);
282 EXPECT_THAT(status_low.message(),
283 HasSubstr("necessary_reduction_for_restart"));
284}
285
286TEST(ValidatePrimalDualHybridGradientParams, BadLinesearchRule) {
287 PrimalDualHybridGradientParams params;
288 params.set_linesearch_rule(
289 PrimalDualHybridGradientParams::LINESEARCH_RULE_UNSPECIFIED);
290 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
291 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
292 EXPECT_THAT(status.message(), HasSubstr("linesearch_rule"));
293}
294
295TEST(ValidatePrimalDualHybridGradientParams, BadAdaptiveLinesearchParameters) {
296 PrimalDualHybridGradientParams params;
297 params.mutable_adaptive_linesearch_parameters()
298 ->set_step_size_reduction_exponent(-1);
299 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
300 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
301 EXPECT_THAT(status.message(), HasSubstr("step_size_reduction_exponent"));
302}
303
304TEST(ValidatePrimalDualHybridGradientParams, BadMalitskyPockParameters) {
305 PrimalDualHybridGradientParams params;
306 params.mutable_malitsky_pock_parameters()->set_linesearch_contraction_factor(
307 -1);
308 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
309 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
310 EXPECT_THAT(status.message(), HasSubstr("linesearch_contraction_factor"));
311}
312
313TEST(ValidatePrimalDualHybridGradientParams, BadInitialStepSizeScaling) {
314 PrimalDualHybridGradientParams params;
315 params.set_initial_step_size_scaling(-1.0);
316 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
317 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
318 EXPECT_THAT(status.message(), HasSubstr("initial_step_size_scaling"));
319}
320
321TEST(ValidatePrimalDualHybridGradientParams,
322 BadInfiniteConstraintBoundThreshold) {
323 PrimalDualHybridGradientParams params;
324 params.set_infinite_constraint_bound_threshold(-1.0);
325 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
326 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
327 EXPECT_THAT(status.message(),
328 HasSubstr("infinite_constraint_bound_threshold"));
329}
330
331TEST(ValidatePrimalDualHybridGradientParams,
332 BadDiagonalTrustRegionSolverTolerance) {
333 PrimalDualHybridGradientParams params;
334 params.set_diagonal_qp_trust_region_solver_tolerance(-1.0);
335 const absl::Status status = ValidatePrimalDualHybridGradientParams(params);
336 EXPECT_EQ(status.code(), absl::StatusCode::kInvalidArgument);
337 EXPECT_THAT(status.message(),
338 HasSubstr("diagonal_qp_trust_region_solver_tolerance"));
339}
340
341} // namespace
342} // namespace operations_research::pdlp
status
absl::Status status
Definition: g_gurobi.cc:35
operations_research::pdlp
Definition: iteration_stats.cc:40
operations_research::pdlp::ValidateTerminationCriteria
absl::Status ValidateTerminationCriteria(const TerminationCriteria &criteria)
Definition: solvers_proto_validation.cc:25
operations_research::pdlp::ValidateMalitskyPockParams
absl::Status ValidateMalitskyPockParams(const MalitskyPockParams &params)
Definition: solvers_proto_validation.cc:66
operations_research::pdlp::ValidateAdaptiveLinesearchParams
absl::Status ValidateAdaptiveLinesearchParams(const AdaptiveLinesearchParams &params)
Definition: solvers_proto_validation.cc:54
operations_research::pdlp::ValidatePrimalDualHybridGradientParams
absl::Status ValidatePrimalDualHybridGradientParams(const PrimalDualHybridGradientParams &params)
Definition: solvers_proto_validation.cc:83
operations_research::TEST
TEST(LinearAssignmentTest, NullMatrix)
Definition: hungarian_test.cc:74
solvers_proto_validation.h