1. BornAgainFit unit test infrastructure

2. Tests for AttLimits, FitParameter, FitParameterLinked

CMakeLists.txt

@@ -35,6 +35,7 @@ add_subdirectory(ThirdParty/gtest)
 add_subdirectory(Tests/UnitTests/TestCore)
 add_subdirectory(ThirdParty/RootMinimizers)
 add_subdirectory(Fit)
+add_subdirectory(Tests/UnitTests/TestFit)
 add_subdirectory(Tests/FunctionalTests)  # functional tests (make check)
 
 if(ROOT_FOUND AND BORNAGAIN_APP)

Core/Tools/inc/BAConfigure.h

+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Tools/inc/BAConfigure.h
+//! @brief     Defines configuration variables
+//!
+//! @homepage  http://apps.jcns.fz-juelich.de/BornAgain
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2013
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#ifndef BACONFIGURE_H
+#define BACONFIGURE_H
+
+/* Configuration file will be automatically regenerated by CMake */
+
+#define BORNAGAIN_SOURCE_DIR "/home/mahadi/BornAgain"
+#define BORNAGAIN_INSTALL_DIR "/usr/local"
+
+#endif

Tests/UnitTests/TestFit/AttLimitsTest.h

+#ifndef ATTLIMITSTEST_H
+#define ATTLIMITSTEST_H
+
+#include "AttLimits.h"
+
+#include "gtest/gtest.h"
+
+
+class AttLimitsTest : public ::testing::Test
+{
+ protected:
+    AttLimitsTest(){}
+    virtual ~AttLimitsTest(){}
+
+};
+
+
+
+TEST_F(AttLimitsTest, AttLimitsInitial)
+{
+    AttLimits attLimits;
+
+    EXPECT_FALSE(attLimits.hasLowerLimit());
+    EXPECT_FALSE(attLimits.hasUpperLimit());
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.isFixed());
+}
+
+TEST_F(AttLimitsTest, AttLimitsSetLimit)
+{
+    AttLimits attLimits;
+
+    //set limit
+    attLimits.setLimits(-1.0,10.0);
+    EXPECT_TRUE(attLimits.hasLowerLimit());
+    EXPECT_TRUE(attLimits.hasUpperLimit());
+    EXPECT_TRUE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.isFixed());
+
+    //lower limit
+    EXPECT_EQ(-1.0,attLimits.getLowerLimit());
+
+    attLimits.removeLowerLimit();
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.hasLowerLimit());
+    EXPECT_EQ(0.0,attLimits.getLowerLimit());
+
+    attLimits.setLowerLimit(2.1);
+    EXPECT_TRUE(attLimits.hasLowerLimit());
+    EXPECT_EQ(2.1,attLimits.getLowerLimit());
+
+    //upper limit
+    EXPECT_EQ(10.0,attLimits.getUpperLimit());
+
+    attLimits.removeUpperLimit();
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.hasUpperLimit());
+    EXPECT_EQ(0.0,attLimits.getUpperLimit());
+
+    attLimits.setUpperLimit(2.2);
+    EXPECT_TRUE(attLimits.hasUpperLimit());
+    EXPECT_EQ(2.2,attLimits.getUpperLimit());
+
+    EXPECT_TRUE(attLimits.hasLowerAndUpperLimits());
+
+    //remove limit
+    attLimits.removeLimits();
+    EXPECT_FALSE(attLimits.hasLowerLimit());
+    EXPECT_FALSE(attLimits.hasUpperLimit());
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.isFixed());
+
+}
+
+TEST_F(AttLimitsTest, AttLimitsLowerLimited)
+{
+    AttLimits attLimits = AttLimits::lowerLimited(5.0);
+    EXPECT_TRUE(attLimits.hasLowerLimit());
+    EXPECT_FALSE(attLimits.hasUpperLimit());
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.isFixed());
+
+    EXPECT_EQ(5.0,attLimits.getLowerLimit());
+    EXPECT_EQ(0.0,attLimits.getUpperLimit());
+}
+
+TEST_F(AttLimitsTest, AttLimitsUpperLimited)
+{
+    AttLimits attLimits = AttLimits::upperLimited(5.0);
+    EXPECT_FALSE(attLimits.hasLowerLimit());
+    EXPECT_TRUE(attLimits.hasUpperLimit());
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.isFixed());
+
+    EXPECT_EQ(0.0,attLimits.getLowerLimit());
+    EXPECT_EQ(5.0,attLimits.getUpperLimit());
+}
+
+TEST_F(AttLimitsTest, AttLimitsLimited)
+{
+    AttLimits attLimits = AttLimits::limited(-10.0, 2.0);
+    EXPECT_TRUE(attLimits.hasLowerLimit());
+    EXPECT_TRUE(attLimits.hasUpperLimit());
+    EXPECT_TRUE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.isFixed());
+
+    EXPECT_EQ(-10.0,attLimits.getLowerLimit());
+    EXPECT_EQ(2.0,attLimits.getUpperLimit());
+}
+
+TEST_F(AttLimitsTest, AttLimitsLimitless)
+{
+    AttLimits attLimits = AttLimits::limitless();
+
+    EXPECT_FALSE(attLimits.hasLowerLimit());
+    EXPECT_FALSE(attLimits.hasUpperLimit());
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_FALSE(attLimits.isFixed());
+}
+
+TEST_F(AttLimitsTest, AttLimitsFixed)
+{
+    AttLimits attLimits = AttLimits::fixed();
+
+    EXPECT_FALSE(attLimits.hasLowerLimit());
+    EXPECT_FALSE(attLimits.hasUpperLimit());
+    EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_TRUE(attLimits.isFixed());
+
+    EXPECT_EQ(0.0,attLimits.getLowerLimit());
+    EXPECT_EQ(0.0,attLimits.getUpperLimit());
+
+    attLimits.setFixed(false);
+    EXPECT_FALSE(attLimits.isFixed());
+}
+
+
+#endif // ATTLIMITSTEST_H

Tests/UnitTests/TestFit/CMakeLists.txt

+############################################################################
+# CMakeLists.txt file for building and running unit tests
+############################################################################
+
+enable_testing()
+
+file(GLOB include_files "*.h")
+
+add_executable( TestFit main.cpp ${include_files})
+
+# dependencies
+include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
+target_link_libraries(TestFit gtest)
+
+include_directories(
+    ${Boost_INCLUDE_DIRS}
+    ${BornAgainCore_INCLUDE_DIRS}
+    ${BornAgainFit_INCLUDE_DIRS}
+    ${EIGEN3_INCLUDE_DIR}
+)
+
+
+target_link_libraries(TestFit
+    ${BornAgainCore_LIBRARY}
+    ${BornAgainFit_LIBRARY}
+    ${Boost_LIBRARIES}
+)
+
+# to build executable right in lib directory to not to have problems with finding libBornAgainCore.dll under Windows
+set_property(TARGET TestFit PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+
+add_test( TestFit TestFit) # TestName ExeName
+
+# add execution of TestCore just after compilation
+add_custom_command(TARGET TestFit POST_BUILD COMMAND TestFit)
+
+
+

Tests/UnitTests/TestFit/FitParameterLinkedTest.h

+#ifndef FITPARAMETERLINKEDTEST_H
+#define FITPARAMETERLINKEDTEST_H
+
+#include "ParameterPool.h"
+#include "FitParameterLinked.h"
+
+#include "gtest/gtest.h"
+
+
+class FitParameterLinkedTest : public ::testing::Test
+{
+ protected:
+    FitParameterLinkedTest(){}
+    virtual ~FitParameterLinkedTest(){}
+
+};
+
+
+
+TEST_F(FitParameterLinkedTest, FitParameterLinkedInitial)
+{
+    FitParameterLinked fitParameterLinked;
+
+    EXPECT_EQ("", fitParameterLinked.getName());
+    EXPECT_EQ(0.0, fitParameterLinked.getValue());
+    EXPECT_EQ(0.0, fitParameterLinked.getStep());
+    EXPECT_EQ(0.0, fitParameterLinked.getError());
+
+
+    EXPECT_FALSE(fitParameterLinked.hasLowerLimit());
+    EXPECT_FALSE(fitParameterLinked.hasUpperLimit());
+    EXPECT_FALSE(fitParameterLinked.hasLowerAndUpperLimits());
+    EXPECT_FALSE(fitParameterLinked.isFixed());
+}
+
+TEST_F(FitParameterLinkedTest, FitParameterLinkedWithValue)
+{
+    AttLimits attLimits = AttLimits::limited(-10.0, 2.0);
+
+    FitParameterLinked fitParameter("FitPL", 2.0, 0.2, attLimits, 0.01);
+
+    EXPECT_EQ("FitPL", fitParameter.getName());
+    EXPECT_EQ(2.0, fitParameter.getValue());
+    EXPECT_EQ(0.2, fitParameter.getStep());
+    EXPECT_EQ(0.01, fitParameter.getError());
+
+    EXPECT_EQ(-10.0, fitParameter.getLowerLimit());
+    EXPECT_EQ(2.0, fitParameter.getUpperLimit());
+
+}
+
+TEST_F(FitParameterLinkedTest, FitParameterLinkedParamPool)
+{
+    FitParameterLinked fitParameterLinked;
+
+
+    double pValue1 = 1.0;
+    double pValue2 = 2.0;
+    double pValue3 = 3.0;
+    double pValue4 = 4.0;
+    double pValue5 = 5.0;
+    double pValue6 = 6.0;
+
+    ParameterPool::parameter_t poolpar1(&pValue1);
+    ParameterPool::parameter_t poolpar2(&pValue2);
+    ParameterPool::parameter_t poolpar3(&pValue3);
+    ParameterPool::parameter_t poolpar4(&pValue4);
+    ParameterPool::parameter_t poolpar5(&pValue5);
+    ParameterPool::parameter_t poolpar6(&pValue6);
+
+    fitParameterLinked.addParameter(poolpar1);
+    fitParameterLinked.addParameter(poolpar2);
+    fitParameterLinked.addParameter(poolpar3);
+
+    fitParameterLinked.setValue(11.2);
+    EXPECT_EQ(11.2, fitParameterLinked.getValue());
+    EXPECT_EQ(11.2, pValue1);
+    EXPECT_EQ(11.2, pValue2);
+    EXPECT_EQ(11.2, pValue3);
+
+
+    ParameterPool m_pool;
+    m_pool.addParameter("par4",poolpar4);
+    m_pool.addParameter("par5",poolpar5);
+    m_pool.addParameter("par6",poolpar6);
+
+    fitParameterLinked.addMatchedParametersFromPool(&m_pool,"par4");
+    fitParameterLinked.setValue(2.3);
+
+    EXPECT_EQ(2.3, fitParameterLinked.getValue());
+    EXPECT_EQ(2.3, pValue1);
+    EXPECT_EQ(2.3, pValue2);
+    EXPECT_EQ(2.3, pValue3);
+    EXPECT_EQ(2.3, pValue4);
+
+
+}
+
+
+#endif //FITPARAMETERLINKEDTEST_H

Tests/UnitTests/TestFit/FitParameterTest.h

+#ifndef FITPARAMETERTEST_H
+#define FITPARAMETERTEST_H
+
+#include "FitParameter.h"
+
+#include "gtest/gtest.h"
+
+
+class FitParameterTest : public ::testing::Test
+{
+ protected:
+    FitParameterTest(){}
+    virtual ~FitParameterTest(){}
+
+};
+
+
+
+TEST_F(FitParameterTest, FitParameterInitial)
+{
+    FitParameter fitParameter;
+
+    EXPECT_EQ("", fitParameter.getName());
+    EXPECT_EQ(0.0, fitParameter.getValue());
+    EXPECT_EQ(0.0, fitParameter.getStep());
+    EXPECT_EQ(0.0, fitParameter.getError());
+
+
+    EXPECT_FALSE(fitParameter.hasLowerLimit());
+    EXPECT_FALSE(fitParameter.hasUpperLimit());
+    EXPECT_FALSE(fitParameter.hasLowerAndUpperLimits());
+    EXPECT_FALSE(fitParameter.isFixed());
+}
+
+TEST_F(FitParameterTest, FitParameterSetValue)
+{
+    FitParameter fitParameter;
+    fitParameter.setValue(-1.0);
+    fitParameter.setStep(0.1);
+    fitParameter.setError(1.2);
+
+    EXPECT_EQ(-1.0, fitParameter.getValue());
+    EXPECT_EQ(0.1, fitParameter.getStep());
+    EXPECT_EQ(1.2, fitParameter.getError());
+}
+
+
+TEST_F(FitParameterTest, FitParameterWithValue)
+{
+    AttLimits attLimits = AttLimits::limited(-10.0, 2.0);
+
+    FitParameter fitParameter("FitP", 2.0, 0.2, attLimits, 0.01);
+
+    EXPECT_EQ("FitP", fitParameter.getName());
+    EXPECT_EQ(2.0, fitParameter.getValue());
+    EXPECT_EQ(0.2, fitParameter.getStep());
+    EXPECT_EQ(0.01, fitParameter.getError());
+
+
+    EXPECT_TRUE(fitParameter.hasLowerLimit());
+    EXPECT_TRUE(fitParameter.hasUpperLimit());
+    EXPECT_TRUE(fitParameter.hasLowerAndUpperLimits());
+    EXPECT_FALSE(fitParameter.isFixed());
+    EXPECT_EQ(-10.0, fitParameter.getLowerLimit());
+    EXPECT_EQ(2.0, fitParameter.getUpperLimit());
+
+
+    fitParameter.setValue(-1.0);
+    fitParameter.setStep(0.1);
+    fitParameter.setError(1.2);
+
+    EXPECT_EQ(-1.0, fitParameter.getValue());
+    EXPECT_EQ(0.1, fitParameter.getStep());
+    EXPECT_EQ(1.2, fitParameter.getError());
+}
+
+#endif //FITPARAMETERTEST_H

Tests/UnitTests/TestFit/main.cpp

+#ifdef _MSC_VER
+#define _VARIADIC_MAX 10
+#endif
+#include "gtest/gtest.h"
+
+#include "AttLimitsTest.h"
+#include "FitParameterTest.h"
+#include "FitParameterLinkedTest.h"
+
+struct ErrorStreamRedirect {
+    ErrorStreamRedirect( std::streambuf * new_buffer )
+        : old( std::cerr.rdbuf( new_buffer ) )
+    { }
+
+    ~ErrorStreamRedirect( ) {
+        std::cerr.rdbuf( old );
+    }
+
+private:
+    std::streambuf * old;
+};
+
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+
+    // redirect std::cerr stream
+    std::stringstream oss;
+    ErrorStreamRedirect redirecter( oss.rdbuf() );
+    (void)redirecter;
+
+    // run all google tests
+    return RUN_ALL_TESTS();
+}
+