diff --git a/Fit/Minimizer/AlgorithmNames.h b/Fit/Minimizer/AlgorithmNames.h
index 7731e69341a0217bdb5406ea06d229cb0ca4990b..d6863eda6b1e1db02d72706618fb4157f4e3c9aa 100644
--- a/Fit/Minimizer/AlgorithmNames.h
+++ b/Fit/Minimizer/AlgorithmNames.h
@@ -16,6 +16,8 @@
 #ifndef ALGORITHMNAMES_H
 #define ALGORITHMNAMES_H
 
+#include <string>
+
 namespace MinimizerNames {
 
 const std::string Minuit = "MinuitMinimizer";
diff --git a/Fit/Minimizer/BasicMinimizer.cpp b/Fit/Minimizer/BasicMinimizer.cpp
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..3c301b137100c1da4f92bd1a1d6e580f27acc4fa 100644
--- a/Fit/Minimizer/BasicMinimizer.cpp
+++ b/Fit/Minimizer/BasicMinimizer.cpp
@@ -0,0 +1,39 @@
+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/Minimizer/BasicMinimizer.cpp
+//! @brief     Implements class BasicMinimizer.
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#include "BasicMinimizer.h"
+
+BasicMinimizer::BasicMinimizer(const std::string &minimizerName, const std::string &algorithmName)
+    : m_minimizerName(minimizerName)
+    , m_algorithmName(algorithmName)
+{
+
+}
+
+std::string BasicMinimizer::minimizerName() const
+{
+    return m_minimizerName;
+}
+
+std::string BasicMinimizer::algorithmName() const
+{
+    return m_algorithmName;
+}
+
+void BasicMinimizer::setAlgorithmName(const std::string &algorithmName)
+{
+    m_algorithmName = algorithmName;
+}
+
diff --git a/Fit/Minimizer/BasicMinimizer.h b/Fit/Minimizer/BasicMinimizer.h
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a7157d52d61feb52ff9815b50836ec6afa796be7 100644
--- a/Fit/Minimizer/BasicMinimizer.h
+++ b/Fit/Minimizer/BasicMinimizer.h
@@ -0,0 +1,47 @@
+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/Minimizer/BasicMinimizer.h
+//! @brief     Declares class BasicMinimizer.
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#ifndef BASICMINIMIZER_H
+#define BASICMINIMIZER_H
+
+#include "IMinimizer.h"
+#include <string>
+
+//! @class BasicMinimizer
+//! @ingroup fitting_internal
+//! @brief The BasicMinimizer class is a base for all minimizers
+
+class BA_CORE_API_ BasicMinimizer : public IMinimizer
+{
+public:
+    explicit BasicMinimizer(const std::string &minimizerName,
+                            const std::string &algorithmName = std::string());
+
+    //! Returns name of the minimizer.
+    std::string minimizerName() const;
+
+    //! Returns name of the minimization algorithm.
+    std::string algorithmName() const;
+
+    //! Sets minimization algorithm.
+    void setAlgorithmName(const std::string &algorithmName);
+
+private:
+    std::string m_minimizerName;
+    std::string m_algorithmName;
+};
+
+#endif
+
diff --git a/Fit/Minimizer/Configurable.cpp b/Fit/Minimizer/Configurable.cpp
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..56035a128b23cbe065ebc03538c9a76030e17738 100644
--- a/Fit/Minimizer/Configurable.cpp
+++ b/Fit/Minimizer/Configurable.cpp
@@ -0,0 +1,57 @@
+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/Minimizer/Configurable.cpp
+//! @brief     Implements class Configurable.
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#include "Configurable.h"
+
+//! Returns true if option with such name already exists.
+Configurable::Configurable(const Configurable &other)
+{
+    for(auto option: other.m_options)
+        m_options.push_back(option_t(new MinimizerOption(*option)));
+}
+
+Configurable &Configurable::operator=(const Configurable &other)
+{
+    if (this != &other) {
+        Configurable tmp(other);
+        tmp.swapContent(*this);
+    }
+    return *this;
+}
+
+Configurable::option_t Configurable::option(const std::string &optionName)
+{
+    for(auto option: m_options) {
+        if(option->name() == optionName)
+            return option;
+    }
+
+    throw std::runtime_error("Configurable::getOption() -> Error. No option with name '"
+                             + optionName + "'.");
+}
+
+bool Configurable::exists(const std::string &name)
+{
+    for(auto option: m_options) {
+        if(option->name() == name)
+            return true;
+    }
+    return false;
+}
+
+void Configurable::swapContent(Configurable &other)
+{
+    std::swap(m_options, other.m_options);
+}
diff --git a/Fit/Minimizer/Configurable.h b/Fit/Minimizer/Configurable.h
index 5b6cf8127e13dd934e6a45be2c38dfc66dd26a82..4382cf660d099651591d240de73792e04748e20b 100644
--- a/Fit/Minimizer/Configurable.h
+++ b/Fit/Minimizer/Configurable.h
@@ -19,16 +19,69 @@
 #include "WinDllMacros.h"
 #include "MinimizerOption.h"
 #include <map>
+#include <vector>
+#include <memory>
+#include <exception>
+
+//! @class Configurable
+//! @ingroup fitting_internal
+//! @brief The Configurable class is a base for storing (int,double,string) options.
 
 class BA_CORE_API_ Configurable {
 
 public:
+    typedef std::shared_ptr<MinimizerOption> option_t;
 
-//    void addOption(std::string &optionName, );
+    Configurable(){}
+    Configurable(const Configurable &other);
+    Configurable& operator=(const Configurable& other);
 
-private:
-    std::vector<MinimizerOption> m_options;
+    template<class T>
+    option_t addOption(const std::string &optionName, T value,
+                       const std::string &description = std::string());
+
+    option_t option(const std::string &optionName);
 
+    template<class T>
+    T optionValue(const std::string &optionName);
+
+    //! Sets the value of option. Option should hold same value type already.
+    template<class T>
+    void setOptionValue(const std::string& optionName, T value);
+
+private:
+    bool exists(const std::string &name);
+    void swapContent(Configurable& other);
+    std::vector<std::shared_ptr<MinimizerOption>> m_options;
 };
 
+template<class T>
+Configurable::option_t Configurable::addOption(const std::string &optionName, T value,
+                                 const std::string &description)
+{
+    if(exists(optionName))
+        throw std::runtime_error("Configurable::addOption() -> Error. Option '" + optionName +
+                                 "' exists.");
+
+    option_t result(new MinimizerOption(optionName, value, description));
+    m_options.push_back(result);
+    return result;
+}
+
+template<class T>
+T Configurable::optionValue(const std::string &optionName)
+{
+    return option(optionName)->get<T>();
+}
+
+template<class T>
+void Configurable::setOptionValue(const std::string& optionName, T value)
+{
+    option(optionName)->value() = value;
+    if(option(optionName)->value().which() != option(optionName)->defaultValue().which())
+        throw std::runtime_error("Configurable::setOptionValue() -> Error. Attempt to set different"
+                                 "type to option '"+optionName+"'");
+}
+
+
 #endif
diff --git a/Fit/Minimizer/IMinimizer.h b/Fit/Minimizer/IMinimizer.h
index 45cc2f8ff7e19bfb87cfd09bc190a14187429485..8c0c23a38dfe8331ca2fc627c712d21e3bb3a73e 100644
--- a/Fit/Minimizer/IMinimizer.h
+++ b/Fit/Minimizer/IMinimizer.h
@@ -17,6 +17,7 @@
 #define IMINIMIZER_H
 
 #include "WinDllMacros.h"
+#include "Configurable.h"
 #include <functional>
 #include <vector>
 
@@ -28,7 +29,7 @@ class MinimizerOptions;
 //! @ingroup fitting_internal
 //! @brief Common interface for all kind minimizer's
 
-class BA_CORE_API_ IMinimizer
+class BA_CORE_API_ IMinimizer : public Configurable
 {
  public:
     //! signature of chi squared function to minimize
diff --git a/Fit/Minimizer/MinimizerFactory.cpp b/Fit/Minimizer/MinimizerFactory.cpp
index 0954b0d1c9a2b596c50e0b2a7d200b61cca647b4..b6e39f90bce786a0e75cee7b24f1e8258c9cdd68 100644
--- a/Fit/Minimizer/MinimizerFactory.cpp
+++ b/Fit/Minimizer/MinimizerFactory.cpp
@@ -21,6 +21,7 @@
 #include "ROOTMinuit2Minimizer.h"
 #include "ROOTMultiMinMinimizer.h"
 #include "ROOTSimAnMinimizer.h"
+#include "Minuit2Minimizer.h"
 
 // ************************************************************************** //
 // auxiliary class MinimizerCatalogue
@@ -108,7 +109,8 @@ IMinimizer* MinimizerFactory::createMinimizer(
 
     IMinimizer* result(0);
     if( minimizer == "Test" ) {
-        result = new TrivialMinimizer();
+        //result = new TrivialMinimizer();
+        result = new Minuit2Minimizer();
 
         /* temporarily disabled
     } else if( minimizer == "Scan" ) {
diff --git a/Fit/Minimizer/MinimizerOption.cpp b/Fit/Minimizer/MinimizerOption.cpp
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..74a32ec3329a75471a9e0abee910ec83e9b0fd47 100644
--- a/Fit/Minimizer/MinimizerOption.cpp
+++ b/Fit/Minimizer/MinimizerOption.cpp
@@ -0,0 +1,47 @@
+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/Minimizer/MinimizerOption.cpp
+//! @brief     Implements class MinimizerOption
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#include "MinimizerOption.h"
+
+MinimizerOption::MinimizerOption(const std::string &name)
+    : m_name(name)
+{
+
+}
+
+std::string MinimizerOption::name() const
+{
+    return m_name;
+}
+
+std::string MinimizerOption::description() const
+{
+    return m_description;
+}
+
+void MinimizerOption::setDescription(const std::string &description)
+{
+    m_description = description;
+}
+
+MinimizerOption::variant_t& MinimizerOption::value()
+{
+    return m_value;
+}
+
+MinimizerOption::variant_t &MinimizerOption::defaultValue()
+{
+    return m_default_value;
+}
diff --git a/Fit/Minimizer/MinimizerOption.h b/Fit/Minimizer/MinimizerOption.h
index ff08e8f59213225f7f2500c84206ff01c5437b92..fa491366eb3f1f560ea95466fedd19370a3f81e0 100644
--- a/Fit/Minimizer/MinimizerOption.h
+++ b/Fit/Minimizer/MinimizerOption.h
@@ -3,7 +3,7 @@
 //  BornAgain: simulate and fit scattering at grazing incidence
 //
 //! @file      Fit/Minimizer/MinimizerOption.h
-//! @brief     Declares class MinimizerOption.
+//! @brief     Declares class MinimizerOption
 //!
 //! @homepage  http://www.bornagainproject.org
 //! @license   GNU General Public License v3 or higher (see COPYING)
@@ -23,20 +23,64 @@
 //! @class MinimizerOption
 //! @ingroup fitting_internal
 //! @brief The MinimizerOption class is intended to store a single option for minimization
-//! algorithm. Relies on https://github.com/mapbox/variant
+//! algorithm. Int, double, string values are available.
+//! Relies on https://github.com/mapbox/variant
 
 class BA_CORE_API_ MinimizerOption
 {
 public:
+    typedef mapbox::util::variant<int, double, std::string> variant_t;
+
+    explicit MinimizerOption(const std::string &name = std::string());
+
+    template<typename T>
+    explicit MinimizerOption(const std::string &name, const T &t,
+                             const std::string &descripion = std::string());
+
+    std::string name() const;
+
+    std::string description() const;
+    void setDescription(const std::string &description);
+
+    variant_t& value();
+    variant_t& defaultValue();
+
+    //! Returns the option's value
+    template<typename T>
+    T get() const;
+
+    //! Returns the option's default value (i.e. used during construction)
+    template<typename T>
+    T getDefault() const;
 
 private:
     std::string m_name;
     std::string m_description;
-    mapbox::util::variant<int, double, std::string> m_value;
-    mapbox::util::variant<int, double, std::string> m_default_value;
+    variant_t m_value;
+    variant_t m_default_value;
 };
 
 
+template<typename T>
+MinimizerOption::MinimizerOption(const std::string &name, const T &t, const std::string &descripion)
+{
+    m_name = name;
+    m_description = descripion;
+    m_value = t;
+    m_default_value = t;
+}
+
+template<typename T>
+T MinimizerOption::get() const
+{
+    return m_value.get<T>();
+}
+
+template<typename T>
+T MinimizerOption::getDefault() const
+{
+    return m_default_value.get<T>();
+}
 
 #endif
 
diff --git a/Fit/Minimizer/Minuit2Minimizer.cpp b/Fit/Minimizer/Minuit2Minimizer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..878ac29449290db7e464f8f3309eccf528ca4012
--- /dev/null
+++ b/Fit/Minimizer/Minuit2Minimizer.cpp
@@ -0,0 +1,30 @@
+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/Minimizer/Minuit2Minimizer.h
+//! @brief     Declares class Minuit2Minimizer.
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#include "Minuit2Minimizer.h"
+#include "AlgorithmNames.h"
+
+Minuit2Minimizer::Minuit2Minimizer()
+    : BasicMinimizer(MinimizerNames::Minuit, AlgorithmNames::Migrad)
+{
+    addOption(std::string("Strategy"), 1);
+    addOption(std::string("ErrorDef"), 1);
+
+    MinimizerOption::variant_t v;
+    v.get<int>();
+
+
+
+}
diff --git a/Fit/Minimizer/Minuit2Minimizer.h b/Fit/Minimizer/Minuit2Minimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..98dac0ba8cd6035d2cbdc3c94b6ec83037ee4726
--- /dev/null
+++ b/Fit/Minimizer/Minuit2Minimizer.h
@@ -0,0 +1,35 @@
+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/Minimizer/Minuit2Minimizer.h
+//! @brief     Declares class Minuit2Minimizer.
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#ifndef MINUIT2MINIMIZER_H
+#define MINUIT2MINIMIZER_H
+
+#include "BasicMinimizer.h"
+
+//! @class Minuit2Minimizer
+//! @ingroup fitting_internal
+//! @brief The Minuit2Minimizer class is a wrapper for ROOT Minuit2 minimizer
+
+class BA_CORE_API_ Minuit2Minimizer : public BasicMinimizer
+{
+public:
+    Minuit2Minimizer();
+
+
+private:
+
+};
+
+#endif
diff --git a/Fit/Minimizer/recursive_wrapper.hpp b/Fit/Minimizer/recursive_wrapper.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4ffcbd7c9366b00951cd2902ecc0e211f7c0ffd9
--- /dev/null
+++ b/Fit/Minimizer/recursive_wrapper.hpp
@@ -0,0 +1,122 @@
+#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+
+// Based on variant/recursive_wrapper.hpp from boost.
+//
+// Original license:
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cassert>
+#include <utility>
+
+namespace mapbox {
+namespace util {
+
+template <typename T>
+class recursive_wrapper
+{
+
+    T* p_;
+
+    void assign(T const& rhs)
+    {
+        this->get() = rhs;
+    }
+
+public:
+    using type = T;
+
+    /**
+     * Default constructor default initializes the internally stored value.
+     * For POD types this means nothing is done and the storage is
+     * uninitialized.
+     *
+     * @throws std::bad_alloc if there is insufficient memory for an object
+     *         of type T.
+     * @throws any exception thrown by the default constructur of T.
+     */
+    recursive_wrapper()
+        : p_(new T){}
+
+    ~recursive_wrapper() noexcept { delete p_; }
+
+    recursive_wrapper(recursive_wrapper const& operand)
+        : p_(new T(operand.get())) {}
+
+    recursive_wrapper(T const& operand)
+        : p_(new T(operand)) {}
+
+    recursive_wrapper(recursive_wrapper&& operand)
+        : p_(new T(std::move(operand.get()))) {}
+
+    recursive_wrapper(T&& operand)
+        : p_(new T(std::move(operand))) {}
+
+    inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
+    {
+        assign(rhs.get());
+        return *this;
+    }
+
+    inline recursive_wrapper& operator=(T const& rhs)
+    {
+        assign(rhs);
+        return *this;
+    }
+
+    inline void swap(recursive_wrapper& operand) noexcept
+    {
+        T* temp = operand.p_;
+        operand.p_ = p_;
+        p_ = temp;
+    }
+
+    recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
+    {
+        swap(rhs);
+        return *this;
+    }
+
+    recursive_wrapper& operator=(T&& rhs)
+    {
+        get() = std::move(rhs);
+        return *this;
+    }
+
+    T& get()
+    {
+        assert(p_);
+        return *get_pointer();
+    }
+
+    T const& get() const
+    {
+        assert(p_);
+        return *get_pointer();
+    }
+
+    T* get_pointer() { return p_; }
+
+    const T* get_pointer() const { return p_; }
+
+    operator T const&() const { return this->get(); }
+
+    operator T&() { return this->get(); }
+
+}; // class recursive_wrapper
+
+template <typename T>
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
diff --git a/Fit/Minimizer/variant.hpp b/Fit/Minimizer/variant.hpp
index 5574b678c068fee2d5d38fa2d0a063780b5b5ae5..227c614973c6cad728e8b7aa50410153eb2b0af9 100644
--- a/Fit/Minimizer/variant.hpp
+++ b/Fit/Minimizer/variant.hpp
@@ -11,7 +11,7 @@
 #include <typeinfo>
 #include <utility>
 
-#include <mapbox/recursive_wrapper.hpp>
+#include <recursive_wrapper.hpp>
 
 // clang-format off
 // [[deprecated]] is only available in C++14, use this for the time being
diff --git a/Fit/RootWrapper/ROOTMinuit2Minimizer.cpp b/Fit/RootWrapper/ROOTMinuit2Minimizer.cpp
index 1f157db420098c029f78e81a8880790e7ac765f1..2b4d23eba3b2497d7c965ef655e27c1d8c0de6d2 100644
--- a/Fit/RootWrapper/ROOTMinuit2Minimizer.cpp
+++ b/Fit/RootWrapper/ROOTMinuit2Minimizer.cpp
@@ -14,7 +14,7 @@
 // ************************************************************************** //
 
 #include "ROOTMinuit2Minimizer.h"
-
+#include <string>
 
 ROOTMinuit2Minimizer::ROOTMinuit2Minimizer(const std::string& minimizer_name, const std::string& algo_type)
     : ROOTMinimizer(minimizer_name, algo_type)
@@ -25,6 +25,8 @@ ROOTMinuit2Minimizer::ROOTMinuit2Minimizer(const std::string& minimizer_name, co
     m_options.addValue("Strategy", 1);
     m_options.addValue("ErrorDef", 1);
 
+//    addOption(std::string("xxx"), 1.0);
+
 }
 
 
diff --git a/Tests/UnitTests/Fit/ConfigurableTest.h b/Tests/UnitTests/Fit/ConfigurableTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f7cd5b8919310f29c70ccac87e10a822ec5f2a8
--- /dev/null
+++ b/Tests/UnitTests/Fit/ConfigurableTest.h
@@ -0,0 +1,140 @@
+#ifndef CONFIGURABLETEST_H
+#define CONFIGURABLETEST_H
+
+#include "Configurable.h"
+#include "gtest/gtest.h"
+#include <exception>
+
+class ConfigurableTest : public ::testing::Test {
+protected:
+    ConfigurableTest(){}
+
+    class TestClass : public Configurable {
+    public:
+        TestClass(){}
+    };
+
+};
+
+TEST_F(ConfigurableTest, addOption)
+{
+    TestClass test;
+
+    const double option_value(1.0);
+    const std::string option_name("option");
+    const std::string option_description("description");
+
+    // adding option
+    Configurable::option_t option = test.addOption(option_name, option_value);
+    option->setDescription(option_description);
+    EXPECT_EQ(option_value, option->get<double>());
+    EXPECT_EQ(option_name, option->name());
+    EXPECT_EQ(option_description, option->description());
+    EXPECT_EQ(option_value, test.optionValue<double>(option_name));
+
+    // accessing option directly
+    EXPECT_EQ(option.get(), test.option(option_name).get());
+
+    // getting non-existing option
+    EXPECT_THROW(test.option("non-existing-option"), std::runtime_error);
+
+    // adding same option twice
+    EXPECT_THROW(test.addOption(option_name, 1.0), std::runtime_error);
+}
+
+TEST_F(ConfigurableTest, getOptionValue)
+{
+    TestClass test;
+
+    test.addOption("option #1", 99, "description #1");
+    test.addOption("option #2", 1.1, "description #2");
+    test.addOption("option #3", "xxx", "description #3");
+
+    EXPECT_EQ(99, test.optionValue<int>("option #1"));
+    EXPECT_EQ(1.1, test.optionValue<double>("option #2"));
+    EXPECT_EQ("xxx", test.optionValue<std::string>("option #3"));
+}
+
+TEST_F(ConfigurableTest, setOptionValue)
+{
+    TestClass test;
+
+    test.addOption("option #1", 99, "description #1");
+    test.addOption("option #2", 1.1, "description #2");
+    test.addOption("option #3", "xxx", "description #3");
+
+    test.setOptionValue("option #1", 88);
+    EXPECT_EQ(88, test.optionValue<int>("option #1"));
+
+    test.setOptionValue("option #2", 2.2);
+    EXPECT_EQ(2.2, test.optionValue<double>("option #2"));
+
+    test.setOptionValue("option #3", "yyy");
+    EXPECT_EQ("yyy", test.optionValue<std::string>("option #3"));
+
+    // setting wrong type to the option
+    EXPECT_THROW(test.setOptionValue("option #1", 99.0), std::runtime_error);
+
+}
+
+TEST_F(ConfigurableTest, Copying)
+{
+    TestClass test;
+
+    test.addOption("option #1", 99, "description #1");
+    test.addOption("option #2", 1.1, "description #2");
+    test.addOption("option #3", "xxx", "description #3");
+
+    // copying and checking values
+    TestClass copy(test);
+
+    EXPECT_EQ(99, copy.optionValue<int>("option #1"));
+    EXPECT_EQ(1.1, copy.optionValue<double>("option #2"));
+    EXPECT_EQ("xxx", copy.optionValue<std::string>("option #3"));
+
+    // changing values of copy
+    copy.setOptionValue("option #1", 88);
+    EXPECT_EQ(88, copy.optionValue<int>("option #1"));
+    copy.setOptionValue("option #2", 2.2);
+    EXPECT_EQ(2.2, copy.optionValue<double>("option #2"));
+    copy.setOptionValue("option #3", "yyy");
+    EXPECT_EQ("yyy", copy.optionValue<std::string>("option #3"));
+
+    // checking the value of original
+    EXPECT_EQ(99, test.optionValue<int>("option #1"));
+    EXPECT_EQ(1.1, test.optionValue<double>("option #2"));
+    EXPECT_EQ("xxx", test.optionValue<std::string>("option #3"));
+}
+
+
+TEST_F(ConfigurableTest, Assignment)
+{
+    TestClass test;
+
+    test.addOption("option #1", 99, "description #1");
+    test.addOption("option #2", 1.1, "description #2");
+    test.addOption("option #3", "xxx", "description #3");
+
+    // copying and checking values
+    TestClass copy;
+    copy = test;
+
+    EXPECT_EQ(99, copy.optionValue<int>("option #1"));
+    EXPECT_EQ(1.1, copy.optionValue<double>("option #2"));
+    EXPECT_EQ("xxx", copy.optionValue<std::string>("option #3"));
+
+    // changing values of copy
+    copy.setOptionValue("option #1", 88);
+    EXPECT_EQ(88, copy.optionValue<int>("option #1"));
+    copy.setOptionValue("option #2", 2.2);
+    EXPECT_EQ(2.2, copy.optionValue<double>("option #2"));
+    copy.setOptionValue("option #3", "yyy");
+    EXPECT_EQ("yyy", copy.optionValue<std::string>("option #3"));
+
+    // checking the value of original
+    EXPECT_EQ(99, test.optionValue<int>("option #1"));
+    EXPECT_EQ(1.1, test.optionValue<double>("option #2"));
+    EXPECT_EQ("xxx", test.optionValue<std::string>("option #3"));
+}
+
+#endif
diff --git a/Tests/UnitTests/Fit/MinimizerOptionTest.h b/Tests/UnitTests/Fit/MinimizerOptionTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7056f211c7c2252548fa1190d6faaf72a44028d
--- /dev/null
+++ b/Tests/UnitTests/Fit/MinimizerOptionTest.h
@@ -0,0 +1,90 @@
+#ifndef MINIMIZEROPTIONTEST_H
+#define MINIMIZEROPTIONTEST_H
+
+#include "MinimizerOption.h"
+#include <variant.hpp>
+#include "gtest/gtest.h"
+#include <iostream>
+#include <string>
+
+class MinimizerOptionTest : public ::testing::Test {
+protected:
+    MinimizerOptionTest(){}
+
+};
+
+TEST_F(MinimizerOptionTest, Variant)
+{
+    MinimizerOption::variant_t v1(1);
+
+    EXPECT_EQ(0, v1.which());
+    EXPECT_EQ(1, v1.get<int>());
+
+    v1 = 2.0;
+    EXPECT_EQ(1, v1.which());
+    EXPECT_EQ(2.0, v1.get<double>());
+
+    const std::string text("xxx");
+    v1 = text;
+    EXPECT_EQ(2, v1.which());
+    EXPECT_EQ(text, v1.get<std::string>());
+}
+
+TEST_F(MinimizerOptionTest, Construction)
+{
+    const std::string name("name");
+    const std::string description("description");
+    const double double_value(2.0);
+    MinimizerOption opt(name, double_value, description);
+
+    EXPECT_EQ(name, opt.name());
+    EXPECT_EQ(description, opt.description());
+    EXPECT_EQ(double_value, opt.value().get<double>());
+    EXPECT_EQ(double_value, opt.get<double>());
+    EXPECT_EQ(double_value, opt.getDefault<double>());
+
+    // setting new value
+    const double new_value = 3.0;
+    opt.value() = new_value;
+    EXPECT_EQ(new_value, opt.get<double>());
+    EXPECT_EQ(double_value, opt.getDefault<double>());
+}
+
+TEST_F(MinimizerOptionTest, Copying)
+{
+    const std::string name("name");
+    const std::string description("description");
+    const double double_value(2.0);
+    MinimizerOption opt(name, double_value, description);
+
+    MinimizerOption copy(opt);
+    EXPECT_EQ(name, copy.name());
+    EXPECT_EQ(description, copy.description());
+    EXPECT_EQ(double_value, copy.value().get<double>());
+    EXPECT_EQ(double_value, copy.get<double>());
+    EXPECT_EQ(double_value, copy.getDefault<double>());
+}
+
+TEST_F(MinimizerOptionTest, Assignment)
+{
+    const std::string name("name");
+    const std::string description("description");
+    const double double_value(2.0);
+    MinimizerOption opt(name, double_value, description);
+
+    MinimizerOption copy;
+    copy = opt;
+
+    const double new_value = 3.0;
+    opt.value() = new_value;
+
+    EXPECT_EQ(name, copy.name());
+    EXPECT_EQ(description, copy.description());
+    EXPECT_EQ(double_value, copy.value().get<double>());
+    EXPECT_EQ(double_value, copy.get<double>());
+    EXPECT_EQ(double_value, copy.getDefault<double>());
+}
+
+
+
+#endif
diff --git a/Tests/UnitTests/Fit/MinimizerOptionsTest.h b/Tests/UnitTests/Fit/MinimizerOptionsTest.h
index fac6e60f533c29aec2d54dc3b25951c0738337cc..2292a91bea65daf926f85f23e4b343ecd5a5e40a 100644
--- a/Tests/UnitTests/Fit/MinimizerOptionsTest.h
+++ b/Tests/UnitTests/Fit/MinimizerOptionsTest.h
@@ -1,4 +1,5 @@
 #include "MinimizerOptions.h"
+#include "Minuit2Minimizer.h"
 #include <stdexcept>
 
 class MinimizerOptionsTest : public ::testing::Test
@@ -53,3 +54,15 @@ TEST_F(MinimizerOptionsTest, SetValues)
     EXPECT_EQ(opt2.getRealValue("some_double"), 9.9);
     EXPECT_EQ(opt2.getNamedValue("some_string"), "xxx");
 }
+
+
+TEST_F(MinimizerOptionsTest, Minuit2Minimizer)
+{
+    EXPECT_EQ(1,1);
+
+    Minuit2Minimizer *minim = new Minuit2Minimizer();
+    std::cout << "XXX" << minim->minimizerName() << " " << minim->algorithmName() << std::endl;
+
+
+
+}