PropertyWithValueTest.h

#ifndef PROPERTYWITHVALUETEST_H_
#define PROPERTYWITHVALUETEST_H_

#include <cxxtest/TestSuite.h>

#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/MandatoryValidator.h"
#include "MantidKernel/BoundedValidator.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/DataItem.h"

using namespace Mantid::Kernel;

class PropertyWithValueTest : public CxxTest::TestSuite {
public:
  static PropertyWithValueTest *createSuite() {
    return new PropertyWithValueTest();
  }
  static void destroySuite(PropertyWithValueTest *suite) { delete suite; }

  PropertyWithValueTest() {
    iProp = new PropertyWithValue<int>("intProp", 1);
    dProp = new PropertyWithValue<double>("doubleProp", 9.99);
    sProp = new PropertyWithValue<std::string>("stringProp", "theValue");
    lProp = new PropertyWithValue<long long>("int64Prop", -9876543210987654LL);
  }

  ~PropertyWithValueTest() {
    delete iProp;
    delete dProp;
    delete sProp;
    delete lProp;
  }

  void testConstructor() {
    // Test that all the base class member variables are correctly assigned to
    TS_ASSERT(!iProp->name().compare("intProp"));
    TS_ASSERT(!iProp->documentation().compare(""));
    TS_ASSERT(typeid(int) == *iProp->type_info());
    TS_ASSERT(iProp->isDefault());

    TS_ASSERT(!dProp->name().compare("doubleProp"));
    TS_ASSERT(!dProp->documentation().compare(""));
    TS_ASSERT(typeid(double) == *dProp->type_info());
    TS_ASSERT(dProp->isDefault());

    TS_ASSERT(!sProp->name().compare("stringProp"));
    TS_ASSERT(!sProp->documentation().compare(""));
    TS_ASSERT(typeid(std::string) == *sProp->type_info());
    TS_ASSERT(sProp->isDefault());

    TS_ASSERT(!lProp->name().compare("int64Prop"));
    TS_ASSERT(!lProp->documentation().compare(""));
    TS_ASSERT(typeid(long long) == *lProp->type_info());
    TS_ASSERT(lProp->isDefault());
  }

  void testValue() {
    TS_ASSERT(!iProp->value().compare("1"));
    // Note that some versions of boost::lexical_cast > 1.34 give a string such
    // as
    // 9.9900000000000002 rather than 9.99. Converting back to a double however
    // does
    // still give the correct 9.99.
    TS_ASSERT(!dProp->value().substr(0, 4).compare("9.99"));
    TS_ASSERT(!sProp->value().compare("theValue"));
    TS_ASSERT(!lProp->value().compare("-9876543210987654"));
  }

  void testSizeOfSingleValueProperty() {
    // Test single value properties.
    TS_ASSERT_EQUALS(1, iProp->size());
    TS_ASSERT_EQUALS(1, dProp->size());
    TS_ASSERT_EQUALS(1, sProp->size());
    TS_ASSERT_EQUALS(1, lProp->size());
  }

  void testSizeOfVectorProperty() {
    // Test vector value property.
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    PropertyWithValue<std::vector<int>> *pv =
        new PropertyWithValue<std::vector<int>>("some_array", v);
    TS_ASSERT_EQUALS(int(v.size()), pv->size());

    delete pv;
  }

  /*
  For multifile property [[a, b], c], we should be adding a and b and therefore
  the size of the property is 2.
  */
  void testSizeOfVectorOfVectorProperty() {
    typedef std::vector<int> VecInt;
    typedef std::vector<VecInt> VecVecInt;
    // Test vector value property.
    VecVecInt v;
    v.push_back(VecInt(1, 0));
    v.push_back(VecInt(2, 0));
    v.push_back(VecInt(1, 0));
    PropertyWithValue<VecVecInt> *pv =
        new PropertyWithValue<VecVecInt>("some_vec_vec_int", v);
    TSM_ASSERT_EQUALS(
        "The size of the nested vectors should not be taken into account.",
        int(v.size()), pv->size());

    delete pv;
  }

