DynamicFactoryTest.h

#ifndef DYNAMICFACTORYTEST_H_
#define DYNAMICFACTORYTEST_H_

#include "MantidKernel/DynamicFactory.h"
#include <cxxtest/TestSuite.h>

#include <boost/shared_ptr.hpp>
#include <Poco/NObserver.h>

#include <vector>
#include <string>


using namespace Mantid::Kernel;

// Helper class
class IntFactory : public DynamicFactory<int>
{
};

// Helper class
class CaseSensitiveIntFactory : public DynamicFactory<int,CaseSensitiveStringComparator>
{
};

class DynamicFactoryTest : public CxxTest::TestSuite
{
  typedef boost::shared_ptr<int> int_ptr;
public:
  // This pair of boilerplate methods prevent the suite being created statically
  // This means the constructor isn't called when running other tests
  static DynamicFactoryTest *createSuite() { return new DynamicFactoryTest(); }
  static void destroySuite( DynamicFactoryTest *suite ) { delete suite; }

  DynamicFactoryTest() :
    CxxTest::TestSuite(), factory(), m_notificationObserver(*this, &DynamicFactoryTest::handleFactoryUpdate), m_updateNoticeReceived(false)
  {
    factory.notificationCenter.addObserver(m_notificationObserver);
  }

  ~DynamicFactoryTest()
  {
    factory.notificationCenter.removeObserver(m_notificationObserver);
  }

  void testCreate()
  {
    TS_ASSERT_THROWS( factory.create("testEntry"), std::runtime_error )
    factory.subscribe<int>("testEntry");
    TS_ASSERT_THROWS_NOTHING( int_ptr i = factory.create("testEntry") );
    TS_ASSERT_THROWS_NOTHING( int_ptr i = factory.create("TESTENTRY") );
    factory.unsubscribe("testEntry");
  }

  void testCreateCaseSensitive()
  {
    TS_ASSERT_THROWS( caseSensitiveFactory.create("testEntryCaseSensitive"), std::runtime_error )
    caseSensitiveFactory.subscribe<int>("testEntryCaseSensitive");
    TS_ASSERT_THROWS( int_ptr i = caseSensitiveFactory.create("testEntryCaseSENSITIVE") , std::runtime_error); //case error on a case sensitive dynamic factory
    TS_ASSERT_THROWS_NOTHING( int_ptr i2 = caseSensitiveFactory.create("testEntryCaseSensitive") );
    caseSensitiveFactory.unsubscribe("testEntryCaseSensitive");
  }


  void testCreateUnwrapped()
  {
    TS_ASSERT_THROWS( factory.createUnwrapped("testUnrappedEntry"), std::runtime_error )
    factory.subscribe<int>("testUnwrappedEntry");
    int *i = NULL;
    TS_ASSERT_THROWS_NOTHING( i = factory.createUnwrapped("testUnwrappedEntry") );
    delete i;

    int *j = NULL;
    TS_ASSERT_THROWS_NOTHING( j = factory.createUnwrapped("TESTUnwrappedEntry") );
    delete j;
    factory.unsubscribe("testUnwrappedEntry");
  }

  void testCreateUnwrappedCaseSensitive()
  {
    TS_ASSERT_THROWS( caseSensitiveFactory.create("testUnrappedEntryCaseSensitive"), std::runtime_error )
    caseSensitiveFactory.subscribe<int>("testUnrappedEntryCaseSensitive");
    int *i = NULL;
    TS_ASSERT_THROWS( i = caseSensitiveFactory.createUnwrapped("testUnrappedentrycaseSENSITIVE") , std::runtime_error); //case error on a case sensitive dynamic factory
    TS_ASSERT_THROWS_NOTHING( i = caseSensitiveFactory.createUnwrapped("testUnrappedEntryCaseSensitive") );
    delete i;
    caseSensitiveFactory.unsubscribe("testUnrappedEntryCaseSensitive");
  }

  void testSubscribeWithEmptyNameThrowsInvalidArgument()
  {
    TS_ASSERT_THROWS( factory.subscribe<int>(""), std::invalid_argument);
  }

  void testSubscribeWithReplaceEqualsErrorIfExistsThrowsRegisteringMatchingClass()
  {
    TS_ASSERT_THROWS_NOTHING( factory.subscribe("int",new Instantiator<int, int>));
    TS_ASSERT_THROWS( factory.subscribe("int",new Instantiator<int, int>,IntFactory::ErrorIfExists), std::runtime_error);
    factory.unsubscribe("int");
  }

  void testSubscribeWithReplaceEqualsOverwriteCurrentReplacesMatchingClass()
  {
    TS_ASSERT_THROWS_NOTHING( factory.subscribe("int",new Instantiator<int, int>));
    TS_ASSERT_THROWS_NOTHING( factory.subscribe("int",new Instantiator<int, int>,IntFactory::OverwriteCurrent));

    factory.unsubscribe("int");
  }

  void testSubscribeByDefaultDoesNotNotify()
  {
    m_updateNoticeReceived = false;
    TS_ASSERT_THROWS_NOTHING( factory.subscribe<int>("int") );
    TS_ASSERT_EQUALS( m_updateNoticeReceived, false )
    factory.unsubscribe("int");
  }

  void testSubscribeNotifiesIfTheyAreSwitchedOn()
  {
    m_updateNoticeReceived = false;
    factory.enableNotifications();
    TS_ASSERT_THROWS_NOTHING( factory.subscribe<int>("intWithNotice") );
    TS_ASSERT_EQUALS( m_updateNoticeReceived, true )
    factory.disableNotifications();
    TS_ASSERT_THROWS_NOTHING( factory.unsubscribe("intWithNotice"));
    }

  void testUnsubscribeByDefaultDoesNotNotify()
  {
     TS_ASSERT_THROWS( factory.unsubscribe("tester"), std::runtime_error);
     factory.subscribe<int>("tester");
     m_updateNoticeReceived = false;
     TS_ASSERT_THROWS_NOTHING( factory.unsubscribe("tester"));
     TS_ASSERT_EQUALS( m_updateNoticeReceived, false )
  }

  void testUnsubscribeNotifiesIfTheyAreSwitchedOn()
  {
    TS_ASSERT_THROWS_NOTHING( factory.subscribe<int>("intWithNotice") );
    factory.enableNotifications();
    m_updateNoticeReceived = false;
    TS_ASSERT_THROWS_NOTHING( factory.unsubscribe("intWithNotice"));
    TS_ASSERT_EQUALS( m_updateNoticeReceived, true )

    factory.disableNotifications();
    m_updateNoticeReceived = false;
  }


  void testExists()
  {
    TS_ASSERT( ! factory.exists("testing") );
    factory.subscribe<int>("testing");
    TS_ASSERT( factory.exists("testing") );
    TS_ASSERT( factory.exists("TESTING") );
  }
	
  void testGetKeys()
  {
    std::string testKey = "testGetKeys";
    //check it is not already present
    TS_ASSERT_THROWS( factory.create(testKey), std::runtime_error )
    factory.subscribe<int>(testKey);

    std::vector<std::string> keys = factory.getKeys();
    
    TSM_ASSERT("Could not find the test key in the returned vector.", std::find(keys.begin(), keys.end(), testKey)!=keys.end()) //check the case is correct

    TS_ASSERT(!keys.empty());

    factory.unsubscribe(testKey);
  }

  void testGetKeysRetainsCase()
  {
    std::string testKey = "testGetKeysRetainsCase";
    //check it is not already present
    TS_ASSERT_THROWS( factory.create(testKey), std::runtime_error )
    factory.subscribe<int>(testKey);

    std::vector<std::string> keys = factory.getKeys();
    
    factory.unsubscribe(testKey);

  }

private:
  void handleFactoryUpdate(const Poco::AutoPtr<IntFactory::UpdateNotification> &)
  {
    m_updateNoticeReceived = true;
  }

  IntFactory factory;
  CaseSensitiveIntFactory caseSensitiveFactory;
  Poco::NObserver<DynamicFactoryTest, IntFactory::UpdateNotification> m_notificationObserver;
  bool m_updateNoticeReceived;
};

#endif /*DYNAMICFACTORYTEST_H_*/