2 * This file is part of the GROMACS molecular simulation package.
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.
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.
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.
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.
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.
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.
37 * Tests proper handling of option storage.
39 * These tests check that methods in storage objects are called properly in all
40 * situations, and also that the OptionStorageTemplate class behaves properly.
42 * \author Teemu Murtola <teemu.murtola@gmail.com>
43 * \ingroup module_options
48 #include <gmock/gmock.h>
49 #include <gtest/gtest.h>
51 #include "gromacs/options/abstractoption.h"
52 #include "gromacs/options/options.h"
53 #include "gromacs/options/optionstoragetemplate.h"
54 #include "gromacs/options/optionsassigner.h"
55 #include "gromacs/utility/exceptions.h"
57 #include "testutils/testasserts.h"
58 #include "testutils/testexceptions.h"
64 class MockOptionStorage;
66 class MockOptionInfo : public gmx::OptionInfo
69 //! Creates an option info object for the given option.
70 explicit MockOptionInfo(MockOptionStorage *option);
72 MockOptionStorage &option();
76 * Mock implementation of an option storage class for unit testing.
78 * Provides facilities for checking that correct methods are called, and for
79 * controlling how they add values using the base class methods.
81 * \ingroup module_options
83 class MockOptionStorage : public gmx::OptionStorageTemplate<std::string>
87 * Initializes the storage from option settings.
89 * \param[in] settings Storage settings.
91 MockOptionStorage(const MockOption &settings);
94 * Calls addValue("dummy") in the base class.
100 // using MyBase::markAsSet;
101 // using MyBase::addValue;
102 // using MyBase::commitValues;
103 // "using" is correct but MSVC gives error C2248. Workaround:
108 void addValue(const std::string &value)
110 MyBase::addValue(value);
114 MyBase::commitValues();
117 virtual gmx::OptionInfo &optionInfo() { return info_; }
118 // These are not used.
119 virtual const char *typeString() const { return "mock"; }
120 virtual std::string formatSingleValue(const std::string & /*value*/) const
125 MOCK_METHOD1(convertValue, void(const std::string &value));
126 MOCK_METHOD1(processSetValues, void(ValueList *values));
127 MOCK_METHOD0(processAll, void());
130 MockOptionInfo info_;
134 * Specifies an option that has a mock storage object for unit testing.
136 * \ingroup module_options
138 class MockOption : public gmx::OptionTemplate<std::string, MockOption>
141 //! OptionInfo subclass corresponding to this option type.
142 typedef MockOptionInfo InfoType;
144 //! Initializes an option with the given name.
145 explicit MockOption(const char *name)
151 virtual gmx::AbstractOptionStoragePointer createStorage() const
153 return gmx::AbstractOptionStoragePointer(new MockOptionStorage(*this));
157 MockOptionStorage::MockOptionStorage(const MockOption &settings)
158 : MyBase(settings), info_(this)
161 using ::testing::Invoke;
162 using ::testing::WithArg;
163 ON_CALL(*this, convertValue(_))
164 .WillByDefault(WithArg<0>(Invoke(this, &MockOptionStorage::addValue)));
167 MockOptionInfo::MockOptionInfo(MockOptionStorage *option)
168 : gmx::OptionInfo(option)
172 MockOptionStorage &MockOptionInfo::option()
174 return static_cast<MockOptionStorage &>(gmx::OptionInfo::option());
178 * Tests that finish() can set a required option even if the user has not
181 TEST(AbstractOptionStorageTest, HandlesSetInFinish)
183 gmx::Options options(NULL, NULL);
184 std::vector<std::string> values;
185 MockOptionInfo *info = options.addOption(
186 MockOption("name").required().storeVector(&values));
187 MockOptionStorage *mock = &info->option();
189 ::testing::InSequence dummy;
190 using ::testing::DoAll;
191 using ::testing::InvokeWithoutArgs;
192 EXPECT_CALL(*mock, processAll())
193 .WillOnce(DoAll(InvokeWithoutArgs(mock, &MockOptionStorage::markAsSet),
194 InvokeWithoutArgs(mock, &MockOptionStorage::addDummyValue),
195 InvokeWithoutArgs(mock, &MockOptionStorage::commitValues)));
198 gmx::OptionsAssigner assigner(&options);
199 EXPECT_NO_THROW_GMX(assigner.start());
200 EXPECT_NO_THROW_GMX(assigner.finish());
201 EXPECT_NO_THROW_GMX(options.finish());
203 ASSERT_EQ(1U, values.size());
204 EXPECT_EQ("dummy", values[0]);
208 * Tests that storage works if the storage object does not add a value in a
209 * call to appendValue().
211 TEST(AbstractOptionStorageTest, HandlesValueRemoval)
213 gmx::Options options(NULL, NULL);
214 std::vector<std::string> values;
215 MockOptionInfo *info = options.addOption(
216 MockOption("name").storeVector(&values).multiValue());
217 MockOptionStorage *mock = &info->option();
219 ::testing::InSequence dummy;
220 using ::testing::ElementsAre;
221 using ::testing::Pointee;
222 using ::testing::Return;
223 EXPECT_CALL(*mock, convertValue("a"));
224 EXPECT_CALL(*mock, convertValue("b"))
226 EXPECT_CALL(*mock, convertValue("c"));
227 EXPECT_CALL(*mock, processSetValues(Pointee(ElementsAre("a", "c"))));
228 EXPECT_CALL(*mock, processAll());
231 gmx::OptionsAssigner assigner(&options);
232 EXPECT_NO_THROW_GMX(assigner.start());
233 ASSERT_NO_THROW_GMX(assigner.startOption("name"));
234 EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
235 EXPECT_NO_THROW_GMX(assigner.appendValue("b"));
236 EXPECT_NO_THROW_GMX(assigner.appendValue("c"));
237 EXPECT_NO_THROW_GMX(assigner.finishOption());
238 EXPECT_NO_THROW_GMX(assigner.finish());
239 EXPECT_NO_THROW_GMX(options.finish());
241 ASSERT_EQ(2U, values.size());
242 EXPECT_EQ("a", values[0]);
243 EXPECT_EQ("c", values[1]);
247 * Tests that storage works if the storage object adds more than one value in
248 * one call to appendValue().
250 TEST(AbstractOptionStorageTest, HandlesValueAddition)
252 gmx::Options options(NULL, NULL);
253 std::vector<std::string> values;
254 MockOptionInfo *info = options.addOption(
255 MockOption("name").storeVector(&values).multiValue());
256 MockOptionStorage *mock = &info->option();
258 ::testing::InSequence dummy;
259 using ::testing::DoAll;
260 using ::testing::ElementsAre;
261 using ::testing::InvokeWithoutArgs;
262 using ::testing::Pointee;
263 EXPECT_CALL(*mock, convertValue("a"));
264 EXPECT_CALL(*mock, convertValue("b"))
265 .WillOnce(DoAll(InvokeWithoutArgs(mock, &MockOptionStorage::addDummyValue),
266 InvokeWithoutArgs(mock, &MockOptionStorage::addDummyValue)));
267 EXPECT_CALL(*mock, processSetValues(Pointee(ElementsAre("a", "dummy", "dummy"))));
268 EXPECT_CALL(*mock, processAll());
271 gmx::OptionsAssigner assigner(&options);
272 EXPECT_NO_THROW_GMX(assigner.start());
273 ASSERT_NO_THROW_GMX(assigner.startOption("name"));
274 EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
275 EXPECT_NO_THROW_GMX(assigner.appendValue("b"));
276 EXPECT_NO_THROW_GMX(assigner.finishOption());
277 EXPECT_NO_THROW_GMX(assigner.finish());
278 EXPECT_NO_THROW_GMX(options.finish());
280 ASSERT_EQ(3U, values.size());
281 EXPECT_EQ("a", values[0]);
282 EXPECT_EQ("dummy", values[1]);
283 EXPECT_EQ("dummy", values[2]);
287 * Tests that storage works if the storage object adds more than one value in
288 * one call to appendValue(), and this results in too many values.
290 TEST(AbstractOptionStorageTest, HandlesTooManyValueAddition)
292 gmx::Options options(NULL, NULL);
293 std::vector<std::string> values;
294 MockOptionInfo *info = options.addOption(
295 MockOption("name").storeVector(&values).valueCount(2));
296 MockOptionStorage *mock = &info->option();
298 ::testing::InSequence dummy;
299 using ::testing::DoAll;
300 using ::testing::ElementsAre;
301 using ::testing::InvokeWithoutArgs;
302 using ::testing::Pointee;
303 EXPECT_CALL(*mock, convertValue("a"));
304 EXPECT_CALL(*mock, convertValue("b"))
305 .WillOnce(DoAll(InvokeWithoutArgs(mock, &MockOptionStorage::addDummyValue),
306 InvokeWithoutArgs(mock, &MockOptionStorage::addDummyValue)));
307 EXPECT_CALL(*mock, processAll());
310 gmx::OptionsAssigner assigner(&options);
311 EXPECT_NO_THROW_GMX(assigner.start());
312 ASSERT_NO_THROW_GMX(assigner.startOption("name"));
313 EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
314 EXPECT_THROW_GMX(assigner.appendValue("b"), gmx::InvalidInputError);
315 EXPECT_NO_THROW_GMX(assigner.finishOption());
316 EXPECT_NO_THROW_GMX(assigner.finish());
317 EXPECT_NO_THROW_GMX(options.finish());
319 ASSERT_TRUE(values.empty());
323 * Tests that the storage object is properly invoked even if no output values
324 * should be produced.
326 TEST(AbstractOptionStorageTest, AllowsEmptyValues)
328 gmx::Options options(NULL, NULL);
329 std::vector<std::string> values;
330 MockOptionInfo *info = options.addOption(
331 MockOption("name").storeVector(&values).valueCount(0));
332 MockOptionStorage *mock = &info->option();
334 ::testing::InSequence dummy;
335 using ::testing::DoAll;
336 using ::testing::ElementsAre;
337 using ::testing::Pointee;
338 using ::testing::Return;
339 EXPECT_CALL(*mock, convertValue("a"))
341 EXPECT_CALL(*mock, processSetValues(Pointee(ElementsAre())));
342 EXPECT_CALL(*mock, processAll());
345 gmx::OptionsAssigner assigner(&options);
346 EXPECT_NO_THROW_GMX(assigner.start());
347 EXPECT_NO_THROW_GMX(assigner.startOption("name"));
348 EXPECT_NO_THROW_GMX(assigner.appendValue("a"));
349 EXPECT_NO_THROW_GMX(assigner.finishOption());
350 EXPECT_NO_THROW_GMX(assigner.finish());
351 EXPECT_NO_THROW_GMX(options.finish());
353 ASSERT_EQ(0U, values.size());