3 * This source code is part of
7 * GROningen MAchine for Chemical Simulations
9 * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
10 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
11 * Copyright (c) 2001-2009, The GROMACS development team,
12 * check out http://www.gromacs.org for more information.
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version 2
17 * of the License, or (at your option) any later version.
19 * If you want to redistribute modifications, please consider that
20 * scientific software is very special. Version control is crucial -
21 * bugs must be traceable. We will be happy to consider code for
22 * inclusion in the official distribution, but derived work must not
23 * be called official GROMACS. Details are found in the README & COPYING
24 * files - if they are missing, get the official version at www.gromacs.org.
26 * To help us fund GROMACS development, we humbly ask that you cite
27 * the papers on the package - you can find them in the top README file.
29 * For more info, check our website at http://www.gromacs.org
33 * Tests option assignment.
35 * In addition to testing gmx::OptionsAssigner, these are the main
36 * tests for the classes from basicoptions.h and basicoptionstorage.h (and
37 * their base classes) that actually implement the behavior, as well as for the
38 * internal implementation of the gmx::Options and gmx::AbstractOptionStorage
41 * \author Teemu Murtola <teemu.murtola@cbr.su.se>
42 * \ingroup module_options
47 #include <gtest/gtest.h>
49 #include "gromacs/options/basicoptions.h"
50 #include "gromacs/options/options.h"
51 #include "gromacs/options/optionsassigner.h"
52 #include "gromacs/utility/exceptions.h"
53 #include "gromacs/utility/stringutil.h"
58 /********************************************************************
59 * General assignment tests
62 TEST(OptionsAssignerTest, HandlesMissingRequiredParameter)
64 gmx::Options options(NULL, NULL);
66 using gmx::IntegerOption;
67 ASSERT_NO_THROW(options.addOption(
68 IntegerOption("p").store(&value).required()));
70 EXPECT_THROW(options.finish(), gmx::InvalidInputError);
73 TEST(OptionsAssignerTest, HandlesRequiredParameterWithDefaultValue)
75 gmx::Options options(NULL, NULL);
77 using gmx::IntegerOption;
78 ASSERT_NO_THROW(options.addOption(
79 IntegerOption("p").store(&value).required()
82 EXPECT_NO_THROW(options.finish());
86 TEST(OptionsAssignerTest, HandlesInvalidMultipleParameter)
88 gmx::Options options(NULL, NULL);
89 std::vector<int> values;
90 using gmx::IntegerOption;
91 ASSERT_NO_THROW(options.addOption(
92 IntegerOption("p").storeVector(&values).multiValue()));
94 gmx::OptionsAssigner assigner(&options);
95 EXPECT_NO_THROW(assigner.start());
96 ASSERT_NO_THROW(assigner.startOption("p"));
97 ASSERT_NO_THROW(assigner.appendValue("1"));
98 ASSERT_NO_THROW(assigner.finishOption());
99 EXPECT_THROW(assigner.startOption("p"), gmx::InvalidInputError);
100 EXPECT_NO_THROW(assigner.finish());
101 EXPECT_NO_THROW(options.finish());
103 EXPECT_TRUE(options.isSet("p"));
104 ASSERT_EQ(1U, values.size());
105 EXPECT_EQ(1, values[0]);
108 TEST(OptionsAssignerTest, HandlesMultipleParameter)
110 gmx::Options options(NULL, NULL);
111 std::vector<int> values;
112 using gmx::IntegerOption;
113 ASSERT_NO_THROW(options.addOption(
114 IntegerOption("p").storeVector(&values).allowMultiple()));
116 gmx::OptionsAssigner assigner(&options);
117 EXPECT_NO_THROW(assigner.start());
118 ASSERT_NO_THROW(assigner.startOption("p"));
119 ASSERT_NO_THROW(assigner.appendValue("1"));
120 EXPECT_NO_THROW(assigner.finishOption());
121 ASSERT_NO_THROW(assigner.startOption("p"));
122 ASSERT_NO_THROW(assigner.appendValue("2"));
123 EXPECT_NO_THROW(assigner.finishOption());
124 EXPECT_NO_THROW(assigner.finish());
125 EXPECT_NO_THROW(options.finish());
127 EXPECT_TRUE(options.isSet("p"));
128 ASSERT_EQ(2U, values.size());
129 EXPECT_EQ(1, values[0]);
130 EXPECT_EQ(2, values[1]);
133 TEST(OptionsAssignerTest, HandlesMissingValue)
135 gmx::Options options(NULL, NULL);
136 int value1 = 0, value2 = 0;
137 using gmx::IntegerOption;
138 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value1)));
139 ASSERT_NO_THROW(options.addOption(IntegerOption("q").store(&value2)));
141 gmx::OptionsAssigner assigner(&options);
142 EXPECT_NO_THROW(assigner.start());
143 ASSERT_NO_THROW(assigner.startOption("p"));
144 EXPECT_THROW(assigner.finishOption(), gmx::InvalidInputError);
145 ASSERT_NO_THROW(assigner.startOption("q"));
146 ASSERT_NO_THROW(assigner.appendValue("2"));
147 EXPECT_NO_THROW(assigner.finishOption());
148 EXPECT_NO_THROW(assigner.finish());
149 EXPECT_NO_THROW(options.finish());
151 EXPECT_EQ(2, value2);
154 TEST(OptionsAssignerTest, HandlesExtraValue)
156 gmx::Options options(NULL, NULL);
158 using gmx::IntegerOption;
159 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value1)));
161 gmx::OptionsAssigner assigner(&options);
162 EXPECT_NO_THROW(assigner.start());
163 ASSERT_NO_THROW(assigner.startOption("p"));
164 ASSERT_NO_THROW(assigner.appendValue("2"));
165 EXPECT_THROW(assigner.appendValue("3"), gmx::InvalidInputError);
166 EXPECT_NO_THROW(assigner.finishOption());
167 EXPECT_NO_THROW(assigner.finish());
168 EXPECT_NO_THROW(options.finish());
170 EXPECT_EQ(0, value1);
173 TEST(OptionsAssignerTest, HandlesSubSections)
175 gmx::Options options(NULL, NULL);
176 gmx::Options sub1("section1", NULL);
177 gmx::Options sub2("section2", NULL);
181 using gmx::IntegerOption;
182 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value)));
183 ASSERT_NO_THROW(sub1.addOption(IntegerOption("p").store(&value1)));
184 ASSERT_NO_THROW(sub2.addOption(IntegerOption("p").store(&value2)));
185 ASSERT_NO_THROW(options.addSubSection(&sub1));
186 ASSERT_NO_THROW(options.addSubSection(&sub2));
188 gmx::OptionsAssigner assigner(&options);
189 EXPECT_NO_THROW(assigner.start());
190 ASSERT_NO_THROW(assigner.startSubSection("section1"));
191 ASSERT_NO_THROW(assigner.startOption("p"));
192 EXPECT_NO_THROW(assigner.appendValue("5"));
193 EXPECT_NO_THROW(assigner.finishOption());
194 EXPECT_NO_THROW(assigner.finishSubSection());
195 ASSERT_NO_THROW(assigner.startOption("p"));
196 EXPECT_NO_THROW(assigner.appendValue("4"));
197 EXPECT_NO_THROW(assigner.finishOption());
198 ASSERT_NO_THROW(assigner.startSubSection("section2"));
199 ASSERT_NO_THROW(assigner.startOption("p"));
200 EXPECT_NO_THROW(assigner.appendValue("6"));
201 EXPECT_NO_THROW(assigner.finishOption());
202 EXPECT_NO_THROW(assigner.finishSubSection());
203 EXPECT_NO_THROW(assigner.finish());
204 EXPECT_NO_THROW(options.finish());
207 EXPECT_EQ(5, value1);
208 EXPECT_EQ(6, value2);
211 TEST(OptionsAssignerTest, HandlesNoStrictSubSections)
213 gmx::Options options(NULL, NULL);
214 gmx::Options sub1("section1", NULL);
215 gmx::Options sub2("section2", NULL);
221 using gmx::IntegerOption;
222 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&pvalue)));
223 ASSERT_NO_THROW(sub1.addOption(IntegerOption("p").store(&pvalue1)));
224 ASSERT_NO_THROW(sub1.addOption(IntegerOption("q").store(&qvalue)));
225 ASSERT_NO_THROW(sub2.addOption(IntegerOption("p").store(&pvalue2)));
226 ASSERT_NO_THROW(sub2.addOption(IntegerOption("r").store(&rvalue)));
227 ASSERT_NO_THROW(options.addSubSection(&sub1));
228 ASSERT_NO_THROW(options.addSubSection(&sub2));
230 gmx::OptionsAssigner assigner(&options);
231 assigner.setNoStrictSectioning(true);
232 EXPECT_NO_THROW(assigner.start());
233 ASSERT_NO_THROW(assigner.startOption("q"));
234 EXPECT_NO_THROW(assigner.appendValue("6"));
235 EXPECT_NO_THROW(assigner.finishOption());
236 ASSERT_NO_THROW(assigner.startOption("p"));
237 EXPECT_NO_THROW(assigner.appendValue("7"));
238 EXPECT_NO_THROW(assigner.finishOption());
239 ASSERT_NO_THROW(assigner.startOption("r"));
240 EXPECT_NO_THROW(assigner.appendValue("8"));
241 EXPECT_NO_THROW(assigner.finishOption());
242 ASSERT_NO_THROW(assigner.startOption("p"));
243 EXPECT_NO_THROW(assigner.appendValue("9"));
244 EXPECT_NO_THROW(assigner.finishOption());
245 EXPECT_NO_THROW(assigner.finishSubSection());
246 ASSERT_NO_THROW(assigner.startOption("p"));
247 EXPECT_NO_THROW(assigner.appendValue("10"));
248 EXPECT_NO_THROW(assigner.finishOption());
249 EXPECT_NO_THROW(assigner.finish());
250 EXPECT_NO_THROW(options.finish());
252 EXPECT_EQ(6, qvalue);
253 EXPECT_EQ(7, pvalue1);
254 EXPECT_EQ(8, rvalue);
255 EXPECT_EQ(9, pvalue2);
256 EXPECT_EQ(10, pvalue);
259 TEST(OptionsAssignerTest, HandlesMultipleSources)
261 gmx::Options options(NULL, NULL);
263 using gmx::IntegerOption;
264 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value)));
267 gmx::OptionsAssigner assigner(&options);
268 EXPECT_NO_THROW(assigner.start());
269 ASSERT_NO_THROW(assigner.startOption("p"));
270 EXPECT_NO_THROW(assigner.appendValue("1"));
271 EXPECT_NO_THROW(assigner.finishOption());
272 EXPECT_NO_THROW(assigner.finish());
275 gmx::OptionsAssigner assigner2(&options);
276 EXPECT_NO_THROW(assigner2.start());
277 ASSERT_NO_THROW(assigner2.startOption("p"));
278 EXPECT_NO_THROW(assigner2.appendValue("2"));
279 EXPECT_NO_THROW(assigner2.finishOption());
280 EXPECT_NO_THROW(assigner2.finish());
282 EXPECT_NO_THROW(options.finish());
288 /********************************************************************
289 * Tests for boolean assignment
292 TEST(OptionsAssignerBooleanTest, StoresYesValue)
294 gmx::Options options(NULL, NULL);
296 using gmx::BooleanOption;
297 ASSERT_NO_THROW(options.addOption(BooleanOption("p").store(&value)));
299 gmx::OptionsAssigner assigner(&options);
300 EXPECT_NO_THROW(assigner.start());
301 ASSERT_NO_THROW(assigner.startOption("p"));
302 EXPECT_NO_THROW(assigner.appendValue("yes"));
303 EXPECT_NO_THROW(assigner.finishOption());
304 EXPECT_NO_THROW(assigner.finish());
305 EXPECT_NO_THROW(options.finish());
310 TEST(OptionsAssignerBooleanTest, SetsBooleanWithoutExplicitValue)
312 gmx::Options options(NULL, NULL);
314 using gmx::BooleanOption;
315 ASSERT_NO_THROW(options.addOption(BooleanOption("p").store(&value)));
317 gmx::OptionsAssigner assigner(&options);
318 EXPECT_NO_THROW(assigner.start());
319 ASSERT_NO_THROW(assigner.startOption("p"));
320 EXPECT_NO_THROW(assigner.finishOption());
321 EXPECT_NO_THROW(assigner.finish());
322 EXPECT_NO_THROW(options.finish());
327 TEST(OptionsAssignerBooleanTest, ClearsBooleanWithPrefixNo)
329 gmx::Options options(NULL, NULL);
331 using gmx::BooleanOption;
332 ASSERT_NO_THROW(options.addOption(BooleanOption("p").store(&value)));
334 gmx::OptionsAssigner assigner(&options);
335 assigner.setAcceptBooleanNoPrefix(true);
336 EXPECT_NO_THROW(assigner.start());
337 ASSERT_NO_THROW(assigner.startOption("nop"));
338 EXPECT_NO_THROW(assigner.finishOption());
339 EXPECT_NO_THROW(assigner.finish());
340 EXPECT_NO_THROW(options.finish());
345 TEST(OptionsAssignerBooleanTest, HandlesBooleanWithPrefixAndValue)
347 gmx::Options options(NULL, NULL);
349 using gmx::BooleanOption;
350 ASSERT_NO_THROW(options.addOption(BooleanOption("p").store(&value)));
352 gmx::OptionsAssigner assigner(&options);
353 assigner.setAcceptBooleanNoPrefix(true);
354 EXPECT_NO_THROW(assigner.start());
355 ASSERT_NO_THROW(assigner.startOption("nop"));
356 // It's OK to fail, but if it doesn't, it should work.
359 assigner.appendValue("no");
360 assigner.finishOption();
361 EXPECT_NO_THROW(assigner.finish());
364 catch (const gmx::InvalidInputError &)
370 /********************************************************************
371 * Tests for integer assignment
373 * These tests also contain tests for general default value handling.
376 TEST(OptionsAssignerIntegerTest, StoresSingleValue)
378 gmx::Options options(NULL, NULL);
380 using gmx::IntegerOption;
381 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value)));
383 gmx::OptionsAssigner assigner(&options);
384 EXPECT_NO_THROW(assigner.start());
385 ASSERT_NO_THROW(assigner.startOption("p"));
386 ASSERT_NO_THROW(assigner.appendValue("3"));
387 EXPECT_NO_THROW(assigner.finishOption());
388 EXPECT_NO_THROW(assigner.finish());
389 EXPECT_NO_THROW(options.finish());
394 TEST(OptionsAssignerIntegerTest, HandlesEmptyValue)
396 gmx::Options options(NULL, NULL);
398 using gmx::IntegerOption;
399 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value)));
401 gmx::OptionsAssigner assigner(&options);
402 EXPECT_NO_THROW(assigner.start());
403 ASSERT_NO_THROW(assigner.startOption("p"));
404 EXPECT_THROW(assigner.appendValue(""), gmx::InvalidInputError);
405 EXPECT_NO_THROW(assigner.finishOption());
406 EXPECT_NO_THROW(assigner.finish());
407 EXPECT_NO_THROW(options.finish());
412 TEST(OptionsAssignerIntegerTest, HandlesInvalidValue)
414 gmx::Options options(NULL, NULL);
416 using gmx::IntegerOption;
417 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value)));
419 gmx::OptionsAssigner assigner(&options);
420 EXPECT_NO_THROW(assigner.start());
421 ASSERT_NO_THROW(assigner.startOption("p"));
422 EXPECT_THROW(assigner.appendValue("2abc"), gmx::InvalidInputError);
423 EXPECT_NO_THROW(assigner.finishOption());
424 EXPECT_NO_THROW(assigner.finish());
425 EXPECT_NO_THROW(options.finish());
430 TEST(OptionsAssignerIntegerTest, HandlesOverflow)
432 gmx::Options options(NULL, NULL);
434 using gmx::IntegerOption;
435 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value)));
437 gmx::OptionsAssigner assigner(&options);
438 EXPECT_NO_THROW(assigner.start());
439 ASSERT_NO_THROW(assigner.startOption("p"));
440 std::string overflowValue(
441 gmx::formatString("%d0000", std::numeric_limits<int>::max()));
442 EXPECT_THROW(assigner.appendValue(overflowValue), gmx::InvalidInputError);
443 EXPECT_NO_THROW(assigner.finishOption());
444 EXPECT_NO_THROW(assigner.finish());
445 EXPECT_NO_THROW(options.finish());
450 TEST(OptionsAssignerIntegerTest, StoresDefaultValue)
452 gmx::Options options(NULL, NULL);
454 using gmx::IntegerOption;
455 ASSERT_NO_THROW(options.addOption(
456 IntegerOption("p").store(&value).defaultValue(2)));
459 gmx::OptionsAssigner assigner(&options);
460 EXPECT_NO_THROW(assigner.start());
461 EXPECT_NO_THROW(assigner.finish());
462 EXPECT_NO_THROW(options.finish());
467 TEST(OptionsAssignerIntegerTest, StoresDefaultValueIfSet)
469 gmx::Options options(NULL, NULL);
471 using gmx::IntegerOption;
472 ASSERT_NO_THROW(options.addOption(
473 IntegerOption("p").store(&value).defaultValueIfSet(2)));
474 EXPECT_EQ(-1, value);
476 gmx::OptionsAssigner assigner(&options);
477 EXPECT_NO_THROW(assigner.start());
478 ASSERT_NO_THROW(assigner.startOption("p"));
479 EXPECT_NO_THROW(assigner.finishOption());
480 EXPECT_NO_THROW(assigner.finish());
481 EXPECT_NO_THROW(options.finish());
486 TEST(OptionsAssignerIntegerTest, HandlesDefaultValueIfSetWhenNotSet)
488 gmx::Options options(NULL, NULL);
490 using gmx::IntegerOption;
491 ASSERT_NO_THROW(options.addOption(
492 IntegerOption("p").store(&value).defaultValueIfSet(2)));
493 EXPECT_EQ(-1, value);
495 gmx::OptionsAssigner assigner(&options);
496 EXPECT_NO_THROW(assigner.start());
497 EXPECT_NO_THROW(assigner.finish());
498 EXPECT_NO_THROW(options.finish());
500 EXPECT_EQ(-1, value);
503 TEST(OptionsAssignerIntegerTest, HandlesBothDefaultValues)
505 gmx::Options options(NULL, NULL);
507 using gmx::IntegerOption;
508 ASSERT_NO_THROW(options.addOption(
509 IntegerOption("p").store(&value)
510 .defaultValue(1).defaultValueIfSet(2)));
513 gmx::OptionsAssigner assigner(&options);
514 EXPECT_NO_THROW(assigner.start());
515 ASSERT_NO_THROW(assigner.startOption("p"));
516 EXPECT_NO_THROW(assigner.finishOption());
517 EXPECT_NO_THROW(assigner.finish());
518 EXPECT_NO_THROW(options.finish());
523 TEST(OptionsAssignerIntegerTest, StoresToVector)
525 gmx::Options options(NULL, NULL);
526 std::vector<int> values;
527 using gmx::IntegerOption;
528 ASSERT_NO_THROW(options.addOption(
529 IntegerOption("p").storeVector(&values).multiValue()));
531 gmx::OptionsAssigner assigner(&options);
532 EXPECT_NO_THROW(assigner.start());
533 ASSERT_NO_THROW(assigner.startOption("p"));
534 ASSERT_NO_THROW(assigner.appendValue("-2"));
535 ASSERT_NO_THROW(assigner.appendValue("1"));
536 ASSERT_NO_THROW(assigner.appendValue("4"));
537 EXPECT_NO_THROW(assigner.finishOption());
538 EXPECT_NO_THROW(assigner.finish());
539 EXPECT_NO_THROW(options.finish());
541 EXPECT_EQ(3U, values.size());
542 EXPECT_EQ(-2, values[0]);
543 EXPECT_EQ(1, values[1]);
544 EXPECT_EQ(4, values[2]);
547 TEST(OptionsAssignerIntegerTest, HandlesVectors)
549 gmx::Options options(NULL, NULL);
550 int vec[3] = {0, 0, 0};
551 using gmx::IntegerOption;
552 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec).vector()));
554 gmx::OptionsAssigner assigner(&options);
555 EXPECT_NO_THROW(assigner.start());
556 ASSERT_NO_THROW(assigner.startOption("p"));
557 ASSERT_NO_THROW(assigner.appendValue("-2"));
558 ASSERT_NO_THROW(assigner.appendValue("1"));
559 ASSERT_NO_THROW(assigner.appendValue("4"));
560 EXPECT_NO_THROW(assigner.finishOption());
561 EXPECT_NO_THROW(assigner.finish());
562 EXPECT_NO_THROW(options.finish());
564 EXPECT_EQ(-2, vec[0]);
565 EXPECT_EQ(1, vec[1]);
566 EXPECT_EQ(4, vec[2]);
569 TEST(OptionsAssignerIntegerTest, HandlesVectorFromSingleValue)
571 gmx::Options options(NULL, NULL);
572 int vec[3] = {0, 0, 0};
573 using gmx::IntegerOption;
574 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec).vector()));
576 gmx::OptionsAssigner assigner(&options);
577 EXPECT_NO_THROW(assigner.start());
578 ASSERT_NO_THROW(assigner.startOption("p"));
579 ASSERT_NO_THROW(assigner.appendValue("2"));
580 EXPECT_NO_THROW(assigner.finishOption());
581 EXPECT_NO_THROW(assigner.finish());
582 EXPECT_NO_THROW(options.finish());
584 EXPECT_EQ(2, vec[0]);
585 EXPECT_EQ(2, vec[1]);
586 EXPECT_EQ(2, vec[2]);
589 TEST(OptionsAssignerIntegerTest, HandlesVectorsWithDefaultValue)
591 gmx::Options options(NULL, NULL);
592 int vec[3] = {3, 2, 1};
593 using gmx::IntegerOption;
594 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec).vector()));
596 EXPECT_NO_THROW(options.finish());
598 EXPECT_EQ(3, vec[0]);
599 EXPECT_EQ(2, vec[1]);
600 EXPECT_EQ(1, vec[2]);
603 TEST(OptionsAssignerIntegerTest, HandlesVectorsWithDefaultValueWithInvalidAssignment)
605 gmx::Options options(NULL, NULL);
606 int vec[3] = {3, 2, 1};
607 std::vector<int> vec2(vec, vec+3);
608 using gmx::IntegerOption;
609 ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec)
610 .storeVector(&vec2).vector()));
612 gmx::OptionsAssigner assigner(&options);
613 EXPECT_NO_THROW(assigner.start());
614 ASSERT_NO_THROW(assigner.startOption("p"));
615 EXPECT_NO_THROW(assigner.appendValue("1"));
616 EXPECT_NO_THROW(assigner.appendValue("3"));
617 EXPECT_THROW(assigner.finishOption(), gmx::InvalidInputError);
618 EXPECT_NO_THROW(assigner.finish());
619 EXPECT_NO_THROW(options.finish());
621 EXPECT_EQ(3, vec[0]);
622 EXPECT_EQ(2, vec[1]);
623 EXPECT_EQ(1, vec[2]);
624 ASSERT_EQ(3U, vec2.size());
625 EXPECT_EQ(3, vec2[0]);
626 EXPECT_EQ(2, vec2[1]);
627 EXPECT_EQ(1, vec2[2]);
631 /********************************************************************
632 * Tests for double assignment
635 TEST(OptionsAssignerDoubleTest, StoresSingleValue)
637 gmx::Options options(NULL, NULL);
639 using gmx::DoubleOption;
640 ASSERT_NO_THROW(options.addOption(DoubleOption("p").store(&value)));
642 gmx::OptionsAssigner assigner(&options);
643 EXPECT_NO_THROW(assigner.start());
644 ASSERT_NO_THROW(assigner.startOption("p"));
645 ASSERT_NO_THROW(assigner.appendValue("2.7"));
646 EXPECT_NO_THROW(assigner.finishOption());
647 EXPECT_NO_THROW(assigner.finish());
648 EXPECT_NO_THROW(options.finish());
650 EXPECT_DOUBLE_EQ(2.7, value);
653 TEST(OptionsAssignerDoubleTest, HandlesEmptyValue)
655 gmx::Options options(NULL, NULL);
657 using gmx::DoubleOption;
658 ASSERT_NO_THROW(options.addOption(DoubleOption("p").store(&value)));
660 gmx::OptionsAssigner assigner(&options);
661 EXPECT_NO_THROW(assigner.start());
662 ASSERT_NO_THROW(assigner.startOption("p"));
663 EXPECT_THROW(assigner.appendValue(""), gmx::InvalidInputError);
664 EXPECT_NO_THROW(assigner.finishOption());
665 EXPECT_NO_THROW(assigner.finish());
666 EXPECT_NO_THROW(options.finish());
668 EXPECT_DOUBLE_EQ(1.0, value);
672 /********************************************************************
673 * Tests for string assignment
676 TEST(OptionsAssignerStringTest, StoresSingleValue)
678 gmx::Options options(NULL, NULL);
680 using gmx::StringOption;
681 ASSERT_NO_THROW(options.addOption(StringOption("p").store(&value)));
683 gmx::OptionsAssigner assigner(&options);
684 EXPECT_NO_THROW(assigner.start());
685 ASSERT_NO_THROW(assigner.startOption("p"));
686 ASSERT_NO_THROW(assigner.appendValue("value"));
687 EXPECT_NO_THROW(assigner.finishOption());
688 EXPECT_NO_THROW(assigner.finish());
689 EXPECT_NO_THROW(options.finish());
691 EXPECT_EQ("value", value);
694 TEST(OptionsAssignerStringTest, HandlesEnumValue)
696 gmx::Options options(NULL, NULL);
698 const char * const allowed[] = { "none", "test", "value", NULL };
700 using gmx::StringOption;
701 ASSERT_NO_THROW(options.addOption(
702 StringOption("p").store(&value)
703 .enumValue(allowed).storeEnumIndex(&index)));
705 gmx::OptionsAssigner assigner(&options);
706 EXPECT_NO_THROW(assigner.start());
707 ASSERT_NO_THROW(assigner.startOption("p"));
708 ASSERT_NO_THROW(assigner.appendValue("test"));
709 EXPECT_NO_THROW(assigner.finishOption());
710 EXPECT_NO_THROW(assigner.finish());
711 EXPECT_NO_THROW(options.finish());
713 EXPECT_EQ("test", value);
717 TEST(OptionsAssignerStringTest, HandlesIncorrectEnumValue)
719 gmx::Options options(NULL, NULL);
721 const char * const allowed[] = { "none", "test", "value", NULL };
723 using gmx::StringOption;
724 ASSERT_NO_THROW(options.addOption(
725 StringOption("p").store(&value)
726 .enumValue(allowed).storeEnumIndex(&index)));
728 gmx::OptionsAssigner assigner(&options);
729 EXPECT_NO_THROW(assigner.start());
730 ASSERT_NO_THROW(assigner.startOption("p"));
731 ASSERT_THROW(assigner.appendValue("unknown"), gmx::InvalidInputError);
734 TEST(OptionsAssignerStringTest, CompletesEnumValue)
736 gmx::Options options(NULL, NULL);
738 const char * const allowed[] = { "none", "test", "value", NULL };
740 using gmx::StringOption;
741 ASSERT_NO_THROW(options.addOption(
742 StringOption("p").store(&value)
743 .enumValue(allowed).storeEnumIndex(&index)));
745 gmx::OptionsAssigner assigner(&options);
746 EXPECT_NO_THROW(assigner.start());
747 ASSERT_NO_THROW(assigner.startOption("p"));
748 ASSERT_NO_THROW(assigner.appendValue("te"));
749 EXPECT_NO_THROW(assigner.finishOption());
750 EXPECT_NO_THROW(assigner.finish());
751 EXPECT_NO_THROW(options.finish());
753 EXPECT_EQ("test", value);
757 TEST(OptionsAssignerStringTest, HandlesEnumWithNoValue)
759 gmx::Options options(NULL, NULL);
761 const char * const allowed[] = { "none", "test", "value", NULL };
763 using gmx::StringOption;
764 ASSERT_NO_THROW(options.addOption(
765 StringOption("p").store(&value)
766 .enumValue(allowed).storeEnumIndex(&index)));
767 EXPECT_TRUE(value.empty());
768 EXPECT_EQ(-1, index);
770 ASSERT_NO_THROW(options.finish());
772 EXPECT_TRUE(value.empty());
773 EXPECT_EQ(-1, index);
776 TEST(OptionsAssignerStringTest, HandlesEnumDefaultValue)
778 gmx::Options options(NULL, NULL);
780 const char * const allowed[] = { "none", "test", "value", NULL };
782 using gmx::StringOption;
783 ASSERT_NO_THROW(options.addOption(
784 StringOption("p").store(&value)
785 .enumValue(allowed).defaultValue("test")
786 .storeEnumIndex(&index)));
787 EXPECT_EQ("test", value);
790 gmx::OptionsAssigner assigner(&options);
791 EXPECT_NO_THROW(assigner.start());
792 EXPECT_NO_THROW(assigner.finish());
793 EXPECT_NO_THROW(options.finish());
795 EXPECT_EQ("test", value);
799 TEST(OptionsAssignerStringTest, HandlesEnumDefaultIndex)
801 gmx::Options options(NULL, NULL);
803 const char * const allowed[] = { "none", "test", "value", NULL };
805 using gmx::StringOption;
806 ASSERT_NO_THROW(options.addOption(
807 StringOption("p").store(&value)
808 .enumValue(allowed).defaultEnumIndex(1)
809 .storeEnumIndex(&index)));
810 EXPECT_EQ("test", value);
813 gmx::OptionsAssigner assigner(&options);
814 EXPECT_NO_THROW(assigner.start());
815 EXPECT_NO_THROW(assigner.finish());
816 EXPECT_NO_THROW(options.finish());
818 EXPECT_EQ("test", value);