  void testSetValue() {
    PropertyWithValue<int> i("test", 1);
    TS_ASSERT_EQUALS(i.setValue("10"), "");
    TS_ASSERT_EQUALS(i, 10);
    TS_ASSERT_EQUALS(
        i.setValue("9.99"),
        "Could not set property test. Can not convert \"9.99\" to " + i.type());
    TS_ASSERT_EQUALS(
        i.setValue("garbage"),
        "Could not set property test. Can not convert \"garbage\" to " +
            i.type());

    PropertyWithValue<double> d("test", 5.55);
    TS_ASSERT_EQUALS(d.setValue("-9.99"), "");
    TS_ASSERT_EQUALS(d, -9.99);
    TS_ASSERT_EQUALS(d.setValue("0"), "");
    TS_ASSERT_EQUALS(d, 0);
    TS_ASSERT_EQUALS(
        d.setValue("garbage"),
        "Could not set property test. Can not convert \"garbage\" to " +
            d.type());

    PropertyWithValue<std::string> s("test", "test");
    TS_ASSERT_EQUALS(s.setValue("-9.99"), "");
    TS_ASSERT_EQUALS(s.operator()(), "-9.99");
    TS_ASSERT_EQUALS(s.setValue("0"), "");
    TS_ASSERT_EQUALS(s.operator()(), "0");
    TS_ASSERT_EQUALS(s.setValue("it works"), "");
    TS_ASSERT_EQUALS(s.operator()(), "it works");

    PropertyWithValue<long long> l("test", 1);
    TS_ASSERT_EQUALS(l.setValue("10"), "");
    TS_ASSERT_EQUALS(l, 10);
    TS_ASSERT_EQUALS(l.setValue("1234567890123456"), "");
    TS_ASSERT_EQUALS(l, 1234567890123456LL);
    TS_ASSERT_EQUALS(
        l.setValue("9.99"),
        "Could not set property test. Can not convert \"9.99\" to " + l.type());
    TS_ASSERT_EQUALS(
        l.setValue("garbage"),
        "Could not set property test. Can not convert \"garbage\" to " +
            l.type());
  }

private:
  class DataObjectOne : public DataItem {
    virtual const std::string name() const { return "MyName1"; };
    virtual const std::string id() const { return "DataObjectOne"; }
    virtual bool threadSafe() const { return true; }
    virtual const std::string toString() const { return name(); }
  };

  class DataObjectTwo : public DataItem {
    virtual const std::string name() const { return "MyName2"; };
    virtual const std::string id() const { return "DataObjectTwo"; }
    virtual bool threadSafe() const { return true; }
    virtual const std::string toString() const { return name(); }
  };

public:
  void testGetDefault() {
    PropertyWithValue<std::string> s("defau=theDef", "theDef");
    TS_ASSERT_EQUALS(s.getDefault(), "theDef");
    TS_ASSERT_EQUALS(s.setValue("somethingElse"), "");
    TS_ASSERT_EQUALS(s.getDefault(), "theDef");

    PropertyWithValue<int> i("defau1", 3);
    TS_ASSERT_EQUALS(i.getDefault(), "3");
    TS_ASSERT_EQUALS(i.setValue("5"), "");
    TS_ASSERT_EQUALS(i.getDefault(), "3");
    TS_ASSERT_EQUALS(
        i.setValue("garbage"),
        "Could not set property defau1. Can not convert \"garbage\" to " +
            i.type());
    TS_ASSERT_EQUALS(i.getDefault(), "3");

    PropertyWithValue<long long> l("defau1", 987987987987LL);
    TS_ASSERT_EQUALS(l.getDefault(), "987987987987");
    TS_ASSERT_EQUALS(l.setValue("5"), "");
    TS_ASSERT_EQUALS(l.getDefault(), "987987987987");
    TS_ASSERT_EQUALS(
        l.setValue("garbage"),
        "Could not set property defau1. Can not convert \"garbage\" to " +
            l.type());
    TS_ASSERT_EQUALS(l.getDefault(), "987987987987");

    // Note that some versions of boost::lexical_cast > 1.34 give a string such
    // as
    // 9.9900000000000002 rather than 9.99. Converting back to a double however
    // does
    // still give the correct 9.99.
    PropertyWithValue<double> d("defau3.33", 3.33);
    TS_ASSERT_EQUALS(d.getDefault().substr(0, 4), "3.33");
    TS_ASSERT_EQUALS(d.setValue("1.6"), "");
    TS_ASSERT_EQUALS(d.getDefault().substr(0, 4), "3.33");
    TS_ASSERT_EQUALS(
        d.setValue("garbage"),
        "Could not set property defau3.33. Can not convert \"garbage\" to " +
            d.type());
    TS_ASSERT_EQUALS(d.getDefault().substr(0, 4), "3.33");
  }

