return allowed_[value];
}
+Variant EnumOptionStorage::normalizeValue(const int &value) const
+{
+ return Variant::create<std::string>(formatSingleValue(value));
+}
+
void EnumOptionStorage::initConverter(ConverterType *converter)
{
converter->addConverter<std::string>(
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012,2013,2014,2015,2016, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2013,2014,2015,2016,2017, 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.
virtual std::string typeString() const { return "enum"; }
virtual std::string formatExtraDescription() const;
virtual std::string formatSingleValue(const int &value) const;
+ virtual Variant normalizeValue(const int &value) const;
//! \copydoc EnumOptionInfo::allowedValues()
const std::vector<std::string> &allowedValues() const { return allowed_; }
std::vector<Variant> result;
for (const auto &value : values)
{
- result.push_back(
- Variant::create<T>(
- processValue(converter_.convert(value))));
+ result.push_back(normalizeValue(converter_.convert(value)));
}
return result;
}
{
return value;
}
+ /*! \brief
+ * Converts a single value to normalized type.
+ *
+ * \param[in] value Value after conversion.
+ * \returns Value to store for the option.
+ *
+ * This can be overridden to serialize a different type than `T`
+ * when using the option with KeyValueTreeObject.
+ */
+ virtual Variant normalizeValue(const T &value) const
+ {
+ return Variant::create<T>(processValue(value));
+ }
private:
virtual void convertValue(const Variant &variant)
{
result.push_back(Variant::create<T>(value));
}
- return result;
+ return normalizeValues(result);
}
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <Bool Name="a">true</Bool>
+ </Object>
+</ReferenceData>
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <Real Name="a">1.5</Real>
+ </Object>
+</ReferenceData>
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <String Name="a">foo</String>
+ </Object>
+</ReferenceData>
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <String Name="a">foo</String>
+ </Object>
+</ReferenceData>
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <Real Name="a">1.5</Real>
+ </Object>
+</ReferenceData>
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <Int64 Name="a">2</Int64>
+ </Object>
+</ReferenceData>
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <Int Name="a">2</Int>
+ </Object>
+</ReferenceData>
--- /dev/null
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="referencedata.xsl"?>
+<ReferenceData>
+ <Object Name="Input"></Object>
+ <Object Name="Adjusted">
+ <String Name="a">s</String>
+ </Object>
+</ReferenceData>
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2016, by the GROMACS development team, led by
+ * Copyright (c) 2016,2017, 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.
runTest();
}
+/********************************************************************
+ * Support for different option types
+ */
+
+class TreeValueSupportTest : public ::testing::Test
+{
+ public:
+ void runTest()
+ {
+ gmx::test::TestReferenceData refdata;
+ gmx::test::TestReferenceChecker checker(refdata.rootChecker());
+ gmx::KeyValueTreeObject tree(builder_.build());
+ checker.checkKeyValueTreeObject(tree, "Input");
+ ASSERT_NO_THROW_GMX(tree = gmx::adjustKeyValueTreeFromOptions(tree, options_));
+ checker.checkKeyValueTreeObject(tree, "Adjusted");
+ }
+
+ gmx::Options options_;
+ gmx::KeyValueTreeBuilder builder_;
+};
+
+TEST_F(TreeValueSupportTest, SupportsBooleanOption)
+{
+ options_.addOption(gmx::BooleanOption("a").defaultValue(true));
+ runTest();
+}
+
+TEST_F(TreeValueSupportTest, SupportsIntegerOption)
+{
+ options_.addOption(gmx::IntegerOption("a").defaultValue(2));
+ runTest();
+}
+
+TEST_F(TreeValueSupportTest, SupportsInt64Option)
+{
+ options_.addOption(gmx::Int64Option("a").defaultValue(2));
+ runTest();
+}
+
+TEST_F(TreeValueSupportTest, SupportsStringOption)
+{
+ options_.addOption(gmx::StringOption("a").defaultValue("s"));
+ runTest();
+}
+
+TEST_F(TreeValueSupportTest, SupportsFloatOption)
+{
+ options_.addOption(gmx::FloatOption("a").defaultValue(1.5));
+ runTest();
+}
+
+TEST_F(TreeValueSupportTest, SupportsDoubleOption)
+{
+ options_.addOption(gmx::DoubleOption("a").defaultValue(1.5));
+ runTest();
+}
+
+TEST_F(TreeValueSupportTest, SupportsEnumIntOption)
+{
+ const char *const values[] = {"foo", "bar"};
+ options_.addOption(gmx::EnumIntOption("a").enumValue(values).defaultValue(0));
+ runTest();
+}
+
+//! Enum for testing EnumOption.
+enum class TestEnum
+{
+ Foo, Bar
+};
+
+TEST_F(TreeValueSupportTest, SupportsEnumOption)
+{
+ const char *const values[] = {"foo", "bar"};
+ options_.addOption(gmx::EnumOption<TestEnum>("a").enumValue(values)
+ .defaultValue(TestEnum::Foo));
+ runTest();
+}
+
} // namespace
#include <gtest/gtest.h>
+#include "gromacs/utility/inmemoryserializer.h"
#include "gromacs/utility/iserializer.h"
#include "gromacs/utility/keyvaluetreebuilder.h"
namespace
{
-class RefDataWriteSerializer : public gmx::ISerializer
+class RefDataSerializer : public gmx::ISerializer
{
public:
- RefDataWriteSerializer(gmx::test::TestReferenceChecker *parentChecker,
- const char *id)
+ RefDataSerializer(gmx::test::TestReferenceChecker *parentChecker,
+ const char *id)
: checker_(parentChecker->checkCompound("SerializedData", id))
{
}
gmx::test::TestReferenceChecker checker_;
};
-class RefDataReadSerializer : public gmx::ISerializer
-{
- public:
- RefDataReadSerializer(gmx::test::TestReferenceChecker *parentChecker,
- const char *id)
- : checker_(parentChecker->checkCompound("SerializedData", id))
- {
- }
-
- virtual bool reading() const { return true; }
-
- virtual void doUChar(unsigned char *value)
- {
- *value = checker_.readUChar(nullptr);
- }
- virtual void doInt(int *value)
- {
- *value = checker_.readInteger(nullptr);
- }
- virtual void doInt64(gmx_int64_t *value)
- {
- *value = checker_.readInt64(nullptr);
- }
- virtual void doFloat(float *value)
- {
- *value = checker_.readFloat(nullptr);
- }
- virtual void doDouble(double *value)
- {
- *value = checker_.readDouble(nullptr);
- }
- virtual void doString(std::string *value)
- {
- *value = checker_.readString(nullptr);
- }
-
- private:
- gmx::test::TestReferenceChecker checker_;
-};
-
class KeyValueTreeSerializerTest : public ::testing::Test
{
public:
gmx::test::TestReferenceChecker checker(data.rootChecker());
checker.checkKeyValueTreeObject(input, "Input");
{
- RefDataWriteSerializer serializer(&checker, "Stream");
+ RefDataSerializer serializer(&checker, "Stream");
gmx::serializeKeyValueTree(input, &serializer);
}
+ std::vector<char> buffer = serializeTree(input);
{
- RefDataReadSerializer serializer(&checker, "Stream");
+ gmx::InMemoryDeserializer deserializer(buffer);
gmx::KeyValueTreeObject output
- = gmx::deserializeKeyValueTree(&serializer);
+ = gmx::deserializeKeyValueTree(&deserializer);
checker.checkKeyValueTreeObject(output, "Input");
}
}
gmx::KeyValueTreeBuilder builder_;
+
+ private:
+ std::vector<char> serializeTree(const gmx::KeyValueTreeObject &tree)
+ {
+ gmx::InMemorySerializer serializer;
+ gmx::serializeKeyValueTree(tree, &serializer);
+ return serializer.finishAndGetBuffer();
+ }
};
TEST_F(KeyValueTreeSerializerTest, EmptyTree)
{
checkInteger(variant.cast<int>(), id);
}
+ else if (variant.isType<gmx_int64_t>())
+ {
+ checkInt64(variant.cast<gmx_int64_t>(), id);
+ }
else if (variant.isType<float>())
{
checkFloat(variant.cast<float>(), id);
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff