Apply clang-format to source tree

[alexxy/gromacs.git] / src / gromacs / options / tests / optionsassigner.cpp

diff --git a/src/gromacs/options/tests/optionsassigner.cpp b/src/gromacs/options/tests/optionsassigner.cpp
index ad1df797612571add31c77e5655a308812900ecf..9d6d7ca1dc2282e510ee8a83e11542588ddb6c7a 100644 (file)
--- a/src/gromacs/options/tests/optionsassigner.cpp
+++ b/src/gromacs/options/tests/optionsassigner.cpp
@@ -1,7 +1,8 @@
 /*
  * This file is part of the GROMACS molecular simulation package.
  *
- * Copyright (c) 2010,2011,2012,2013,2014,2015,2016,2017,2019, by the GROMACS development team, led by
+ * Copyright (c) 2010-2017, The GROMACS development team.
+ * Copyright (c) 2019, by the GROMACS development team, led by
  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
  * and including many others, as listed in the AUTHORS file in the
  * top-level source directory and at http://www.gromacs.org.
@@ -75,8 +76,7 @@ TEST(OptionsAssignerTest, HandlesMissingRequiredParameter)
     gmx::Options options;
     int          value = 0;
     using gmx::IntegerOption;
-    ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p").store(&value).required()));
+    ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value).required()));
 
     EXPECT_THROW(options.finish(), gmx::InvalidInputError);
 }
@@ -86,9 +86,7 @@ TEST(OptionsAssignerTest, HandlesRequiredParameterWithDefaultValue)
     gmx::Options options;
     int          value = 0;
     using gmx::IntegerOption;
-    ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p").store(&value).required()
-                                .defaultValue(1)));
+    ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value).required().defaultValue(1)));
 
     EXPECT_NO_THROW(options.finish());
     EXPECT_EQ(1, value);
@@ -101,9 +99,7 @@ TEST(OptionsAssignerTest, HandlesInvalidMultipleParameter)
     bool             bIsSet = false;
     using gmx::IntegerOption;
     ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p")
-                                .storeVector(&values).storeIsSet(&bIsSet)
-                                .multiValue()));
+            IntegerOption("p").storeVector(&values).storeIsSet(&bIsSet).multiValue()));
 
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
@@ -126,9 +122,7 @@ TEST(OptionsAssignerTest, HandlesMultipleParameter)
     bool             bIsSet = false;
     using gmx::IntegerOption;
     ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p")
-                                .storeVector(&values).storeIsSet(&bIsSet)
-                                .allowMultiple()));
+            IntegerOption("p").storeVector(&values).storeIsSet(&bIsSet).allowMultiple()));
 
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW_GMX(assigner.start());
@@ -190,8 +184,8 @@ TEST(OptionsAssignerTest, HandlesExtraValue)
 TEST(OptionsAssignerTest, HandlesGroups)
 {
     gmx::Options            options;
-    gmx::IOptionsContainer &group1 = options.addGroup();
-    gmx::IOptionsContainer &group2 = options.addGroup();
+    gmx::IOptionsContainer& group1 = options.addGroup();
+    gmx::IOptionsContainer& group2 = options.addGroup();
     int                     value  = 3;
     int                     value1 = 1;
     int                     value2 = 2;
@@ -361,7 +355,7 @@ TEST(OptionsAssignerBooleanTest, HandlesBooleanWithPrefixAndValue)
         EXPECT_NO_THROW(assigner.finish());
         EXPECT_TRUE(value);
     }
-    catch (const gmx::InvalidInputError &)
+    catch (const gmx::InvalidInputError&)
     {
     }
 }
@@ -437,8 +431,7 @@ TEST(OptionsAssignerIntegerTest, HandlesOverflow)
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
     ASSERT_NO_THROW(assigner.startOption("p"));
-    std::string overflowValue(
-            gmx::formatString("%d0000", std::numeric_limits<int>::max()));
+    std::string overflowValue(gmx::formatString("%d0000", std::numeric_limits<int>::max()));
     EXPECT_THROW(assigner.appendValue(overflowValue), gmx::InvalidInputError);
     EXPECT_NO_THROW(assigner.finishOption());
     EXPECT_NO_THROW(assigner.finish());
@@ -452,8 +445,7 @@ TEST(OptionsAssignerIntegerTest, StoresDefaultValue)
     gmx::Options options;
     int          value = -1;
     using gmx::IntegerOption;
-    ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p").store(&value).defaultValue(2)));
+    ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value).defaultValue(2)));
     EXPECT_EQ(2, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -469,8 +461,7 @@ TEST(OptionsAssignerIntegerTest, StoresDefaultValueIfSet)
     gmx::Options options;
     int          value = -1;
     using gmx::IntegerOption;
-    ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p").store(&value).defaultValueIfSet(2)));
+    ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value).defaultValueIfSet(2)));
     EXPECT_EQ(-1, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -488,8 +479,7 @@ TEST(OptionsAssignerIntegerTest, HandlesDefaultValueIfSetWhenNotSet)
     gmx::Options options;
     int          value = -1;
     using gmx::IntegerOption;
-    ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p").store(&value).defaultValueIfSet(2)));
+    ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(&value).defaultValueIfSet(2)));
     EXPECT_EQ(-1, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -505,9 +495,8 @@ TEST(OptionsAssignerIntegerTest, HandlesBothDefaultValues)
     gmx::Options options;
     int          value = -1;
     using gmx::IntegerOption;
-    ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p").store(&value)
-                                .defaultValue(1).defaultValueIfSet(2)));
+    ASSERT_NO_THROW(
+            options.addOption(IntegerOption("p").store(&value).defaultValue(1).defaultValueIfSet(2)));
     EXPECT_EQ(1, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -522,11 +511,10 @@ TEST(OptionsAssignerIntegerTest, HandlesBothDefaultValues)
 
 TEST(OptionsAssignerIntegerTest, StoresToVector)
 {
-    gmx::Options          options;
-    std::vector<int>      values;
+    gmx::Options     options;
+    std::vector<int> values;
     using gmx::IntegerOption;
-    ASSERT_NO_THROW(options.addOption(
-                            IntegerOption("p").storeVector(&values).multiValue()));
+    ASSERT_NO_THROW(options.addOption(IntegerOption("p").storeVector(&values).multiValue()));
 
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
@@ -547,7 +535,7 @@ TEST(OptionsAssignerIntegerTest, StoresToVector)
 TEST(OptionsAssignerIntegerTest, HandlesVectors)
 {
     gmx::Options options;
-    int          vec[3] = {0, 0, 0};
+    int          vec[3] = { 0, 0, 0 };
     using gmx::IntegerOption;
     ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec).vector()));
 
@@ -569,7 +557,7 @@ TEST(OptionsAssignerIntegerTest, HandlesVectors)
 TEST(OptionsAssignerIntegerTest, HandlesVectorFromSingleValue)
 {
     gmx::Options options;
-    int          vec[3] = {0, 0, 0};
+    int          vec[3] = { 0, 0, 0 };
     using gmx::IntegerOption;
     ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec).vector()));
 
@@ -589,7 +577,7 @@ TEST(OptionsAssignerIntegerTest, HandlesVectorFromSingleValue)
 TEST(OptionsAssignerIntegerTest, HandlesVectorsWithDefaultValue)
 {
     gmx::Options options;
-    int          vec[3] = {3, 2, 1};
+    int          vec[3] = { 3, 2, 1 };
     using gmx::IntegerOption;
     ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec).vector()));
 
@@ -602,8 +590,8 @@ TEST(OptionsAssignerIntegerTest, HandlesVectorsWithDefaultValue)
 
 TEST(OptionsAssignerIntegerTest, HandlesVectorsWithDefaultValueWithInvalidAssignment)
 {
-    gmx::Options     options;
-    int              vec[3] = {3, 2, 1};
+    gmx::Options options;
+    int          vec[3] = { 3, 2, 1 };
     using gmx::IntegerOption;
     ASSERT_NO_THROW(options.addOption(IntegerOption("p").store(vec).vector()));
 
@@ -682,10 +670,10 @@ TEST(OptionsAssignerDoubleTest, HandlesEmptyValue)
 
 TEST(OptionsAssignerDoubleTest, HandlesPreSetScaleValue)
 {
-    gmx::Options           options;
-    double                 value = 1.0;
+    gmx::Options options;
+    double       value = 1.0;
     using gmx::DoubleOption;
-    gmx::DoubleOptionInfo *info = options.addOption(DoubleOption("p").store(&value));
+    gmx::DoubleOptionInfo* info = options.addOption(DoubleOption("p").store(&value));
     EXPECT_NO_THROW(info->setScaleFactor(10));
 
     gmx::OptionsAssigner assigner(&options);
@@ -701,12 +689,12 @@ TEST(OptionsAssignerDoubleTest, HandlesPreSetScaleValue)
 
 TEST(OptionsAssignerDoubleTest, HandlesPostSetScaleValue)
 {
-    gmx::Options           options;
-    double                 value = 1.0;
+    gmx::Options options;
+    double       value = 1.0;
     using gmx::DoubleOption;
-    gmx::DoubleOptionInfo *info = options.addOption(DoubleOption("p").store(&value));
+    gmx::DoubleOptionInfo* info = options.addOption(DoubleOption("p").store(&value));
 
-    gmx::OptionsAssigner   assigner(&options);
+    gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
     ASSERT_NO_THROW(assigner.startOption("p"));
     ASSERT_NO_THROW(assigner.appendValue("2.7"));
@@ -724,12 +712,12 @@ TEST(OptionsAssignerDoubleTest, HandlesPostSetScaleValue)
  */
 
 //! Set of allowed values for enum option tests.
-const char *const c_allowed[] = { "none", "test", "value" };
+const char* const c_allowed[] = { "none", "test", "value" };
 
 TEST(OptionsAssignerStringTest, StoresSingleValue)
 {
-    gmx::Options           options;
-    std::string            value;
+    gmx::Options options;
+    std::string  value;
     using gmx::StringOption;
     ASSERT_NO_THROW(options.addOption(StringOption("p").store(&value)));
 
@@ -746,12 +734,10 @@ TEST(OptionsAssignerStringTest, StoresSingleValue)
 
 TEST(OptionsAssignerStringTest, HandlesEnumValue)
 {
-    gmx::Options           options;
-    std::string            value;
+    gmx::Options options;
+    std::string  value;
     using gmx::StringOption;
-    ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(StringOption("p").store(&value).enumValue(c_allowed)));
 
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
@@ -766,13 +752,12 @@ TEST(OptionsAssignerStringTest, HandlesEnumValue)
 
 TEST(OptionsAssignerStringTest, HandlesEnumValueFromNullTerminatedArray)
 {
-    gmx::Options           options;
-    std::string            value;
-    const char * const     allowed[] = { "none", "test", "value", nullptr };
+    gmx::Options      options;
+    std::string       value;
+    const char* const allowed[] = { "none", "test", "value", nullptr };
     using gmx::StringOption;
     ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").store(&value)
-                                .enumValueFromNullTerminatedArray(allowed)));
+            StringOption("p").store(&value).enumValueFromNullTerminatedArray(allowed)));
 
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
@@ -787,12 +772,10 @@ TEST(OptionsAssignerStringTest, HandlesEnumValueFromNullTerminatedArray)
 
 TEST(OptionsAssignerStringTest, HandlesIncorrectEnumValue)
 {
-    gmx::Options           options;
-    std::string            value;
+    gmx::Options options;
+    std::string  value;
     using gmx::StringOption;
-    ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(StringOption("p").store(&value).enumValue(c_allowed)));
 
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
@@ -802,12 +785,10 @@ TEST(OptionsAssignerStringTest, HandlesIncorrectEnumValue)
 
 TEST(OptionsAssignerStringTest, CompletesEnumValue)
 {
-    gmx::Options           options;
-    std::string            value;
+    gmx::Options options;
+    std::string  value;
     using gmx::StringOption;
-    ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(StringOption("p").store(&value).enumValue(c_allowed)));
 
     gmx::OptionsAssigner assigner(&options);
     EXPECT_NO_THROW(assigner.start());