  void testCopyConstructor() {
    PropertyWithValue<int> i = *iProp;
    TS_ASSERT(!i.name().compare("intProp"));
    TS_ASSERT(!i.documentation().compare(""));
    TS_ASSERT(typeid(int) == *i.type_info());
    TS_ASSERT(i.isDefault());
    TS_ASSERT_EQUALS(i, 1);

    PropertyWithValue<double> d = *dProp;
    TS_ASSERT(!d.name().compare("doubleProp"));
    TS_ASSERT(!d.documentation().compare(""));
    TS_ASSERT(typeid(double) == *d.type_info());
    TS_ASSERT(d.isDefault());
    TS_ASSERT_EQUALS(d, 9.99);

    PropertyWithValue<std::string> s = *sProp;
    TS_ASSERT(!s.name().compare("stringProp"));
    TS_ASSERT(!s.documentation().compare(""));
    TS_ASSERT(typeid(std::string) == *s.type_info());
    TS_ASSERT(s.isDefault());
    TS_ASSERT_EQUALS(sProp->operator()(), "theValue");

    PropertyWithValue<long long> l = *lProp;
    TS_ASSERT(!lProp->name().compare("int64Prop"));
    TS_ASSERT(!lProp->documentation().compare(""));
    TS_ASSERT(typeid(long long) == *lProp->type_info());
    TS_ASSERT(lProp->isDefault());
    TS_ASSERT_EQUALS(l, -9876543210987654LL);
  }

  void testCopyAssignmentOperator() {
    PropertyWithValue<int> i("Prop1", 5);
    i = *iProp;
    TS_ASSERT(!i.name().compare("Prop1"));
    TS_ASSERT(!i.documentation().compare(""));
    TS_ASSERT(!i.isDefault());
    TS_ASSERT_EQUALS(i, 1);

    PropertyWithValue<double> d("Prop2", 5.5);
    d = *dProp;
    TS_ASSERT(!d.name().compare("Prop2"));
    TS_ASSERT(!d.documentation().compare(""));
    TS_ASSERT(!d.isDefault());
    TS_ASSERT_EQUALS(d, 9.99);

    PropertyWithValue<std::string> s("Prop3", "test");
    s = *sProp;
    TS_ASSERT(!s.name().compare("Prop3"));
    TS_ASSERT(!s.documentation().compare(""));
    TS_ASSERT(!s.isDefault());
    TS_ASSERT_EQUALS(sProp->operator()(), "theValue");

    PropertyWithValue<long long> l("Prop4", 5);
    l = *lProp;
    TS_ASSERT(!l.name().compare("Prop4"));
    TS_ASSERT(!l.documentation().compare(""));
    TS_ASSERT(!l.isDefault());
    TS_ASSERT_EQUALS(l, -9876543210987654LL);
  }

  void testAssignmentOperator() {
    PropertyWithValue<int> i("Prop1", 5);
    TS_ASSERT_EQUALS(i = 2, 2);
    TS_ASSERT(!i.isDefault());
    i = 5;
    TS_ASSERT(i.isDefault());

    PropertyWithValue<double> d("Prop2", 5.5);
    TS_ASSERT_EQUALS(d = 7.77, 7.77);
    TS_ASSERT(!d.isDefault());
    d = 5.5;
    TS_ASSERT(d.isDefault());

    PropertyWithValue<std::string> s("Prop3", "testing");
    s = "test";
    TS_ASSERT_EQUALS(s.operator()(), "test");
    TS_ASSERT(!s.isDefault());
    s = "testing";
    TS_ASSERT(i.isDefault());

    PropertyWithValue<long long> l("Prop4", 987987987987LL);
    TS_ASSERT_EQUALS(l = 2, 2);
    TS_ASSERT(!l.isDefault());
    l = 987987987987LL;
    TS_ASSERT(l.isDefault());

    PropertyWithValue<int> ii("Prop1.1", 6);
    i = ii = 10;
    TS_ASSERT_EQUALS(ii, 10);
    TS_ASSERT_EQUALS(i, 10);

    PropertyWithValue<double> dd("Prop2.2", 6.5);
    d = dd = 1.111;
    TS_ASSERT_EQUALS(dd, 1.111);
    TS_ASSERT_EQUALS(d, 1.111);

    PropertyWithValue<std::string> ss("Prop3.3", "testing2");
    s = ss = "tested";
    TS_ASSERT_EQUALS(ss.operator()(), "tested");
    TS_ASSERT_EQUALS(s.operator()(), "tested");

    PropertyWithValue<long long> ll("Prop4.4", 6);
    l = ll = 789789789789LL;
    TS_ASSERT_EQUALS(ll, 789789789789LL);
    TS_ASSERT_EQUALS(l, 789789789789LL);
  }

  void testOperatorBrackets() {
    TS_ASSERT_EQUALS(iProp->operator()(), 1);
    TS_ASSERT_EQUALS(dProp->operator()(), 9.99);
    TS_ASSERT_EQUALS(sProp->operator()(), "theValue");
    TS_ASSERT_EQUALS(lProp->operator()(), -9876543210987654LL);
  }

  void testPlusEqualOperator() {
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    PropertyWithValue<std::vector<int>> *pv =
        new PropertyWithValue<std::vector<int>>("some_array", v);
    PropertyWithValue<std::vector<int>> *pv2 =
        new PropertyWithValue<std::vector<int>>("some_array", v);
    (*pv) += pv2;
    TS_ASSERT_EQUALS(pv->value(), "1,2,3,1,2,3");
    delete pv;
    delete pv2;
  }

  void testPlusEqualOperatorOnYourself() {
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    PropertyWithValue<std::vector<int>> *pv =
        new PropertyWithValue<std::vector<int>>("some_array", v);
    (*pv) += pv;
    TS_ASSERT_EQUALS(pv->value(), "1,2,3,1,2,3");
    delete pv;
  }

  void testOperatorNothing() {
    int i = *iProp;
    TS_ASSERT_EQUALS(i, 1);
    double d = *dProp;
    TS_ASSERT_EQUALS(d, 9.99);
    std::string str = *sProp;
    TS_ASSERT(!str.compare("theValue"));
    long long l = *lProp;
    TS_ASSERT_EQUALS(l, -9876543210987654LL);
  }

  void testAllowedValues() {
    TS_ASSERT(iProp->allowedValues().empty());
    TS_ASSERT(dProp->allowedValues().empty());
    TS_ASSERT(sProp->allowedValues().empty());
    TS_ASSERT(lProp->allowedValues().empty());
    // Tests using a ListValidator are below
  }

  void testCasting() {
    TS_ASSERT_DIFFERS(dynamic_cast<Property *>(iProp),
                      static_cast<Property *>(0));
    PropertyWithValue<int> i("Prop1", 5);
    Property *p = dynamic_cast<Property *>(&i);
    TS_ASSERT(!p->name().compare("Prop1"));
    TS_ASSERT(!p->value().compare("5"));
    TS_ASSERT_EQUALS(p->setValue("10"), "");
    TS_ASSERT(!p->value().compare("10"));
    TS_ASSERT_EQUALS(i, 10);

    TS_ASSERT_DIFFERS(dynamic_cast<Property *>(dProp),
                      static_cast<Property *>(0));
    PropertyWithValue<double> d("Prop2", 5.5);
    Property *pp = dynamic_cast<Property *>(&d);
    TS_ASSERT(!pp->name().compare("Prop2"));
    TS_ASSERT(!pp->value().compare("5.5"));
    TS_ASSERT_EQUALS(pp->setValue("7.777"), "");
    // Note that some versions of boost::lexical_cast > 1.34 give a string such
    // as
    // 9.9900000000000002 rather than 9.99. Converting back to a double however
    // does
    // still give the correct 9.99.
    TS_ASSERT(!pp->value().substr(0, 5).compare("7.777"));
    TS_ASSERT_EQUALS(d, 7.777);

    TS_ASSERT_DIFFERS(dynamic_cast<Property *>(sProp),
                      static_cast<Property *>(0));
    PropertyWithValue<std::string> s("Prop3", "testing");
    Property *ppp = dynamic_cast<Property *>(&s);
    TS_ASSERT(!ppp->name().compare("Prop3"));
    TS_ASSERT(!ppp->value().compare("testing"));
    TS_ASSERT_EQUALS(ppp->setValue("newValue"), "");
    TS_ASSERT(!ppp->value().compare("newValue"));
    TS_ASSERT_EQUALS(s.operator()(), "newValue");

    TS_ASSERT_DIFFERS(dynamic_cast<Property *>(lProp),
                      static_cast<Property *>(0));
    PropertyWithValue<long long> l("Prop4", 789789789789LL);
    Property *pppp = dynamic_cast<Property *>(&l);
    TS_ASSERT(!pppp->name().compare("Prop4"));
    TS_ASSERT(!pppp->value().compare("789789789789"));
    TS_ASSERT_EQUALS(pppp->setValue("10"), "");
    TS_ASSERT(!pppp->value().compare("10"));
    TS_ASSERT_EQUALS(l, 10);
  }

  void testMandatoryValidator() {
    PropertyWithValue<std::string> p(
        "test", "", boost::make_shared<MandatoryValidator<std::string>>());
    TS_ASSERT_EQUALS(p.isValid(), "A value must be entered for this parameter");
    TS_ASSERT_EQUALS(p.setValue("I'm here"), "");
    TS_ASSERT_EQUALS(p.isValid(), "");
    TS_ASSERT_EQUALS(p.setValue(""),
                     "A value must be entered for this parameter");
    TS_ASSERT_EQUALS(p.value(), "I'm here");
  }

  void testIntBoundedValidator() {
    std::string start("Selected value "), end(")"),
        greaterThan(" is > the upper bound ("),
        lessThan(" is < the lower bound (");

    // int tests
    PropertyWithValue<int> pi("test", 11,
                              boost::make_shared<BoundedValidator<int>>(1, 10));
    TS_ASSERT_EQUALS(pi.isValid(), start + "11" + greaterThan + "10" + end);
    TS_ASSERT_EQUALS(pi.setValue("0"), start + "0" + lessThan + "1" + end);
    TS_ASSERT_EQUALS(pi.value(), "11");
    TS_ASSERT_EQUALS(pi.isValid(), start + "11" + greaterThan + "10" + end);
    TS_ASSERT_EQUALS(pi.setValue("1"), "");
    TS_ASSERT_EQUALS(pi.isValid(), "");
    TS_ASSERT_EQUALS(pi.setValue("10"), "");
    TS_ASSERT_EQUALS(pi.isValid(), "");
    TS_ASSERT_EQUALS(pi.setValue("11"),
                     start + "11" + greaterThan + "10" + end);
    TS_ASSERT_EQUALS(pi.value(), "10");
    TS_ASSERT_EQUALS(pi.isValid(), "");
    std::string errorMsg = pi.setValue("");
    // when the string can't be converted to the correct type we get a system
    // dependent meassage that in this case should look like the string below
    TS_ASSERT_EQUALS(
        errorMsg.find("Could not set property test. Can not convert \"\" to ",
                      0),
        0);

    // double tests
    PropertyWithValue<double> pd(
        "test", 11.0, boost::make_shared<BoundedValidator<double>>(1.0, 10.0));
    TS_ASSERT_EQUALS(pd.isValid(), start + "11" + greaterThan + "10" + end);
    TS_ASSERT_EQUALS(pd.setValue("0.9"), start + "0.9" + lessThan + "1" + end);
    TS_ASSERT_EQUALS(pd.value(), "11");
    TS_ASSERT_EQUALS(pd.isValid(), start + "11" + greaterThan + "10" + end);
    TS_ASSERT_EQUALS(pd.setValue("1"), "");
    TS_ASSERT_EQUALS(pd.isValid(), "");
    TS_ASSERT_EQUALS(pd.setValue("10"), "");
    TS_ASSERT_EQUALS(pd.isValid(), "");
    TS_ASSERT_EQUALS(pd.setValue("10.1"),
                     start + "10.1" + greaterThan + "10" + end);
    TS_ASSERT_EQUALS(pd.value(), "10");
    TS_ASSERT_EQUALS(pd.isValid(), "");

    // string tests
    PropertyWithValue<std::string> ps(
        "test", "",
        boost::make_shared<BoundedValidator<std::string>>("B", "T"));
    TS_ASSERT_EQUALS(ps.isValid(), start + "" + lessThan + "B" + end);
    TS_ASSERT_EQUALS(ps.setValue("AZ"), start + "AZ" + lessThan + "B" + end);
    TS_ASSERT_EQUALS(ps.value(), "");
    TS_ASSERT_EQUALS(ps.isValid(), start + "" + lessThan + "B" + end);
    TS_ASSERT_EQUALS(ps.setValue("B"), "");
    TS_ASSERT_EQUALS(ps.isValid(), "");
    TS_ASSERT_EQUALS(ps.setValue("T"), "");
    TS_ASSERT_EQUALS(ps.isValid(), "");
    TS_ASSERT_EQUALS(ps.setValue("TA"), start + "TA" + greaterThan + "T" + end);
    TS_ASSERT_EQUALS(ps.value(), "T");
    TS_ASSERT_EQUALS(ps.isValid(), "");

    // int64 tests
    PropertyWithValue<long long> pl(
        "test", 987987987987LL,
        boost::make_shared<BoundedValidator<long long>>(0, 789789789789LL));
    TS_ASSERT_EQUALS(pl.isValid(), start + "987987987987" + greaterThan +
                                       "789789789789" + end);
    TS_ASSERT_EQUALS(pl.setValue("-1"), start + "-1" + lessThan + "0" + end);
    TS_ASSERT_EQUALS(pl.value(), "987987987987");
    TS_ASSERT_EQUALS(pl.setValue("0"), "");
    TS_ASSERT_EQUALS(pl.isValid(), "");
    TS_ASSERT_EQUALS(pl.setValue("789789789789"), "");
    TS_ASSERT_EQUALS(pl.isValid(), "");
    TS_ASSERT_EQUALS(pl.setValue("789789789790"), start + "789789789790" +
                                                      greaterThan +
                                                      "789789789789" + end);
    TS_ASSERT_EQUALS(pl.value(), "789789789789");
  }

  void testListValidator() {
    std::string start("The value '"),
        end("' is not in the list of allowed values");

    std::vector<std::string> empt, vec;
    PropertyWithValue<std::string> empty(
        "test", "", boost::make_shared<StringListValidator>(empt));
    TS_ASSERT_EQUALS(empty.isValid(), "Select a value");
    vec.push_back("one");
    vec.push_back("two");
    PropertyWithValue<std::string> p(
        "test", "", boost::make_shared<StringListValidator>(vec));
    TS_ASSERT_EQUALS(p.isValid(), "Select a value");
    TS_ASSERT_EQUALS(p.setValue("one"), "");
    TS_ASSERT_EQUALS(p.isValid(), "");
    TS_ASSERT_EQUALS(p.setValue("two"), "");
    TS_ASSERT_EQUALS(p.isValid(), "");
    TS_ASSERT_EQUALS(
        p.setValue("three"),
        "The value \"three\" is not in the list of allowed values");
    TS_ASSERT_EQUALS(p.value(), "two");
    TS_ASSERT_EQUALS(p.isValid(), "");
    std::vector<std::string> s;
    TS_ASSERT_THROWS_NOTHING(s = p.allowedValues());
    TS_ASSERT_EQUALS(s.size(), 2);
    TS_ASSERT(std::find(s.begin(), s.end(), "one") != s.end())
    TS_ASSERT(std::find(s.begin(), s.end(), "two") != s.end())
  }

