src/gromacs/selection/tests/selectionoption.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2010,2011,2012,2013, by the GROMACS development team, led by
   5  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   6  * others, as listed in the AUTHORS file in the top-level source
   7  * directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Tests handling of selection options.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_selection
  41  */
  42 #include <gtest/gtest.h>
  43
  44 #include "gromacs/options/options.h"
  45 #include "gromacs/options/optionsassigner.h"
  46 #include "gromacs/selection/selection.h"
  47 #include "gromacs/selection/selectioncollection.h"
  48 #include "gromacs/selection/selectionfileoption.h"
  49 #include "gromacs/selection/selectionoption.h"
  50 #include "gromacs/selection/selectionoptionmanager.h"
  51 #include "gromacs/utility/exceptions.h"
  52
  53 #include "testutils/testasserts.h"
  54 #include "testutils/testfilemanager.h"
  55
  56 using gmx::test::TestFileManager;
  57
  58 namespace
  59 {
  60
  61 /********************************************************************
  62  * Base fixture for tests in this file.
  63  */
  64
  65 class SelectionOptionTestBase : public ::testing::Test
  66 {
  67     public:
  68         SelectionOptionTestBase();
  69
  70         void setManager();
  71
  72         gmx::SelectionCollection    sc_;
  73         gmx::SelectionOptionManager manager_;
  74         gmx::Options                options_;
  75 };
  76
  77 SelectionOptionTestBase::SelectionOptionTestBase()
  78     : manager_(&sc_), options_(NULL, NULL)
  79 {
  80     sc_.setReferencePosType("atom");
  81     sc_.setOutputPosType("atom");
  82 }
  83
  84 void SelectionOptionTestBase::setManager()
  85 {
  86     setManagerForSelectionOptions(&options_, &manager_);
  87 }
  88
  89
  90 /********************************************************************
  91  * Tests for SelectionOption
  92  */
  93
  94 //! Test fixture for gmx::SelectionOption.
  95 typedef SelectionOptionTestBase SelectionOptionTest;
  96
  97 TEST_F(SelectionOptionTest, ParsesSimpleSelection)
  98 {
  99     gmx::Selection sel;
 100     using gmx::SelectionOption;
 101     ASSERT_NO_THROW_GMX(options_.addOption(SelectionOption("sel").store(&sel)));
 102     setManager();
 103
 104     gmx::OptionsAssigner assigner(&options_);
 105     EXPECT_NO_THROW_GMX(assigner.start());
 106     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 107     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
 108     EXPECT_NO_THROW_GMX(assigner.finishOption());
 109     EXPECT_NO_THROW_GMX(assigner.finish());
 110     EXPECT_NO_THROW_GMX(options_.finish());
 111 }
 112
 113
 114 TEST_F(SelectionOptionTest, HandlesDynamicSelectionWhenStaticRequired)
 115 {
 116     gmx::Selection sel;
 117     using gmx::SelectionOption;
 118     ASSERT_NO_THROW_GMX(options_.addOption(
 119                                 SelectionOption("sel").store(&sel).onlyStatic()));
 120     setManager();
 121
 122     gmx::OptionsAssigner assigner(&options_);
 123     EXPECT_NO_THROW_GMX(assigner.start());
 124     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 125     EXPECT_THROW_GMX(assigner.appendValue("resname RA RB and x < 5"), gmx::InvalidInputError);
 126     EXPECT_NO_THROW_GMX(assigner.finishOption());
 127     EXPECT_NO_THROW_GMX(assigner.finish());
 128     EXPECT_NO_THROW_GMX(options_.finish());
 129 }
 130
 131
 132 TEST_F(SelectionOptionTest, HandlesTooManySelections)
 133 {
 134     gmx::Selection sel;
 135     using gmx::SelectionOption;
 136     ASSERT_NO_THROW_GMX(options_.addOption(SelectionOption("sel").store(&sel)));
 137     setManager();
 138
 139     gmx::OptionsAssigner assigner(&options_);
 140     EXPECT_NO_THROW_GMX(assigner.start());
 141     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 142     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
 143     EXPECT_THROW_GMX(assigner.appendValue("resname RB RC"), gmx::InvalidInputError);
 144     EXPECT_NO_THROW_GMX(assigner.finishOption());
 145     EXPECT_NO_THROW_GMX(assigner.finish());
 146     EXPECT_NO_THROW_GMX(options_.finish());
 147 }
 148
 149
 150 TEST_F(SelectionOptionTest, HandlesTooFewSelections)
 151 {
 152     gmx::Selection sel[2];
 153     using gmx::SelectionOption;
 154     ASSERT_NO_THROW_GMX(options_.addOption(
 155                                 SelectionOption("sel").store(sel).valueCount(2)));
 156     setManager();
 157
 158     gmx::OptionsAssigner assigner(&options_);
 159     EXPECT_NO_THROW_GMX(assigner.start());
 160     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 161     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
 162     EXPECT_THROW_GMX(assigner.finishOption(), gmx::InvalidInputError);
 163     EXPECT_NO_THROW_GMX(assigner.finish());
 164     EXPECT_NO_THROW_GMX(options_.finish());
 165 }
 166
 167
 168 TEST_F(SelectionOptionTest, HandlesAdjuster)
 169 {
 170     gmx::SelectionList        sel;
 171     using gmx::SelectionOption;
 172     gmx::SelectionOptionInfo *info = options_.addOption(
 173                 SelectionOption("sel").storeVector(&sel).multiValue());
 174     setManager();
 175
 176     gmx::OptionsAssigner assigner(&options_);
 177     EXPECT_NO_THROW_GMX(assigner.start());
 178     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 179     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
 180     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RB RC"));
 181     EXPECT_NO_THROW_GMX(assigner.finishOption());
 182     EXPECT_NO_THROW_GMX(assigner.finish());
 183     EXPECT_NO_THROW_GMX(options_.finish());
 184     EXPECT_NO_THROW_GMX(info->setValueCount(2));
 185 }
 186
 187
 188 TEST_F(SelectionOptionTest, HandlesDynamicWhenStaticRequiredWithAdjuster)
 189 {
 190     gmx::Selection            sel;
 191     using gmx::SelectionOption;
 192     gmx::SelectionOptionInfo *info = options_.addOption(
 193                 SelectionOption("sel").store(&sel));
 194     setManager();
 195
 196     gmx::OptionsAssigner assigner(&options_);
 197     EXPECT_NO_THROW_GMX(assigner.start());
 198     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 199     EXPECT_NO_THROW_GMX(assigner.appendValue("x < 5"));
 200     EXPECT_NO_THROW_GMX(assigner.finishOption());
 201     EXPECT_NO_THROW_GMX(assigner.finish());
 202     EXPECT_NO_THROW_GMX(options_.finish());
 203     EXPECT_THROW_GMX(info->setOnlyStatic(true), gmx::InvalidInputError);
 204 }
 205
 206
 207 TEST_F(SelectionOptionTest, HandlesTooManySelectionsWithAdjuster)
 208 {
 209     gmx::SelectionList        sel;
 210     using gmx::SelectionOption;
 211     gmx::SelectionOptionInfo *info = options_.addOption(
 212                 SelectionOption("sel").storeVector(&sel).multiValue());
 213     setManager();
 214
 215     gmx::OptionsAssigner assigner(&options_);
 216     EXPECT_NO_THROW_GMX(assigner.start());
 217     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 218     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
 219     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RB RC"));
 220     EXPECT_NO_THROW_GMX(assigner.finishOption());
 221     EXPECT_NO_THROW_GMX(assigner.finish());
 222     EXPECT_NO_THROW_GMX(options_.finish());
 223     EXPECT_THROW_GMX(info->setValueCount(1), gmx::InvalidInputError);
 224 }
 225
 226
 227 TEST_F(SelectionOptionTest, HandlesTooFewSelectionsWithAdjuster)
 228 {
 229     gmx::SelectionList        sel;
 230     using gmx::SelectionOption;
 231     gmx::SelectionOptionInfo *info = options_.addOption(
 232                 SelectionOption("sel").storeVector(&sel).multiValue());
 233     setManager();
 234
 235     gmx::OptionsAssigner assigner(&options_);
 236     EXPECT_NO_THROW_GMX(assigner.start());
 237     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 238     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RA RB"));
 239     EXPECT_NO_THROW_GMX(assigner.finishOption());
 240     EXPECT_NO_THROW_GMX(assigner.finish());
 241     EXPECT_NO_THROW_GMX(options_.finish());
 242     EXPECT_THROW_GMX(info->setValueCount(2), gmx::InvalidInputError);
 243 }
 244
 245
 246 TEST_F(SelectionOptionTest, HandlesDelayedRequiredSelection)
 247 {
 248     gmx::Selection sel;
 249     using gmx::SelectionOption;
 250     ASSERT_NO_THROW_GMX(options_.addOption(
 251                                 SelectionOption("sel").store(&sel).required()));
 252     setManager();
 253
 254     gmx::OptionsAssigner assigner(&options_);
 255     EXPECT_NO_THROW_GMX(assigner.start());
 256     EXPECT_NO_THROW_GMX(assigner.finish());
 257     EXPECT_NO_THROW_GMX(options_.finish());
 258     ASSERT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RA RB"));
 259     ASSERT_STREQ("resname RA RB", sel.selectionText());
 260 }
 261
 262
 263 TEST_F(SelectionOptionTest, HandlesTooFewDelayedRequiredSelections)
 264 {
 265     gmx::Selection sel[2];
 266     using gmx::SelectionOption;
 267     ASSERT_NO_THROW_GMX(options_.addOption(
 268                                 SelectionOption("sel").store(sel).required()
 269                                     .valueCount(2)));
 270     setManager();
 271
 272     gmx::OptionsAssigner assigner(&options_);
 273     EXPECT_NO_THROW_GMX(assigner.start());
 274     EXPECT_NO_THROW_GMX(assigner.finish());
 275     EXPECT_NO_THROW_GMX(options_.finish());
 276     EXPECT_THROW_GMX(manager_.parseRequestedFromString("resname RA RB"), gmx::InvalidInputError);
 277 }
 278
 279
 280 TEST_F(SelectionOptionTest, HandlesDelayedOptionalSelection)
 281 {
 282     gmx::Selection sel;
 283     using gmx::SelectionOption;
 284     ASSERT_NO_THROW_GMX(options_.addOption(SelectionOption("sel").store(&sel)));
 285     setManager();
 286
 287     gmx::OptionsAssigner assigner(&options_);
 288     EXPECT_NO_THROW_GMX(assigner.start());
 289     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 290     EXPECT_NO_THROW_GMX(assigner.finishOption());
 291     EXPECT_NO_THROW_GMX(assigner.finish());
 292     EXPECT_NO_THROW_GMX(options_.finish());
 293     ASSERT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RA RB"));
 294     ASSERT_STREQ("resname RA RB", sel.selectionText());
 295 }
 296
 297
 298 TEST_F(SelectionOptionTest, HandlesDelayedSelectionWithAdjuster)
 299 {
 300     gmx::SelectionList        sel;
 301     using gmx::SelectionOption;
 302     gmx::SelectionOptionInfo *info = options_.addOption(
 303                 SelectionOption("sel").storeVector(&sel).valueCount(3));
 304     setManager();
 305
 306     gmx::OptionsAssigner assigner(&options_);
 307     EXPECT_NO_THROW_GMX(assigner.start());
 308     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 309     EXPECT_NO_THROW_GMX(assigner.finishOption());
 310     EXPECT_NO_THROW_GMX(assigner.finish());
 311     EXPECT_NO_THROW_GMX(options_.finish());
 312     EXPECT_NO_THROW_GMX(info->setValueCount(2));
 313     EXPECT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RA RB; resname RB RC"));
 314 }
 315
 316
 317 /********************************************************************
 318  * Tests for SelectionFileOption
 319  */
 320
 321 class SelectionFileOptionTest : public SelectionOptionTestBase
 322 {
 323     public:
 324         SelectionFileOptionTest();
 325 };
 326
 327 SelectionFileOptionTest::SelectionFileOptionTest()
 328 {
 329     options_.addOption(gmx::SelectionFileOption("sf"));
 330 }
 331
 332
 333 TEST_F(SelectionFileOptionTest, HandlesSingleSelectionOptionFromFile)
 334 {
 335     gmx::SelectionList sel;
 336     gmx::SelectionList reqsel;
 337     using gmx::SelectionOption;
 338     ASSERT_NO_THROW_GMX(options_.addOption(
 339                                 SelectionOption("sel").storeVector(&sel).multiValue()));
 340     ASSERT_NO_THROW_GMX(options_.addOption(
 341                                 SelectionOption("reqsel").storeVector(&reqsel)
 342                                     .multiValue().required()));
 343     setManager();
 344
 345     gmx::OptionsAssigner assigner(&options_);
 346     EXPECT_NO_THROW_GMX(assigner.start());
 347     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 348     EXPECT_NO_THROW_GMX(assigner.finishOption());
 349     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 350     EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
 351     EXPECT_NO_THROW_GMX(assigner.finishOption());
 352     EXPECT_NO_THROW_GMX(assigner.finish());
 353     EXPECT_NO_THROW_GMX(options_.finish());
 354
 355     // These should match the contents of selfile.dat
 356     ASSERT_EQ(2U, sel.size());
 357     EXPECT_STREQ("resname RA RB", sel[0].selectionText());
 358     EXPECT_STREQ("resname RB RC", sel[1].selectionText());
 359     ASSERT_EQ(0U, reqsel.size());
 360 }
 361
 362
 363 TEST_F(SelectionFileOptionTest, HandlesTwoSeparateSelectionOptions)
 364 {
 365     gmx::SelectionList sel1;
 366     gmx::SelectionList sel2;
 367     using gmx::SelectionOption;
 368     ASSERT_NO_THROW_GMX(options_.addOption(
 369                                 SelectionOption("sel1").storeVector(&sel1).multiValue()));
 370     ASSERT_NO_THROW_GMX(options_.addOption(
 371                                 SelectionOption("sel2").storeVector(&sel2).multiValue()));
 372     setManager();
 373
 374     gmx::OptionsAssigner assigner(&options_);
 375     std::string          value(TestFileManager::getInputFilePath("selfile.dat"));
 376     EXPECT_NO_THROW_GMX(assigner.start());
 377     ASSERT_NO_THROW_GMX(assigner.startOption("sel1"));
 378     EXPECT_NO_THROW_GMX(assigner.finishOption());
 379     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 380     EXPECT_NO_THROW_GMX(assigner.appendValue(value));
 381     EXPECT_NO_THROW_GMX(assigner.finishOption());
 382     ASSERT_NO_THROW_GMX(assigner.startOption("sel2"));
 383     EXPECT_NO_THROW_GMX(assigner.finishOption());
 384     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 385     EXPECT_NO_THROW_GMX(assigner.appendValue(value));
 386     EXPECT_NO_THROW_GMX(assigner.finishOption());
 387     EXPECT_NO_THROW_GMX(assigner.finish());
 388     EXPECT_NO_THROW_GMX(options_.finish());
 389
 390     // These should match the contents of selfile.dat
 391     ASSERT_EQ(2U, sel1.size());
 392     EXPECT_STREQ("resname RA RB", sel1[0].selectionText());
 393     EXPECT_STREQ("resname RB RC", sel1[1].selectionText());
 394     ASSERT_EQ(2U, sel2.size());
 395     EXPECT_STREQ("resname RA RB", sel2[0].selectionText());
 396     EXPECT_STREQ("resname RB RC", sel2[1].selectionText());
 397 }
 398
 399
 400 TEST_F(SelectionFileOptionTest, HandlesTwoSelectionOptionsFromSingleFile)
 401 {
 402     gmx::SelectionList sel1;
 403     gmx::SelectionList sel2;
 404     using gmx::SelectionOption;
 405     ASSERT_NO_THROW_GMX(options_.addOption(
 406                                 SelectionOption("sel1").storeVector(&sel1)));
 407     ASSERT_NO_THROW_GMX(options_.addOption(
 408                                 SelectionOption("sel2").storeVector(&sel2)));
 409     setManager();
 410
 411     gmx::OptionsAssigner assigner(&options_);
 412     std::string          value(TestFileManager::getInputFilePath("selfile.dat"));
 413     EXPECT_NO_THROW_GMX(assigner.start());
 414     ASSERT_NO_THROW_GMX(assigner.startOption("sel1"));
 415     EXPECT_NO_THROW_GMX(assigner.finishOption());
 416     ASSERT_NO_THROW_GMX(assigner.startOption("sel2"));
 417     EXPECT_NO_THROW_GMX(assigner.finishOption());
 418     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 419     EXPECT_NO_THROW_GMX(assigner.appendValue(value));
 420     EXPECT_NO_THROW_GMX(assigner.finishOption());
 421     EXPECT_NO_THROW_GMX(assigner.finish());
 422     EXPECT_NO_THROW_GMX(options_.finish());
 423
 424     // These should match the contents of selfile.dat
 425     ASSERT_EQ(1U, sel1.size());
 426     EXPECT_STREQ("resname RA RB", sel1[0].selectionText());
 427     ASSERT_EQ(1U, sel2.size());
 428     EXPECT_STREQ("resname RB RC", sel2[0].selectionText());
 429 }
 430
 431
 432 TEST_F(SelectionFileOptionTest, HandlesRequiredOptionFromFile)
 433 {
 434     gmx::SelectionList sel;
 435     gmx::SelectionList optsel;
 436     using gmx::SelectionOption;
 437     ASSERT_NO_THROW_GMX(options_.addOption(
 438                                 SelectionOption("sel").storeVector(&sel)
 439                                     .multiValue().required()));
 440     ASSERT_NO_THROW_GMX(options_.addOption(
 441                                 SelectionOption("optsel").storeVector(&optsel)
 442                                     .multiValue()));
 443     setManager();
 444
 445     gmx::OptionsAssigner assigner(&options_);
 446     EXPECT_NO_THROW_GMX(assigner.start());
 447     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 448     EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
 449     EXPECT_NO_THROW_GMX(assigner.finishOption());
 450     EXPECT_NO_THROW_GMX(assigner.startOption("optsel"));
 451     EXPECT_NO_THROW_GMX(assigner.finishOption());
 452     EXPECT_NO_THROW_GMX(assigner.finish());
 453     EXPECT_NO_THROW_GMX(options_.finish());
 454     EXPECT_NO_THROW_GMX(manager_.parseRequestedFromString("resname RC RD"));
 455
 456     // These should match the contents of selfile.dat
 457     ASSERT_EQ(2U, sel.size());
 458     EXPECT_STREQ("resname RA RB", sel[0].selectionText());
 459     EXPECT_STREQ("resname RB RC", sel[1].selectionText());
 460     ASSERT_EQ(1U, optsel.size());
 461     EXPECT_STREQ("resname RC RD", optsel[0].selectionText());
 462 }
 463
 464
 465 // TODO: Is this the best possible behavior, or should it error out?
 466 TEST_F(SelectionFileOptionTest, HandlesRequiredOptionFromFileWithOtherOptionSet)
 467 {
 468     gmx::SelectionList sel1;
 469     gmx::SelectionList sel2;
 470     using gmx::SelectionOption;
 471     ASSERT_NO_THROW_GMX(options_.addOption(
 472                                 SelectionOption("sel1").storeVector(&sel1)
 473                                     .multiValue().required()));
 474     ASSERT_NO_THROW_GMX(options_.addOption(
 475                                 SelectionOption("sel2").storeVector(&sel2)
 476                                     .multiValue().required()));
 477     setManager();
 478
 479     gmx::OptionsAssigner assigner(&options_);
 480     EXPECT_NO_THROW_GMX(assigner.start());
 481     EXPECT_NO_THROW_GMX(assigner.startOption("sel1"));
 482     EXPECT_NO_THROW_GMX(assigner.appendValue("resname RC RD"));
 483     EXPECT_NO_THROW_GMX(assigner.finishOption());
 484     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 485     EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
 486     EXPECT_NO_THROW_GMX(assigner.finishOption());
 487     EXPECT_NO_THROW_GMX(assigner.finish());
 488     EXPECT_NO_THROW_GMX(options_.finish());
 489
 490     // These should match the contents of selfile.dat
 491     ASSERT_EQ(2U, sel2.size());
 492     EXPECT_STREQ("resname RA RB", sel2[0].selectionText());
 493     EXPECT_STREQ("resname RB RC", sel2[1].selectionText());
 494     ASSERT_EQ(1U, sel1.size());
 495     EXPECT_STREQ("resname RC RD", sel1[0].selectionText());
 496 }
 497
 498
 499 TEST_F(SelectionFileOptionTest, HandlesTwoRequiredOptionsFromSingleFile)
 500 {
 501     gmx::SelectionList sel1;
 502     gmx::SelectionList sel2;
 503     using gmx::SelectionOption;
 504     ASSERT_NO_THROW_GMX(options_.addOption(
 505                                 SelectionOption("sel1").storeVector(&sel1).required()));
 506     ASSERT_NO_THROW_GMX(options_.addOption(
 507                                 SelectionOption("sel2").storeVector(&sel2).required()));
 508     setManager();
 509
 510     gmx::OptionsAssigner assigner(&options_);
 511     std::string          value(TestFileManager::getInputFilePath("selfile.dat"));
 512     EXPECT_NO_THROW_GMX(assigner.start());
 513     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 514     EXPECT_NO_THROW_GMX(assigner.appendValue(value));
 515     EXPECT_NO_THROW_GMX(assigner.finishOption());
 516     EXPECT_NO_THROW_GMX(assigner.finish());
 517     EXPECT_NO_THROW_GMX(options_.finish());
 518
 519     // These should match the contents of selfile.dat
 520     ASSERT_EQ(1U, sel1.size());
 521     EXPECT_STREQ("resname RA RB", sel1[0].selectionText());
 522     ASSERT_EQ(1U, sel2.size());
 523     EXPECT_STREQ("resname RB RC", sel2[0].selectionText());
 524 }
 525
 526
 527 TEST_F(SelectionFileOptionTest, GivesErrorWithNoFile)
 528 {
 529     gmx::SelectionList sel;
 530     using gmx::SelectionOption;
 531     ASSERT_NO_THROW_GMX(options_.addOption(
 532                                 SelectionOption("sel").storeVector(&sel).multiValue()));
 533     setManager();
 534
 535     gmx::OptionsAssigner assigner(&options_);
 536     EXPECT_NO_THROW_GMX(assigner.start());
 537     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 538     EXPECT_NO_THROW_GMX(assigner.finishOption());
 539     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 540     EXPECT_THROW_GMX(assigner.finishOption(), gmx::InvalidInputError);
 541     EXPECT_NO_THROW_GMX(assigner.finish());
 542     EXPECT_NO_THROW_GMX(options_.finish());
 543 }
 544
 545
 546 TEST_F(SelectionFileOptionTest, GivesErrorWithNonExistentFile)
 547 {
 548     gmx::SelectionList sel;
 549     using gmx::SelectionOption;
 550     ASSERT_NO_THROW_GMX(options_.addOption(
 551                                 SelectionOption("sel").storeVector(&sel).multiValue()));
 552     setManager();
 553
 554     gmx::OptionsAssigner assigner(&options_);
 555     EXPECT_NO_THROW_GMX(assigner.start());
 556     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 557     EXPECT_NO_THROW_GMX(assigner.finishOption());
 558     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 559     // TODO: Should this be changed to an InvalidInputError?
 560     EXPECT_THROW_GMX(assigner.appendValue("nonexistentfile"), gmx::FileIOError);
 561     EXPECT_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")),
 562                      gmx::InvalidInputError);
 563     EXPECT_NO_THROW_GMX(assigner.finishOption());
 564     EXPECT_NO_THROW_GMX(assigner.finish());
 565     EXPECT_NO_THROW_GMX(options_.finish());
 566 }
 567
 568
 569 TEST_F(SelectionFileOptionTest, GivesErrorWithMultipleFiles)
 570 {
 571     gmx::SelectionList sel;
 572     using gmx::SelectionOption;
 573     ASSERT_NO_THROW_GMX(options_.addOption(
 574                                 SelectionOption("sel").storeVector(&sel).multiValue()));
 575     setManager();
 576
 577     gmx::OptionsAssigner assigner(&options_);
 578     EXPECT_NO_THROW_GMX(assigner.start());
 579     ASSERT_NO_THROW_GMX(assigner.startOption("sel"));
 580     EXPECT_NO_THROW_GMX(assigner.finishOption());
 581     ASSERT_NO_THROW_GMX(assigner.startOption("sf"));
 582     EXPECT_NO_THROW_GMX(assigner.appendValue(TestFileManager::getInputFilePath("selfile.dat")));
 583     EXPECT_THROW_GMX(assigner.appendValue("nonexistentfile"), gmx::InvalidInputError);
 584     EXPECT_NO_THROW_GMX(assigner.finishOption());
 585     EXPECT_NO_THROW_GMX(assigner.finish());
 586     EXPECT_NO_THROW_GMX(options_.finish());
 587 }
 588
 589 } // namespace