@@ -822,12 +803,10 @@ TEST(OptionsAssignerStringTest, CompletesEnumValue)
 
 TEST(OptionsAssignerStringTest, HandlesEnumWithNoValue)
 {
-    gmx::Options           options;
-    std::string            value;
+    gmx::Options options;
+    std::string  value;
     using gmx::StringOption;
-    ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(StringOption("p").store(&value).enumValue(c_allowed)));
     EXPECT_TRUE(value.empty());
 
     ASSERT_NO_THROW(options.finish());
@@ -837,12 +816,11 @@ TEST(OptionsAssignerStringTest, HandlesEnumWithNoValue)
 
 TEST(OptionsAssignerStringTest, HandlesEnumDefaultValue)
 {
-    gmx::Options           options;
-    std::string            value;
+    gmx::Options options;
+    std::string  value;
     using gmx::StringOption;
     ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").store(&value)
-                                .enumValue(c_allowed).defaultValue("test")));
+            StringOption("p").store(&value).enumValue(c_allowed).defaultValue("test")));
     EXPECT_EQ("test", value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -855,12 +833,10 @@ TEST(OptionsAssignerStringTest, HandlesEnumDefaultValue)
 
 TEST(OptionsAssignerStringTest, HandlesEnumDefaultValueFromVariable)
 {
-    gmx::Options           options;
-    std::string            value("test");
+    gmx::Options options;
+    std::string  value("test");
     using gmx::StringOption;
-    ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(StringOption("p").store(&value).enumValue(c_allowed)));
     EXPECT_EQ("test", value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -879,8 +855,7 @@ TEST(OptionsAssignerStringTest, HandlesEnumDefaultValueFromVector)
     value.emplace_back("value");
     using gmx::StringOption;
     ASSERT_NO_THROW(options.addOption(
-                            StringOption("p").storeVector(&value).valueCount(2)
-                                .enumValue(c_allowed)));
+            StringOption("p").storeVector(&value).valueCount(2).enumValue(c_allowed)));
     ASSERT_EQ(2U, value.size());
     EXPECT_EQ("test", value[0]);
     EXPECT_EQ("value", value[1]);