  void testIsDefault() {
    TS_ASSERT_EQUALS(iProp->setValue("1"), "");
    // 1 is was the initial value and so the next test should pass
    TS_ASSERT(iProp->isDefault());
    TS_ASSERT_EQUALS(iProp->setValue("2"), "");
    TS_ASSERT(!iProp->isDefault());
  }

  // class A
  //{
  // public:
  //  virtual A& fun(const A& rhs)
  //  {
  //    std::cout << "fun() called from class A\n";
  //  }
  //};
  //
  // template <typename T>
  // class B : public A
  //{
  // public:
  //  B(T value) : m_value(value)
  //  {
  //
  //  }
  //
  //  virtual A& fun(const A& rhs)
  //  {
  //    std::cout << "fun() called from class B<T>. I contain " << m_value << "
  //    and the parameter contains " << rhs.m_value << "\n";
  //  }
  //  T m_value;
  //};
  //
  //  void testTemplates()
  //  {
  //    std::cout << "\n\n";
  //    A myA;
  //    B<int> myB(12);
  //    myA.fun(myA);
  //    myB.fun(myB);
  //
  //    A * myAptr = new A();
  //    A * myBptr = new B<int>(23);
  //
  //    myAptr->fun(*myAptr);
  //    myBptr->fun(*myBptr);
  //
  //  }

  void testAdditionOperator() {
    int i;
    double d;
    Property *p1;
    Property *p2;

    // --- Numbers are added together ----
    p1 = new PropertyWithValue<double>("Prop1", 12.0);
    p2 = new PropertyWithValue<double>("Prop1", 23.0);
    (*p1) += p2;
    PropertyWithValue<double> *pd =
        dynamic_cast<PropertyWithValue<double> *>(p1);
    d = *pd;
    TS_ASSERT_EQUALS(d, 35.0);
    delete p1;
    delete p2;

    p1 = new PropertyWithValue<int>("Prop1", 34);
    p2 = new PropertyWithValue<int>("Prop1", 62);
    (*p1) += p2;
    PropertyWithValue<int> *pi = dynamic_cast<PropertyWithValue<int> *>(p1);
    i = *pi;
    TS_ASSERT_EQUALS(i, 96);
    delete p1;
    delete p2;

    // --- Vectors are appennded together ----
    std::vector<int> v1, v2;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    v1.push_back(6);
    p1 = new PropertyWithValue<std::vector<int>>("Prop1", v1);
    p2 = new PropertyWithValue<std::vector<int>>("Prop1", v2);
    (*p1) += p2;
    PropertyWithValue<std::vector<int>> *pvi =
        dynamic_cast<PropertyWithValue<std::vector<int>> *>(p1);
    std::vector<int> v3 = *pvi;
    TS_ASSERT_EQUALS(v3.size(), 6);
    delete p1;
    delete p2;
  }

  void test_string_property_alias() {
    // system("pause");
    std::vector<std::string> allowedValues;
    allowedValues.push_back("Hello");
    allowedValues.push_back("World");
    std::map<std::string, std::string> alias;
    alias["1"] = "Hello";
    alias["0"] = "World";
    auto validator =
        boost::make_shared<ListValidator<std::string>>(allowedValues, alias);
    PropertyWithValue<std::string> prop("String", "", validator);
    TS_ASSERT_THROWS_NOTHING(prop = "Hello");
    std::string value = prop;
    TS_ASSERT_EQUALS(value, "Hello");

    TS_ASSERT_THROWS(prop = "Mantid", std::invalid_argument);

    TS_ASSERT_THROWS_NOTHING(prop = "1");
    value = prop;
    TS_ASSERT_EQUALS(value, "Hello");

    TS_ASSERT_THROWS_NOTHING(prop = "0");
    value = prop;
    TS_ASSERT_EQUALS(value, "World");
  }

private:
  PropertyWithValue<int> *iProp;
  PropertyWithValue<double> *dProp;
  PropertyWithValue<std::string> *sProp;
  PropertyWithValue<long long> *lProp;
};

#endif /*PROPERTYWITHVALUETEST_H_*/