@@ -911,12 +886,10 @@ enum TestEnum
 
 TEST(OptionsAssignerEnumTest, StoresSingleValue)
 {
-    gmx::Options           options;
-    TestEnum               value     = etestNone;
+    gmx::Options options;
+    TestEnum     value = etestNone;
     using gmx::EnumOption;
-    ASSERT_NO_THROW(options.addOption(
-                            EnumOption<TestEnum>("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(EnumOption<TestEnum>("p").store(&value).enumValue(c_allowed)));
     EXPECT_EQ(etestNone, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -932,12 +905,11 @@ TEST(OptionsAssignerEnumTest, StoresSingleValue)
 
 TEST(OptionsAssignerEnumTest, StoresVectorValues)
 {
-    gmx::Options           options;
-    std::vector<TestEnum>  values;
+    gmx::Options          options;
+    std::vector<TestEnum> values;
     using gmx::EnumOption;
     ASSERT_NO_THROW(options.addOption(
-                            EnumOption<TestEnum>("p").storeVector(&values)
-                                .multiValue().enumValue(c_allowed)));
+            EnumOption<TestEnum>("p").storeVector(&values).multiValue().enumValue(c_allowed)));
     EXPECT_TRUE(values.empty());
 
     gmx::OptionsAssigner assigner(&options);
@@ -956,12 +928,10 @@ TEST(OptionsAssignerEnumTest, StoresVectorValues)
 
 TEST(OptionsAssignerEnumTest, HandlesInitialValueOutOfRange)
 {
-    gmx::Options           options;
-    TestEnum               value     = etestNR;
+    gmx::Options options;
+    TestEnum     value = etestNR;
     using gmx::EnumOption;
-    ASSERT_NO_THROW(options.addOption(
-                            EnumOption<TestEnum>("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(EnumOption<TestEnum>("p").store(&value).enumValue(c_allowed)));
     EXPECT_EQ(etestNR, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -974,12 +944,11 @@ TEST(OptionsAssignerEnumTest, HandlesInitialValueOutOfRange)
 
 TEST(OptionsAssignerEnumTest, HandlesEnumDefaultValue)
 {
-    gmx::Options           options;
-    TestEnum               value     = etestNone;
+    gmx::Options options;
+    TestEnum     value = etestNone;
     using gmx::EnumOption;
     ASSERT_NO_THROW(options.addOption(
-                            EnumOption<TestEnum>("p").store(&value)
-                                .enumValue(c_allowed).defaultValue(etestTest)));
+            EnumOption<TestEnum>("p").store(&value).enumValue(c_allowed).defaultValue(etestTest)));
     EXPECT_EQ(etestTest, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -992,12 +961,10 @@ TEST(OptionsAssignerEnumTest, HandlesEnumDefaultValue)
 
 TEST(OptionsAssignerEnumTest, HandlesEnumDefaultValueFromVariable)
 {
-    gmx::Options           options;
-    TestEnum               value     = etestTest;
+    gmx::Options options;
+    TestEnum     value = etestTest;
     using gmx::EnumOption;
-    ASSERT_NO_THROW(options.addOption(
-                            EnumOption<TestEnum>("p").store(&value)
-                                .enumValue(c_allowed)));
+    ASSERT_NO_THROW(options.addOption(EnumOption<TestEnum>("p").store(&value).enumValue(c_allowed)));
     EXPECT_EQ(etestTest, value);
 
     gmx::OptionsAssigner assigner(&options);
@@ -1010,14 +977,13 @@ TEST(OptionsAssignerEnumTest, HandlesEnumDefaultValueFromVariable)
 
 TEST(OptionsAssignerEnumTest, HandlesEnumDefaultValueFromVector)
 {
-    gmx::Options             options;
-    std::vector<TestEnum>    value;
+    gmx::Options          options;
+    std::vector<TestEnum> value;
     value.push_back(etestNone);
     value.push_back(etestTest);
     using gmx::EnumOption;
     ASSERT_NO_THROW(options.addOption(
-                            EnumOption<TestEnum>("p").storeVector(&value).valueCount(2)
-                                .enumValue(c_allowed)));
+            EnumOption<TestEnum>("p").storeVector(&value).valueCount(2).enumValue(c_allowed)));
     ASSERT_EQ(2U, value.size());
     EXPECT_EQ(etestNone, value[0]);
     EXPECT_EQ(etestTest, value[1]);