First version Map implementation of database handler with unit tests ( ticket 38 )

Signed-off-by: Christian Linke <christian.linke@bmw.de>

23 files changed, 5684 insertions, 82 deletions

diff --git a/AudioManagerDaemon/CMakeLists.txt b/AudioManagerDaemon/CMakeLists.txt
index 270b542..0eb9100 100644
--- a/AudioManagerDaemon/CMakeLists.txt
+++ b/AudioManagerDaemon/CMakeLists.txt
@@ -25,7 +25,9 @@ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
 set(DOC_OUTPUT_PATH ${DOC_OUTPUT_PATH}/AudioManager)
 set(INCLUDE_FOLDER "include")
 
-pkg_check_modules(SQLITE REQUIRED sqlite3)
+IF (WITH_DATABASE_STORAGE)
+    pkg_check_modules(SQLITE REQUIRED sqlite3)
+ENDIF (WITH_DATABASE_STORAGE)
 
 IF (WITH_SYSTEMD_WATCHDOG)
 	pkg_check_modules(SYSTEMD libsystemd-daemon>=44)
@@ -49,6 +51,7 @@ SET(AUDIOMAN_SRCS_CXX
     src/CAmControlReceiver.cpp
     src/CAmControlSender.cpp
     src/CAmDatabaseHandler.cpp
+    src/CAmMapHandler.cpp
     src/CAmDatabaseObserver.cpp
     src/CAmRoutingReceiver.cpp
     src/CAmRoutingSender.cpp
@@ -88,6 +91,18 @@ IF(WITH_SOCKETHANDLER_LOOP)
      )
 ENDIF(WITH_SOCKETHANDLER_LOOP)
 
+IF(WITH_DATABASE_STORAGE)
+    SET (AUDIOMAN_SRCS_CXX
+        ${AUDIOMAN_SRCS_CXX}
+        src/CAmDatabaseHandler.cpp
+    )
+ELSE(WITH_DATABASE_STORAGE)
+    SET (AUDIOMAN_SRCS_CXX
+        ${AUDIOMAN_SRCS_CXX}
+        src/CAmMapHandler.cpp
+    )
+ENDIF(WITH_DATABASE_STORAGE)
+
 INCLUDE_DIRECTORIES(	
 	${CMAKE_SOURCE_DIR} 
 	${CMAKE_CURRENT_BINARY_DIR}	
@@ -182,7 +197,9 @@ IF(WITH_TESTS)
 ENDIF(WITH_TESTS)
 
 # General packet dependency
-SET(ADD_DEPEND_BIN_PROP "sqlite3(>=3.6.22)")
+IF(WITH_DATABASE_STORAGE)
+    SET(ADD_DEPEND_BIN_PROP "sqlite3(>=3.6.22)")
+ENDIF(WITH_DATABASE_STORAGE)
 
 # Optional packet dependency
 IF(WITH_DLT)
diff --git a/AudioManagerDaemon/include/CAmCommandReceiver.h b/AudioManagerDaemon/include/CAmCommandReceiver.h
index 8f9aa06..56f26d1 100644
--- a/AudioManagerDaemon/include/CAmCommandReceiver.h
+++ b/AudioManagerDaemon/include/CAmCommandReceiver.h
@@ -27,7 +27,7 @@
 namespace am
 {
 
-class CAmDatabaseHandler;
+class CAmDatabaseHandlerInterface;
 class CAmControlSender;
 class CAmDbusWrapper;
 class CAmSocketHandler;
@@ -38,8 +38,8 @@ class CAmSocketHandler;
 class CAmCommandReceiver: public IAmCommandReceive
 {
 public:
-    CAmCommandReceiver(CAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iControlSender, CAmSocketHandler* iSocketHandler);
-    CAmCommandReceiver(CAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iControlSender, CAmSocketHandler* iSocketHandler, CAmDbusWrapper* iDBusWrapper);
+    CAmCommandReceiver(CAmDatabaseHandlerInterface* iDatabaseHandler, CAmControlSender* iControlSender, CAmSocketHandler* iSocketHandler);
+    CAmCommandReceiver(CAmDatabaseHandlerInterface* iDatabaseHandler, CAmControlSender* iControlSender, CAmSocketHandler* iSocketHandler, CAmDbusWrapper* iDBusWrapper);
     ~CAmCommandReceiver();
     am_Error_e connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID);
     am_Error_e disconnect(const am_mainConnectionID_t mainConnectionID);
@@ -75,7 +75,7 @@ public:
     void waitOnRundown(bool rundown); //!< tells the ComandReceiver to start waiting for all handles to be confirmed
 
 private:
-    CAmDatabaseHandler* mDatabaseHandler; //!< pointer to the databasehandler
+    CAmDatabaseHandlerInterface* mDatabaseHandler; //!< pointer to the databasehandler
     CAmControlSender* mControlSender; //!< pointer to the control sender
     CAmDbusWrapper* mDBusWrapper; //!< pointer to the dbuswrapper
     CAmSocketHandler* mSocketHandler; //!< pointer to the SocketHandler
diff --git a/AudioManagerDaemon/include/CAmControlReceiver.h b/AudioManagerDaemon/include/CAmControlReceiver.h
index 11e295d..ca0c3f5 100644
--- a/AudioManagerDaemon/include/CAmControlReceiver.h
+++ b/AudioManagerDaemon/include/CAmControlReceiver.h
@@ -28,7 +28,7 @@ namespace am
 {
 
 class CAmSocketHandler;
-class CAmDatabaseHandler;
+class CAmDatabaseHandlerInterface;
 class CAmRoutingSender;
 class CAmCommandSender;
 class CAmRouter;
@@ -40,8 +40,8 @@ class CAmNodeStateCommunicator;
 class CAmControlReceiver: public IAmControlReceive
 {
 public:
-    CAmControlReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter, CAmNodeStateCommunicator* iNodeStateCommunicator);
-    CAmControlReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter);
+    CAmControlReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter, CAmNodeStateCommunicator* iNodeStateCommunicator);
+    CAmControlReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter);
     ~CAmControlReceiver();
     am_Error_e getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList);
     am_Error_e connect(am_Handle_s& handle, am_connectionID_t& connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID);
@@ -137,7 +137,7 @@ public:
     NsmErrorStatus_e sendLifecycleRequestCompleteNSM(const uint32_t RequestId, const NsmErrorStatus_e status) ;
 
 private:
-    CAmDatabaseHandler* mDatabaseHandler; //!< pointer tto the databasehandler
+    CAmDatabaseHandlerInterface* mDatabaseHandler; //!< pointer tto the databasehandler
     CAmRoutingSender* mRoutingSender; //!< pointer to the routing send interface.
     CAmCommandSender* mCommandSender; //!< pointer to the command send interface
     CAmSocketHandler* mSocketHandler; //!< pointer to the socketHandler
diff --git a/AudioManagerDaemon/include/CAmDatabaseHandler.h b/AudioManagerDaemon/include/CAmDatabaseHandler.h
index 4341c01..1adc4d6 100644
--- a/AudioManagerDaemon/include/CAmDatabaseHandler.h
+++ b/AudioManagerDaemon/include/CAmDatabaseHandler.h
@@ -22,10 +22,8 @@
 #ifndef DATABASEHANDLER_H_
 #define DATABASEHANDLER_H_
 
-#include "audiomanagertypes.h"
+#include "CAmDatabaseHandlerInterface.h"
 #include <map>
-#include <vector>
-#include <string>
 #include <sqlite3.h>
 
 namespace am
@@ -35,7 +33,6 @@ class CAmDatabaseObserver;
 class CAmRoutingTree;
 class CAmRoutingTreeItem;
 
-#define DYNAMIC_ID_BOUNDARY 100 //!< the value below is reserved for staticIDs, the value above will be assigned to dynamically registered items
 //todo: check the enum values before entering & changing in the database.
 //todo: change asserts for dynamic boundary checks into failure answers.#
 //todo: check autoincrement boundary and set to 16bit limits
@@ -47,9 +44,18 @@ class CAmRoutingTreeItem;
 /**
  * This class handles and abstracts the database
  */
-class CAmDatabaseHandler
+class CAmDatabaseHandler : public CAmDatabaseHandlerInterface
 {
+private:
+    am_timeSync_t calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const; //!< calculates a new main connection delay
+    bool sqQuery(const std::string& query); //!< queries the database
+    bool openDatabase(); //!< opens the database
+    void createTables(); //!< creates all tables from the static table
+    sqlite3 *mpDatabase; //!< pointer to the database
+    std::string mPath; //!< path to the database
+
 public:
+	CAmDatabaseHandler();
     CAmDatabaseHandler(std::string databasePath);
     ~CAmDatabaseHandler();
     am_Error_e enterDomainDB(const am_Domain_s& domainData, am_domainID_t& domainID);
@@ -148,8 +154,8 @@ public:
 
     bool existMainConnection(const am_mainConnectionID_t mainConnectionID) const;
     bool existcrossFader(const am_crossfaderID_t crossfaderID) const;
-    bool existConnection(const am_Connection_s connection);
-    bool existConnectionID(const am_connectionID_t connectionID);
+    bool existConnection(const am_Connection_s & connection) const;
+    bool existConnectionID(const am_connectionID_t connectionID) const;
     bool existSource(const am_sourceID_t sourceID) const;
     bool existSourceNameOrID(const am_sourceID_t sourceID, const std::string& name) const;
     bool existSourceName(const std::string& name) const;
@@ -163,23 +169,6 @@ public:
     void registerObserver(CAmDatabaseObserver *iObserver);
     bool sourceVisible(const am_sourceID_t sourceID) const;
     bool sinkVisible(const am_sinkID_t sinkID) const;
-
-private:
-    am_timeSync_t calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const; //!< calculates a new main connection delay
-    bool sqQuery(const std::string& query); //!< queries the database
-    bool openDatabase(); //!< opens the database
-    void createTables(); //!< creates all tables from the static table
-    sqlite3 *mpDatabase; //!< pointer to the database
-    std::string mPath; //!< path to the database
-    CAmDatabaseObserver *mpDatabaseObserver; //!< pointer to the Observer
-    bool mFirstStaticSink; //!< bool for dynamic range handling
-    bool mFirstStaticSource; //!< bool for dynamic range handling
-    bool mFirstStaticGateway; //!< bool for dynamic range handling
-    bool mFirstStaticSinkClass; //!< bool for dynamic range handling
-    bool mFirstStaticSourceClass; //!< bool for dynamic range handling
-    bool mFirstStaticCrossfader; //!< bool for dynamic range handling
-    typedef std::map<am_gatewayID_t, std::vector<bool> > ListConnectionFormat; //!< type for list of connection formats
-    ListConnectionFormat mListConnectionFormat; //!< list of connection formats
 };
 
 }
diff --git a/AudioManagerDaemon/include/CAmDatabaseHandlerInterface.h b/AudioManagerDaemon/include/CAmDatabaseHandlerInterface.h
new file mode 100644
index 0000000..58d97bc
--- /dev/null
+++ b/AudioManagerDaemon/include/CAmDatabaseHandlerInterface.h
@@ -0,0 +1,192 @@
+/**
+ * Copyright (C) 2012, BMW AG
+ *
+ * This file is part of GENIVI Project AudioManager.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+* \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
+ *
+ * \file CAmDatabaseHandlerInterface.h
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#ifndef DATABASEHANDLERINTERFACE_H_
+#define DATABASEHANDLERINTERFACE_H_
+
+#include "audiomanagertypes.h"
+#include <map>
+#include <vector>
+#include <string>
+
+namespace am
+{
+
+class CAmDatabaseObserver;
+class CAmRoutingTree;
+class CAmRoutingTreeItem;
+
+#define DYNAMIC_ID_BOUNDARY 100 //!< the value below is reserved for staticIDs, the value above will be assigned to dynamically registered items
+//todo: check the enum values before entering & changing in the database.
+//todo: change asserts for dynamic boundary checks into failure answers.#
+//todo: check autoincrement boundary and set to 16bit limits
+//todo: If the sink is part of a gateway, the listconnectionFormats is copied to the gatewayInformation. Check this statement for sinks & sources
+//todo: exchange last_insert_row id to be more safe
+//todo: create test to ensure uniqueness of names throughout the database
+//todo: enforce the uniqueness of names
+
+typedef std::map<am_gatewayID_t, std::vector<bool> > ListConnectionFormat; //!< type for list of connection formats
+
+/**
+ * This class handles and abstracts the database
+ */
+
+class CAmDatabaseHandlerInterface
+{
+protected:
+    virtual am_timeSync_t calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const = 0; //!< calculates a new main connection delay
+    CAmDatabaseObserver *mpDatabaseObserver; //!< pointer to the Observer
+    bool mFirstStaticSink; //!< bool for dynamic range handling
+    bool mFirstStaticSource; //!< bool for dynamic range handling
+    bool mFirstStaticGateway; //!< bool for dynamic range handling
+    bool mFirstStaticSinkClass; //!< bool for dynamic range handling
+    bool mFirstStaticSourceClass; //!< bool for dynamic range handling
+    bool mFirstStaticCrossfader; //!< bool for dynamic range handling
+    ListConnectionFormat mListConnectionFormat; //!< list of connection formats
+
+public:
+    CAmDatabaseHandlerInterface(): 	mpDatabaseObserver(NULL), //
+										mFirstStaticSink(true), //
+										mFirstStaticSource(true), //
+										mFirstStaticGateway(true), //
+										mFirstStaticSinkClass(true), //
+										mFirstStaticSourceClass(true), //
+										mFirstStaticCrossfader(true), //
+										mListConnectionFormat()
+	{};
+    virtual ~CAmDatabaseHandlerInterface() {};
+
+    virtual am_Error_e enterDomainDB(const am_Domain_s& domainData, am_domainID_t& domainID) = 0;
+    virtual am_Error_e enterMainConnectionDB(const am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID) = 0;
+    virtual am_Error_e enterSinkDB(const am_Sink_s& sinkData, am_sinkID_t& sinkID) = 0;
+    virtual am_Error_e enterCrossfaderDB(const am_Crossfader_s& crossfaderData, am_crossfaderID_t& crossfaderID) = 0;
+    virtual am_Error_e enterGatewayDB(const am_Gateway_s& gatewayData, am_gatewayID_t& gatewayID) = 0;
+    virtual am_Error_e enterSourceDB(const am_Source_s& sourceData, am_sourceID_t& sourceID) = 0;
+    virtual am_Error_e enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID) = 0;
+    virtual am_Error_e enterSinkClassDB(const am_SinkClass_s& sinkClass, am_sinkClass_t& sinkClassID) = 0;
+    virtual am_Error_e enterSourceClassDB(am_sourceClass_t& sourceClassID, const am_SourceClass_s& sourceClass) = 0;
+    virtual am_Error_e enterSystemProperties(const std::vector<am_SystemProperty_s>& listSystemProperties) = 0;
+    virtual am_Error_e changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID) = 0;
+    virtual am_Error_e changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState) = 0;
+    virtual am_Error_e changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID) = 0;
+    virtual am_Error_e changeSinkAvailabilityDB(const am_Availability_s& availability, const am_sinkID_t sinkID) = 0;
+    virtual am_Error_e changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID) = 0;
+    virtual am_Error_e changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID) = 0;
+    virtual am_Error_e changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sinkID_t sinkID) = 0;
+    virtual am_Error_e changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sourceID_t sourceID) = 0;
+    virtual am_Error_e changeSourceSoundPropertyDB(const am_SoundProperty_s& soundProperty, const am_sourceID_t sourceID) = 0;
+    virtual am_Error_e changeSinkSoundPropertyDB(const am_SoundProperty_s& soundProperty, const am_sinkID_t sinkID) = 0;
+    virtual am_Error_e changeSourceAvailabilityDB(const am_Availability_s& availability, const am_sourceID_t sourceID) = 0;
+    virtual am_Error_e changeSystemPropertyDB(const am_SystemProperty_s& property) = 0;
+    virtual am_Error_e changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID) = 0;
+    virtual am_Error_e changeSinkClassInfoDB(const am_SinkClass_s& sinkClass) = 0;
+    virtual am_Error_e changeSourceClassInfoDB(const am_SourceClass_s& sourceClass) = 0;
+    virtual am_Error_e changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay) = 0;
+    virtual am_Error_e changeConnectionFinal(const am_connectionID_t connectionID) = 0;
+    virtual am_Error_e changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState) = 0;
+    virtual am_Error_e changeSinkVolume(const am_sinkID_t sinkID, const am_volume_t volume) = 0;
+    virtual am_Error_e changeSourceVolume(const am_sourceID_t sourceID, const am_volume_t volume) = 0;
+    virtual am_Error_e changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink) = 0;
+    virtual am_Error_e removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID) = 0;
+    virtual am_Error_e removeSinkDB(const am_sinkID_t sinkID) = 0;
+    virtual am_Error_e removeSourceDB(const am_sourceID_t sourceID) = 0;
+    virtual am_Error_e removeGatewayDB(const am_gatewayID_t gatewayID) = 0;
+    virtual am_Error_e removeCrossfaderDB(const am_crossfaderID_t crossfaderID) = 0;
+    virtual am_Error_e removeDomainDB(const am_domainID_t domainID) = 0;
+    virtual am_Error_e removeSinkClassDB(const am_sinkClass_t sinkClassID) = 0;
+    virtual am_Error_e removeSourceClassDB(const am_sourceClass_t sourceClassID) = 0;
+    virtual am_Error_e removeConnection(const am_connectionID_t connectionID) = 0;
+    virtual am_Error_e getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s& classInfo) const  = 0;
+    virtual am_Error_e getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s& sinkClass) const  = 0;
+    virtual am_Error_e getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s& gatewayData) const  = 0;
+    virtual am_Error_e getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s& sinkData) const  = 0;
+    virtual am_Error_e getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s& sourceData) const  = 0;
+    virtual am_Error_e getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData) const = 0;
+    virtual am_Error_e getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData) const = 0;
+    virtual am_Error_e getSinkVolume(const am_sinkID_t sinkID, am_volume_t& volume) const = 0;
+    virtual am_Error_e getSourceVolume(const am_sourceID_t sourceID, am_volume_t& volume) const = 0;
+    virtual am_Error_e getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_SoundPropertyType_e propertyType, int16_t& value) const = 0;
+    virtual am_Error_e getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_SoundPropertyType_e propertyType, int16_t& value) const = 0;
+    virtual am_Error_e getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t>& listSinkID) const = 0;
+    virtual am_Error_e getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t>& listSourceID) const = 0;
+    virtual am_Error_e getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t>& listGatewaysID) const = 0;
+    virtual am_Error_e getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t>& listGatewaysID) const = 0;
+    virtual am_Error_e getListMainConnections(std::vector<am_MainConnection_s>& listMainConnections) const = 0;
+    virtual am_Error_e getListDomains(std::vector<am_Domain_s>& listDomains) const = 0;
+    virtual am_Error_e getListConnections(std::vector<am_Connection_s>& listConnections) const = 0;
+    virtual am_Error_e getListSinks(std::vector<am_Sink_s>& listSinks) const = 0;
+    virtual am_Error_e getListSources(std::vector<am_Source_s>& lisSources) const = 0;
+    virtual am_Error_e getListSourceClasses(std::vector<am_SourceClass_s>& listSourceClasses) const = 0;
+    virtual am_Error_e getListCrossfaders(std::vector<am_Crossfader_s>& listCrossfaders) const = 0;
+    virtual am_Error_e getListGateways(std::vector<am_Gateway_s>& listGateways) const = 0;
+    virtual am_Error_e getListSinkClasses(std::vector<am_SinkClass_s>& listSinkClasses) const = 0;
+    virtual am_Error_e getListVisibleMainConnections(std::vector<am_MainConnectionType_s>& listConnections) const = 0;
+    virtual am_Error_e getListMainSinks(std::vector<am_SinkType_s>& listMainSinks) const = 0;
+    virtual am_Error_e getListMainSources(std::vector<am_SourceType_s>& listMainSources) const = 0;
+    virtual am_Error_e getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s>& listSoundProperties) const = 0;
+    virtual am_Error_e getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s>& listSourceProperties) const = 0;
+    virtual am_Error_e getListSystemProperties(std::vector<am_SystemProperty_s>& listSystemProperties) const = 0;
+    virtual am_Error_e getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const = 0;
+    virtual am_Error_e getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const = 0;
+    virtual am_Error_e getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> & listConnectionFormat) const = 0;
+    virtual am_Error_e getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay) const = 0;
+    virtual am_Error_e getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t& domainID) const = 0;
+    virtual am_Error_e getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t& domainID) const = 0;
+    virtual am_Error_e getSoureState(const am_sourceID_t sourceID, am_SourceState_e& sourceState) const = 0;
+    virtual am_Error_e getDomainState(const am_domainID_t domainID, am_DomainState_e& state) const = 0;
+    virtual am_Error_e getRoutingTree(bool onlyfree, CAmRoutingTree& tree, std::vector<CAmRoutingTreeItem*>& flatTree) = 0;
+    virtual am_Error_e peekDomain(const std::string& name, am_domainID_t& domainID) = 0;
+    virtual am_Error_e peekSink(const std::string& name, am_sinkID_t& sinkID) = 0;
+    virtual am_Error_e peekSource(const std::string& name, am_sourceID_t& sourceID) = 0;
+    virtual am_Error_e peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID) = 0;
+    virtual am_Error_e peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID) = 0;
+    virtual am_Error_e changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_ConnectionFormat_e>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties) = 0;
+    virtual am_Error_e changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_ConnectionFormat_e>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties) = 0;
+    virtual am_Error_e getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations) = 0;
+    virtual am_Error_e getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations) = 0;
+    virtual am_Error_e changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration) = 0;
+    virtual am_Error_e changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration) = 0;
+    virtual am_Error_e changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_ConnectionFormat_e>& listSourceConnectionFormats, const std::vector<am_ConnectionFormat_e>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix) = 0;
+    virtual am_Error_e changeSinkNotificationConfigurationDB(const am_sinkID_t sinkID,const am_NotificationConfiguration_s notificationConfiguration) = 0;
+    virtual am_Error_e changeSourceNotificationConfigurationDB(const am_sourceID_t sourceID,const am_NotificationConfiguration_s notificationConfiguration) = 0;
+
+    virtual bool existMainConnection(const am_mainConnectionID_t mainConnectionID) const = 0;
+    virtual bool existcrossFader(const am_crossfaderID_t crossfaderID) const = 0;
+    virtual bool existConnection(const am_Connection_s & connection) const = 0;
+    virtual bool existConnectionID(const am_connectionID_t connectionID) const = 0;
+    virtual bool existSource(const am_sourceID_t sourceID) const = 0;
+    virtual bool existSourceNameOrID(const am_sourceID_t sourceID, const std::string& name) const = 0;
+    virtual bool existSourceName(const std::string& name) const = 0;
+    virtual bool existSink(const am_sinkID_t sinkID) const = 0;
+    virtual bool existSinkNameOrID(const am_sinkID_t sinkID, const std::string& name) const = 0;
+    virtual bool existSinkName(const std::string& name) const = 0;
+    virtual bool existDomain(const am_domainID_t domainID) const = 0;
+    virtual bool existGateway(const am_gatewayID_t gatewayID) const = 0;
+    virtual bool existSinkClass(const am_sinkClass_t sinkClassID) const = 0;
+    virtual bool existSourceClass(const am_sourceClass_t sourceClassID) const = 0;
+    virtual void registerObserver(CAmDatabaseObserver *iObserver) = 0;
+    virtual bool sourceVisible(const am_sourceID_t sourceID) const = 0;
+    virtual bool sinkVisible(const am_sinkID_t sinkID) const = 0;
+};
+
+}
+
+#endif /* DATABASEHANDLERINTERFACE_H_ */
diff --git a/AudioManagerDaemon/include/CAmMapHandler.h b/AudioManagerDaemon/include/CAmMapHandler.h
new file mode 100644
index 0000000..984fbe1
--- /dev/null
+++ b/AudioManagerDaemon/include/CAmMapHandler.h
@@ -0,0 +1,394 @@
+/**
+ * Copyright (C) 2012, BMW AG
+ *
+ * This file is part of GENIVI Project AudioManager.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+* \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
+ *
+ * \file CAmDatabaseHandler.h
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#ifndef MAPHANDLER_H_
+#define MAPHANDLER_H_
+
+#include "CAmDatabaseHandlerInterface.h"
+#include <unordered_map>
+#include <map>
+#include <stdint.h>
+#include <limits.h>
+
+
+namespace am
+{
+//todo: check the enum values before entering & changing in the database.
+//todo: change asserts for dynamic boundary checks into failure answers.#
+//todo: check autoincrement boundary and set to 16bit limits
+//todo: If the sink is part of a gateway, the listconnectionFormats is copied to the gatewayInformation. Check this statement for sinks & sources
+//todo: exchange last_insert_row id to be more safe
+//todo: create test to ensure uniqueness of names throughout the database
+//todo: enforce the uniqueness of names
+
+/**
+ * The following structures extend the base structures with the field 'reserved'.
+ */
+
+struct am_Sink_Database_s : public am_Sink_s
+{
+	bool reserved;
+	am_Sink_Database_s():am_Sink_s(), reserved(false)
+	{};
+	void getSinkType(am_SinkType_s & sinkType) const
+	{
+		sinkType.name = name;
+		sinkType.sinkID = sinkID;
+		sinkType.availability = available;
+		sinkType.muteState = muteState;
+		sinkType.volume = mainVolume;
+		sinkType.sinkClassID = sinkClassID;
+	};
+	am_Sink_Database_s & operator=(const am_Sink_Database_s & anObject)
+	{
+		if (this != &anObject)
+		{
+			am_Sink_s::operator=(anObject);
+			reserved = anObject.reserved;
+		}
+		return *this;
+	};
+	am_Sink_Database_s & operator=(const am_Sink_s & anObject)
+	{
+		if (this != &anObject)
+			am_Sink_s::operator=(anObject);
+		return *this;
+	};
+	void print() const
+	{
+		printf("\n Sink(%s) id(%d)\n", name.c_str() ,sinkID);
+	    printf("\t availability(%d) availabilityReason(%d) sinkClassID(%d) domainID(%d) visible(%d) volume(%d) mainVolume(%d) muteState(%d) reserved(%d)\n",
+	    				available.availability, available.availabilityReason, sinkClassID, domainID, visible, volume, mainVolume, muteState,reserved);
+	};
+};
+
+struct am_Source_Database_s : public am_Source_s
+{
+	bool reserved;
+	am_Source_Database_s():am_Source_s(), reserved(false)
+	{};
+	void getSourceType(am_SourceType_s & sourceType) const
+	{
+		sourceType.name = name;
+		sourceType.sourceClassID = sourceClassID;
+		sourceType.availability = available;
+		sourceType.sourceID = sourceID;
+	};
+	am_Source_Database_s & operator=(const am_Source_Database_s & anObject)
+	{
+		if (this != &anObject)
+		{
+			am_Source_s::operator=(anObject);
+			reserved = anObject.reserved;
+		}
+		return *this;
+	};
+	am_Source_Database_s & operator=(const am_Source_s & anObject)
+	{
+		if (this != &anObject)
+		{
+			am_Source_s::operator=(anObject);
+		}
+		return *this;
+	};
+	void print() const
+	{
+		printf("\n Source(%s) id(%d)\n", name.c_str() ,sourceID);
+	    printf("\t availability(%d) availabilityReason(%d) sourceClassID(%d) domainID(%d) visible(%d) volume(%d) interruptState(%d) sourceState(%d) reserved(%d)\n",
+	    				available.availability, available.availabilityReason, sourceClassID, domainID, visible, volume, interruptState, sourceState,reserved);
+	};
+};
+
+struct am_Connection_Database_s : public am_Connection_s
+{
+	bool reserved;
+	am_Connection_Database_s():am_Connection_s(), reserved(true)
+	{};
+	am_Connection_Database_s & operator=(const am_Connection_Database_s & anObject)
+	{
+		if (this != &anObject)
+		{
+			am_Connection_s::operator=(anObject);
+			reserved = anObject.reserved;
+		}
+		return *this;
+	};
+	am_Connection_Database_s & operator=(const am_Connection_s & anObject)
+	{
+		if (this != &anObject)
+			am_Connection_s::operator=(anObject);
+		return *this;
+	};
+};
+
+struct am_Domain_Database_s : public am_Domain_s
+{
+	bool reserved;
+	am_Domain_Database_s():am_Domain_s(), reserved(false)
+	{};
+	am_Domain_Database_s & operator=(const am_Domain_Database_s & anObject)
+	{
+		if (this != &anObject)
+		{
+			am_Domain_s::operator=(anObject);
+			reserved = anObject.reserved;
+		}
+		return *this;
+	};
+	am_Domain_Database_s & operator=(const am_Domain_s & anObject)
+	{
+		if (this != &anObject)
+			am_Domain_s::operator=(anObject);
+		return *this;
+	};
+};
+
+struct am_MainConnection_Database_s : public am_MainConnection_s
+{
+	am_MainConnection_Database_s():am_MainConnection_s()
+	{};
+	void getMainConnectionType(am_MainConnectionType_s & connectionType) const
+	{
+		connectionType.mainConnectionID = mainConnectionID;
+		connectionType.sourceID = sourceID;
+		connectionType.sinkID = sinkID;
+		connectionType.connectionState = connectionState;
+		connectionType.delay = delay;
+	};
+	am_MainConnection_Database_s & operator=(const am_MainConnection_Database_s & anObject)
+	{
+		am_MainConnection_s::operator=(anObject);
+		return *this;
+	};
+	am_MainConnection_Database_s & operator=(const am_MainConnection_s & anObject)
+	{
+		am_MainConnection_s::operator=(anObject);
+		return *this;
+	};
+};
+
+/**
+ * This class handles and abstracts the database
+ */
+class CAmMapHandler : public CAmDatabaseHandlerInterface
+{
+public:
+	CAmMapHandler();
+    ~CAmMapHandler();
+    am_Error_e enterDomainDB(const am_Domain_s& domainData, am_domainID_t& domainID);
+    am_Error_e enterMainConnectionDB(const am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID);
+    am_Error_e enterSinkDB(const am_Sink_s& sinkData, am_sinkID_t& sinkID);
+    am_Error_e enterCrossfaderDB(const am_Crossfader_s& crossfaderData, am_crossfaderID_t& crossfaderID);
+    am_Error_e enterGatewayDB(const am_Gateway_s& gatewayData, am_gatewayID_t& gatewayID);
+    am_Error_e enterSourceDB(const am_Source_s& sourceData, am_sourceID_t& sourceID);
+    am_Error_e enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID);
+    am_Error_e enterSinkClassDB(const am_SinkClass_s& sinkClass, am_sinkClass_t& sinkClassID);
+    am_Error_e enterSourceClassDB(am_sourceClass_t& sourceClassID, const am_SourceClass_s& sourceClass);
+    am_Error_e enterSystemProperties(const std::vector<am_SystemProperty_s>& listSystemProperties);
+    am_Error_e changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID);
+    am_Error_e changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState);
+    am_Error_e changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID);
+    am_Error_e changeSinkAvailabilityDB(const am_Availability_s& availability, const am_sinkID_t sinkID);
+    am_Error_e changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID);
+    am_Error_e changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID);
+    am_Error_e changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sinkID_t sinkID);
+    am_Error_e changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sourceID_t sourceID);
+    am_Error_e changeSourceSoundPropertyDB(const am_SoundProperty_s& soundProperty, const am_sourceID_t sourceID);
+    am_Error_e changeSinkSoundPropertyDB(const am_SoundProperty_s& soundProperty, const am_sinkID_t sinkID);
+    am_Error_e changeSourceAvailabilityDB(const am_Availability_s& availability, const am_sourceID_t sourceID);
+    am_Error_e changeSystemPropertyDB(const am_SystemProperty_s& property);
+    am_Error_e changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID);
+    am_Error_e changeSinkClassInfoDB(const am_SinkClass_s& sinkClass);
+    am_Error_e changeSourceClassInfoDB(const am_SourceClass_s& sourceClass);
+    am_Error_e changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay);
+    am_Error_e changeConnectionFinal(const am_connectionID_t connectionID);
+    am_Error_e changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState);
+    am_Error_e changeSinkVolume(const am_sinkID_t sinkID, const am_volume_t volume);
+    am_Error_e changeSourceVolume(const am_sourceID_t sourceID, const am_volume_t volume);
+    am_Error_e changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink);
+    am_Error_e removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID);
+    am_Error_e removeSinkDB(const am_sinkID_t sinkID);
+    am_Error_e removeSourceDB(const am_sourceID_t sourceID);
+    am_Error_e removeGatewayDB(const am_gatewayID_t gatewayID);
+    am_Error_e removeCrossfaderDB(const am_crossfaderID_t crossfaderID);
+    am_Error_e removeDomainDB(const am_domainID_t domainID);
+    am_Error_e removeSinkClassDB(const am_sinkClass_t sinkClassID);
+    am_Error_e removeSourceClassDB(const am_sourceClass_t sourceClassID);
+    am_Error_e removeConnection(const am_connectionID_t connectionID);
+    am_Error_e getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s& classInfo) const;
+    am_Error_e getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s& sinkClass) const;
+    am_Error_e getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s& gatewayData) const;
+    am_Error_e getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s& sinkData) const;
+    am_Error_e getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s& sourceData) const;
+    am_Error_e getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData) const;
+    am_Error_e getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData) const;
+    am_Error_e getSinkVolume(const am_sinkID_t sinkID, am_volume_t& volume) const;
+    am_Error_e getSourceVolume(const am_sourceID_t sourceID, am_volume_t& volume) const;
+    am_Error_e getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_SoundPropertyType_e propertyType, int16_t& value) const;
+    am_Error_e getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_SoundPropertyType_e propertyType, int16_t& value) const;
+    am_Error_e getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t>& listSinkID) const;
+    am_Error_e getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t>& listSourceID) const;
+    am_Error_e getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t>& listGatewaysID) const;
+    am_Error_e getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t>& listGatewaysID) const;
+    am_Error_e getListMainConnections(std::vector<am_MainConnection_s>& listMainConnections) const;
+    am_Error_e getListDomains(std::vector<am_Domain_s>& listDomains) const;
+    am_Error_e getListConnections(std::vector<am_Connection_s>& listConnections) const;
+    am_Error_e getListSinks(std::vector<am_Sink_s>& listSinks) const;
+    am_Error_e getListSources(std::vector<am_Source_s>& lisSources) const;
+    am_Error_e getListSourceClasses(std::vector<am_SourceClass_s>& listSourceClasses) const;
+    am_Error_e getListCrossfaders(std::vector<am_Crossfader_s>& listCrossfaders) const;
+    am_Error_e getListGateways(std::vector<am_Gateway_s>& listGateways) const;
+    am_Error_e getListSinkClasses(std::vector<am_SinkClass_s>& listSinkClasses) const;
+    am_Error_e getListVisibleMainConnections(std::vector<am_MainConnectionType_s>& listConnections) const;
+    am_Error_e getListMainSinks(std::vector<am_SinkType_s>& listMainSinks) const;
+    am_Error_e getListMainSources(std::vector<am_SourceType_s>& listMainSources) const;
+    am_Error_e getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s>& listSoundProperties) const;
+    am_Error_e getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s>& listSourceProperties) const;
+    am_Error_e getListSystemProperties(std::vector<am_SystemProperty_s>& listSystemProperties) const;
+    am_Error_e getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const;
+    am_Error_e getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const;
+    am_Error_e getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> & listConnectionFormat) const;
+    am_Error_e getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay) const;
+    am_Error_e getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t& domainID) const;
+    am_Error_e getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t& domainID) const;
+    am_Error_e getSoureState(const am_sourceID_t sourceID, am_SourceState_e& sourceState) const;
+    am_Error_e getDomainState(const am_domainID_t domainID, am_DomainState_e& state) const;
+    am_Error_e getRoutingTree(bool onlyfree, CAmRoutingTree& tree, std::vector<CAmRoutingTreeItem*>& flatTree);
+    am_Error_e peekDomain(const std::string& name, am_domainID_t& domainID);
+    am_Error_e peekSink(const std::string& name, am_sinkID_t& sinkID);
+    am_Error_e peekSource(const std::string& name, am_sourceID_t& sourceID);
+    am_Error_e peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID);
+    am_Error_e peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID);
+    am_Error_e changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_ConnectionFormat_e>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties);
+    am_Error_e changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_ConnectionFormat_e>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties);
+    am_Error_e getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations);
+    am_Error_e getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations);
+    am_Error_e changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration);
+    am_Error_e changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration);
+    am_Error_e changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_ConnectionFormat_e>& listSourceConnectionFormats, const std::vector<am_ConnectionFormat_e>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix);
+    am_Error_e changeSinkNotificationConfigurationDB(const am_sinkID_t sinkID,const am_NotificationConfiguration_s notificationConfiguration);
+    am_Error_e changeSourceNotificationConfigurationDB(const am_sourceID_t sourceID,const am_NotificationConfiguration_s notificationConfiguration);
+
+    bool existMainConnection(const am_mainConnectionID_t mainConnectionID) const;
+    bool existcrossFader(const am_crossfaderID_t crossfaderID) const;
+    bool existConnection(const am_Connection_s & connection) const;
+    bool existConnectionID(const am_connectionID_t connectionID) const;
+    bool existSource(const am_sourceID_t sourceID) const;
+    bool existSourceNameOrID(const am_sourceID_t sourceID, const std::string& name) const;
+    bool existSourceName(const std::string& name) const;
+    bool existSink(const am_sinkID_t sinkID) const;
+    bool existSinkNameOrID(const am_sinkID_t sinkID, const std::string& name) const;
+    bool existSinkName(const std::string& name) const;
+    bool existDomain(const am_domainID_t domainID) const;
+    bool existGateway(const am_gatewayID_t gatewayID) const;
+    bool existSinkClass(const am_sinkClass_t sinkClassID) const;
+    bool existSourceClass(const am_sourceClass_t sourceClassID) const;
+    void registerObserver(CAmDatabaseObserver *iObserver);
+    bool sourceVisible(const am_sourceID_t sourceID) const;
+    bool sinkVisible(const am_sinkID_t sinkID) const;
+
+    void printSources();
+    void printSinks();
+    void printSinkClasses();
+    void printSourceClasses();
+private:
+
+    typedef std::map<am_domainID_t, am_Domain_Database_s>  		  			 CAmMapDomain;
+    typedef std::map<am_sourceClass_t, am_SourceClass_s> 		   			 CAmMapSourceClass;
+    typedef std::map<am_sinkClass_t, am_SinkClass_s> 		  	       		 CAmMapSinkClass;
+    typedef std::map<am_sinkID_t, am_Sink_Database_s> 			   			 CAmMapSink;
+    typedef std::map<am_sourceID_t, am_Source_Database_s> 		 			 CAmMapSource;
+    typedef std::map<am_gatewayID_t, am_Gateway_s> 			 	 			 CAmMapGateway;
+    typedef std::map<am_crossfaderID_t, am_Crossfader_s> 		   			 CAmMapCrossfader;
+    typedef std::map<am_connectionID_t, am_Connection_Database_s>			 CAmMapConnection;
+    typedef std::map<am_mainConnectionID_t, am_MainConnection_Database_s> 	 CAmMapMainConnection;
+    typedef std::vector<am_SystemProperty_s> 	   				 			 CAmVectorSystemProperties;
+    typedef struct CAmMappedData
+    {
+    	int16_t mCurrentDomainID;
+    	int16_t mCurrentSourceClassesID;
+    	int16_t mCurrentSinkClassesID;
+    	int16_t mCurrentSinkID;
+    	int16_t mCurrentSourceID;
+    	int16_t mCurrentGatewayID;
+    	int16_t mCurrentCrossfaderID;
+    	int16_t mCurrentConnectionID;
+    	int16_t mCurrentMainConnectionID;
+    	int16_t mDefaultIDLimit;
+
+    	CAmVectorSystemProperties mSystemProperties;
+    	CAmMapDomain mDomainMap;
+    	CAmMapSourceClass mSourceClassesMap;
+    	CAmMapSinkClass mSinkClassesMap;
+    	CAmMapSink mSinkMap;
+    	CAmMapSource mSourceMap;
+    	CAmMapGateway mGatewayMap;
+    	CAmMapCrossfader mCrossfaderMap;
+    	CAmMapConnection mConnectionMap;
+    	CAmMapMainConnection mMainConnectionMap;
+
+    	CAmMappedData(): //For Domain, MainConnections, Connections we don't have static IDs.
+    		mCurrentDomainID(1), mCurrentSourceClassesID(DYNAMIC_ID_BOUNDARY), mCurrentSinkClassesID(DYNAMIC_ID_BOUNDARY),
+    		mCurrentSinkID(DYNAMIC_ID_BOUNDARY), mCurrentSourceID(DYNAMIC_ID_BOUNDARY), mCurrentGatewayID(DYNAMIC_ID_BOUNDARY),
+    		mCurrentCrossfaderID(DYNAMIC_ID_BOUNDARY), mCurrentConnectionID(1), mCurrentMainConnectionID(1),
+    		mDefaultIDLimit(SHRT_MAX),
+
+    		mSystemProperties(),
+			mDomainMap(),mSourceClassesMap(), mSinkClassesMap(), mSinkMap(), mSourceMap(),
+			mGatewayMap(), mCrossfaderMap(), mConnectionMap(), mMainConnectionMap()
+    	{};
+
+    	bool increaseID(int16_t * resultID, int16_t * sourceID, int16_t const desiredStaticID = 0, int16_t const preferedStaticIDBoundary = DYNAMIC_ID_BOUNDARY)
+    	{
+    		if( desiredStaticID > 0 && desiredStaticID < preferedStaticIDBoundary )
+    		{
+				*resultID = desiredStaticID;
+				return true;
+    		}
+    		else if( *sourceID < mDefaultIDLimit-1 ) //SHRT_MAX or the max limit is reserved and not used!!!
+    		{
+    			*resultID = (*sourceID)++;
+    			return true;
+    		}
+    		else
+    		{
+    			*resultID = -1;
+    			return false;
+    		}
+    	 };
+    } CAmMappedData;
+
+
+    CAmMappedData mMappedData;
+
+    am_timeSync_t calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const; //!< calculates a new main connection delay
+    int16_t calculateDelayForRoute(const std::vector<am_connectionID_t>& listConnectionID);
+    bool insertSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID);
+    bool insertCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID);
+    bool insertGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID);
+    bool insertSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID);
+    bool insertSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID);
+    bool insertSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass);
+};
+
+}
+
+#endif /* MAPHANDLER_H_ */
diff --git a/AudioManagerDaemon/include/CAmRouter.h b/AudioManagerDaemon/include/CAmRouter.h
index 7268f3c..ca04d6a 100644
--- a/AudioManagerDaemon/include/CAmRouter.h
+++ b/AudioManagerDaemon/include/CAmRouter.h
@@ -27,7 +27,7 @@
 namespace am
 {
 
-class CAmDatabaseHandler;
+class CAmDatabaseHandlerInterface;
 class CAmControlSender;
 
 /**
@@ -36,7 +36,7 @@ class CAmControlSender;
 class CAmRouter
 {
 public:
-    CAmRouter(CAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iSender);
+    CAmRouter(CAmDatabaseHandlerInterface* iDatabaseHandler, CAmControlSender* iSender);
     ~CAmRouter();
     am_Error_e getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList);
 
@@ -44,7 +44,7 @@ private:
     am_Error_e findBestWay(am_sinkID_t sinkID, am_sourceID_t sourceID, std::vector<am_RoutingElement_s>& listRoute, std::vector<am_RoutingElement_s>::iterator routeIterator, std::vector<am_gatewayID_t>::iterator gatewayIterator);
     void listPossibleConnectionFormats(const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e>& listFormats) const;
     void listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID, const am_ConnectionFormat_e sinkConnectionFormat, std::vector<am_ConnectionFormat_e>& listFormats) const;
-    CAmDatabaseHandler* mpDatabaseHandler; //!< pointer to database handler
+    CAmDatabaseHandlerInterface* mpDatabaseHandler; //!< pointer to database handler
     CAmControlSender* mpControlSender; //!< pointer the controlsender - is used to retrieve information for the optimal route
 };
 
diff --git a/AudioManagerDaemon/include/CAmRoutingReceiver.h b/AudioManagerDaemon/include/CAmRoutingReceiver.h
index dbb90a4..4d1493a 100644
--- a/AudioManagerDaemon/include/CAmRoutingReceiver.h
+++ b/AudioManagerDaemon/include/CAmRoutingReceiver.h
@@ -29,7 +29,7 @@ namespace am
 
 class CAmSocketHandler;
 class CAmDbusWrapper;
-class CAmDatabaseHandler;
+class CAmDatabaseHandlerInterface;
 class CAmRoutingSender;
 class CAmControlSender;
 
@@ -39,8 +39,8 @@ class CAmControlSender;
 class CAmRoutingReceiver: public IAmRoutingReceive
 {
 public:
-    CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler);
-    CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper);
+    CAmRoutingReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler);
+    CAmRoutingReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper);
     ~CAmRoutingReceiver();
     void ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error);
     void ackDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error);
@@ -97,7 +97,7 @@ public:
     void waitOnRundown(bool rundown); //!< tells the RoutingReceiver to start waiting for all handles to be confirmed
 
 private:
-    CAmDatabaseHandler *mpDatabaseHandler; //!< pointer to the databaseHandler
+    CAmDatabaseHandlerInterface *mpDatabaseHandler; //!< pointer to the databaseHandler
     CAmRoutingSender *mpRoutingSender; //!< pointer to the routingSender
     CAmControlSender *mpControlSender; //!< pointer to the controlSender
     CAmSocketHandler *mpSocketHandler; //!< pointer to sockethandler
diff --git a/AudioManagerDaemon/src/CAmCommandReceiver.cpp b/AudioManagerDaemon/src/CAmCommandReceiver.cpp
index 486693f..491cf6e 100644
--- a/AudioManagerDaemon/src/CAmCommandReceiver.cpp
+++ b/AudioManagerDaemon/src/CAmCommandReceiver.cpp
@@ -22,7 +22,7 @@
 #include "CAmCommandReceiver.h"
 #include <cassert>
 #include <algorithm>
-#include "CAmDatabaseHandler.h"
+#include "CAmDatabaseHandlerInterface.h"
 #include "CAmControlSender.h"
 #include "shared/CAmDltWrapper.h"
 #include "shared/CAmSocketHandler.h"
@@ -30,7 +30,7 @@
 namespace am
 {
 
-CAmCommandReceiver::CAmCommandReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
+CAmCommandReceiver::CAmCommandReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
         mDatabaseHandler(iDatabaseHandler), //
         mControlSender(iControlSender), //
         mDBusWrapper(NULL), //
@@ -49,7 +49,7 @@ CAmCommandReceiver::CAmCommandReceiver(CAmDatabaseHandler *iDatabaseHandler, CAm
     assert(mControlSender!=NULL);
 }
 
-CAmCommandReceiver::CAmCommandReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
+CAmCommandReceiver::CAmCommandReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
         mDatabaseHandler(iDatabaseHandler), //
         mControlSender(iControlSender), //
         mDBusWrapper(iDBusWrapper), //
diff --git a/AudioManagerDaemon/src/CAmControlReceiver.cpp b/AudioManagerDaemon/src/CAmControlReceiver.cpp
index 18c5b6f..99aa988 100644
--- a/AudioManagerDaemon/src/CAmControlReceiver.cpp
+++ b/AudioManagerDaemon/src/CAmControlReceiver.cpp
@@ -24,7 +24,7 @@
 #include <stdlib.h>
 #include <stdexcept>
 #include "config.h"
-#include "CAmDatabaseHandler.h"
+#include "CAmDatabaseHandlerInterface.h"
 #include "CAmRoutingSender.h"
 #include "CAmCommandSender.h"
 #include "CAmRouter.h"
@@ -38,7 +38,7 @@
 
 namespace am {
 
-CAmControlReceiver::CAmControlReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter, CAmNodeStateCommunicator* iNodeStateCommunicator) :
+CAmControlReceiver::CAmControlReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter, CAmNodeStateCommunicator* iNodeStateCommunicator) :
         mDatabaseHandler(iDatabaseHandler), //
         mRoutingSender(iRoutingSender), //
         mCommandSender(iCommandSender), //
@@ -54,7 +54,7 @@ CAmControlReceiver::CAmControlReceiver(CAmDatabaseHandler *iDatabaseHandler, CAm
     assert(iNodeStateCommunicator!=NULL);
 }
 
-CAmControlReceiver::CAmControlReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter) :
+CAmControlReceiver::CAmControlReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmCommandSender *iCommandSender, CAmSocketHandler *iSocketHandler, CAmRouter* iRouter) :
         mDatabaseHandler(iDatabaseHandler), //
         mRoutingSender(iRoutingSender), //
         mCommandSender(iCommandSender), //
diff --git a/AudioManagerDaemon/src/CAmDatabaseHandler.cpp b/AudioManagerDaemon/src/CAmDatabaseHandler.cpp
index 4f1c5c0..75e3872 100644
--- a/AudioManagerDaemon/src/CAmDatabaseHandler.cpp
+++ b/AudioManagerDaemon/src/CAmDatabaseHandler.cpp
@@ -135,17 +135,15 @@ inline std::string i2s(T const& x)
     return (o.str());
 }
 
-CAmDatabaseHandler::CAmDatabaseHandler(std::string databasePath) :
+CAmDatabaseHandler::CAmDatabaseHandler():CAmDatabaseHandlerInterface()
+{
+	mpDatabase = NULL;
+	mPath = std::string("");
+}
+
+CAmDatabaseHandler::CAmDatabaseHandler(std::string databasePath):CAmDatabaseHandlerInterface(),
         mpDatabase(NULL), //
-        mPath(databasePath), //
-        mpDatabaseObserver(NULL), //
-        mFirstStaticSink(true), //
-        mFirstStaticSource(true), //
-        mFirstStaticGateway(true), //
-        mFirstStaticSinkClass(true), //
-        mFirstStaticSourceClass(true), //
-        mFirstStaticCrossfader(true), //
-        mListConnectionFormat()
+        mPath(databasePath)
 {
 
     std::ifstream infile(mPath.c_str());
@@ -3844,7 +3842,7 @@ bool CAmDatabaseHandler::sinkVisible(const am_sinkID_t sinkID) const
  * @param connection the connection to be checked
  * @return true if connections exists
  */
-bool CAmDatabaseHandler::existConnection(const am_Connection_s connection)
+bool CAmDatabaseHandler::existConnection(const am_Connection_s & connection) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT connectionID FROM " + std::string(CONNECTION_TABLE) + " WHERE sinkID=? AND sourceID=? AND connectionFormat=? AND reserved=0";
@@ -3887,7 +3885,7 @@ bool CAmDatabaseHandler::existConnection(const am_Connection_s connection)
  * @param connectionID
  * @return true if connection exits
  */
-bool CAmDatabaseHandler::existConnectionID(const am_connectionID_t connectionID)
+bool CAmDatabaseHandler::existConnectionID(const am_connectionID_t connectionID) const
 {
     sqlite3_stmt* query = NULL;
     std::string command = "SELECT connectionID FROM " + std::string(CONNECTION_TABLE) + " WHERE connectionID=? AND reserved=0";
diff --git a/AudioManagerDaemon/src/CAmMapHandler.cpp b/AudioManagerDaemon/src/CAmMapHandler.cpp
new file mode 100644
index 0000000..608038a
--- /dev/null
+++ b/AudioManagerDaemon/src/CAmMapHandler.cpp
@@ -0,0 +1,2520 @@
+/**
+ * Copyright (C) 2012, BMW AG
+ *
+ * This file is part of GENIVI Project AudioManager.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
+ *
+ * \file CAmDatabaseHandler.cpp
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#include "CAmMapHandler.h"
+#include <cassert>
+#include <stdexcept>
+#include <vector>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <algorithm>
+#include <limits>
+#include "CAmDatabaseObserver.h"
+#include "CAmRouter.h"
+#include "shared/CAmDltWrapper.h"
+
+
+namespace am
+{
+
+template <typename TMapKeyType, class TMapObjectType> TMapObjectType const * objectWithKeyIfExistsInMap(const TMapKeyType & key, const std::map<TMapKeyType,TMapObjectType> & map)
+{
+	typename std::map<TMapKeyType,TMapObjectType>::const_iterator iter = map.find(key);
+	if( iter!=map.end() )
+		return (TMapObjectType const *)&iter->second;
+	return NULL;
+}
+
+template <typename TMapKeyType, class TMapObjectType> bool existsObjectWithKeyInMap(const TMapKeyType & key, const std::map<TMapKeyType,TMapObjectType> & map)
+{
+	return objectWithKeyIfExistsInMap(key, map)!=NULL;
+}
+
+typedef bool (*CAmCompareObjectWithValue)(const void *, const void *, void *);
+
+template <typename TMapKeyType, class TMapObjectType, class TSearchObjectType>
+TMapObjectType const * findFirstObjectMatchingCriteria(const std::map<TMapKeyType, TMapObjectType> & aMap,
+															  const TSearchObjectType & aComparison,
+															  CAmCompareObjectWithValue comparator,
+															  void *context = NULL)
+{
+	typename std::map<TMapKeyType, TMapObjectType>::const_iterator it = aMap.begin();
+	TMapObjectType * result = NULL;
+	for (; it != aMap.end(); ++it)
+	{
+		const void * obj1 = (const void *)&it->second;
+		const void * obj2 = (const void *)&aComparison;
+		if (comparator(obj1, obj2, context))
+		{
+			result = (TMapObjectType *)&it->second;
+			break;
+		}
+	}
+	return result;
+}
+
+bool compareSinkObjectByName(const void *anObject, const void *aValue, void *)
+{
+	return (anObject && aValue)?((const std::string *)aValue)->compare(((const am_Sink_Database_s *)anObject)->name)==0:false;
+}
+
+bool compareSourceObjectByName(const void *anObject, const void *aValue, void *)
+{
+	return (anObject && aValue)?((const std::string *)aValue)->compare(((const am_Source_Database_s *)anObject)->name)==0:false;
+}
+
+bool compareSinkClassObjectByName(const void *anObject, const void *aValue, void *)
+{
+	return (anObject && aValue)?((const std::string *)aValue)->compare(((const am_SinkClass_s *)anObject)->name)==0:false;
+}
+
+bool compareSourceClassObjectByName(const void *anObject, const void *aValue, void *)
+{
+	return (anObject && aValue)?((const std::string *)aValue)->compare(((const am_SourceClass_s *)anObject)->name)==0:false;
+}
+
+bool compareDomainObjectWithValue(const void *anObject, const void *aValue, void *)
+{
+	return (anObject && aValue)?((const std::string *)aValue)->compare(((const am_Domain_s *)anObject)->name)==0:false;
+}
+
+bool compareSinkObjectByNameAndFlag(const void *anObject, const void *aValue, void *contextOrNull)
+{
+	if(anObject && aValue)
+	{
+		bool flag = (contextOrNull!=NULL)?*((bool*)contextOrNull):true;
+		return flag==((const am_Sink_Database_s *)anObject)->reserved &&
+				((const std::string *)aValue)->compare(((const am_Sink_s *)anObject)->name)==0;
+	}
+	return false;
+}
+
+bool compareConnectionObjectsWithObject(const void *anObject, const void *aValue, void *)
+{
+	if(anObject && aValue)
+	{
+		return 0==((const am_Connection_Database_s *)anObject)->reserved &&
+				((const am_Connection_Database_s *)aValue)->sinkID == ((const am_Connection_Database_s *)anObject)->sinkID &&
+				((const am_Connection_Database_s *)aValue)->sourceID == ((const am_Connection_Database_s *)anObject)->sourceID &&
+				((const am_Connection_Database_s *)aValue)->connectionFormat == ((const am_Connection_Database_s *)anObject)->connectionFormat;
+	}
+	return false;
+}
+
+bool compareSourceObjectsByNameAndFlag(const void *anObject, const void *aValue, void *contextOrNull)
+{
+	if(anObject && aValue)
+	{
+		bool flag = (contextOrNull!=NULL)?*((bool*)contextOrNull):true;
+		return flag==((const am_Source_Database_s *)anObject)->reserved &&
+				((const std::string *)aValue)->compare(((const am_Source_Database_s *)anObject)->name)==0;
+	}
+	return false;
+}
+
+template <typename TMapKeyType, class TMapObjectType>
+void makeFirstStaticEntry(uint16_t & index, uint16_t & identifier, std::map <TMapKeyType, TMapObjectType> & storageMap)
+{
+	identifier = DYNAMIC_ID_BOUNDARY;
+	if(index!=identifier)
+	{
+		storageMap[identifier] = storageMap[index];
+		storageMap.erase(index);
+		index = identifier;
+	}
+}
+
+/**
+ * template to converts T to std::string
+ * @param x T
+ * @return string
+ */
+template<typename T>
+inline std::string i2s(T const& x)
+{
+    std::ostringstream o;
+    o << x;
+    return (o.str());
+}
+
+CAmMapHandler::CAmMapHandler():CAmDatabaseHandlerInterface(), mMappedData()
+{
+	logInfo(__PRETTY_FUNCTION__,"Init");
+}
+
+CAmMapHandler::~CAmMapHandler()
+{
+    logInfo(__PRETTY_FUNCTION__,"Destroy");
+}
+
+am_Error_e CAmMapHandler::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
+{
+    assert(domainData.domainID==0);
+    assert(!domainData.name.empty());
+    assert(!domainData.busname.empty());
+    assert(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX);
+
+    //first check for a reserved domain
+    CAmCompareObjectWithValue comparator = compareDomainObjectWithValue;
+    am_Domain_s const *reservedDomain = findFirstObjectMatchingCriteria(mMappedData.mDomainMap, domainData.name, comparator);
+
+    int16_t nextID = 0;
+    if( NULL != reservedDomain )
+    {
+    	nextID = reservedDomain->domainID;
+    	domainID = nextID;
+    	mMappedData.mDomainMap[nextID] = domainData;
+    	mMappedData.mDomainMap[nextID].domainID = nextID;
+    	mMappedData.mDomainMap[nextID].reserved = 0;
+    	return (E_OK);
+    }
+    else
+    {
+		if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentDomainID, domainData.domainID))
+		{
+			domainID = nextID;
+			mMappedData.mDomainMap[nextID] = domainData;
+			mMappedData.mDomainMap[nextID].domainID = nextID;
+
+			logInfo("DatabaseHandler::enterDomainDB entered new domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "assigned ID:", domainID);
+
+			if (mpDatabaseObserver)
+				mpDatabaseObserver->newDomain(mMappedData.mDomainMap[nextID]);
+			return (E_OK);
+		}
+		else
+		{
+			domainID = 0;
+			logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+			return (E_MAX);
+		}
+    }
+}
+
+int16_t CAmMapHandler::calculateDelayForRoute(const std::vector<am_connectionID_t>& listConnectionID)
+{
+	int16_t delay = 0;
+	std::vector<am_connectionID_t>::const_iterator elementIterator = listConnectionID.begin();
+	for (; elementIterator < listConnectionID.end(); ++elementIterator)
+	{
+		am_connectionID_t key = *elementIterator;
+		std::map<am_connectionID_t, am_Connection_Database_s>::const_iterator it = mMappedData.mConnectionMap.find(key);
+		if (it!=mMappedData.mConnectionMap.end())
+		{
+			int16_t temp_delay = it->second.delay;
+			if (temp_delay != -1 && delay != -1)
+				delay += temp_delay;
+			else
+				delay = -1;
+		}
+	}
+	return delay;
+}
+
+am_Error_e CAmMapHandler::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
+{
+    assert(mainConnectionData.mainConnectionID==0);
+    assert(mainConnectionData.connectionState>=CS_UNKNOWN && mainConnectionData.connectionState<=CS_MAX);
+    assert(mainConnectionData.sinkID!=0);
+    assert(mainConnectionData.sourceID!=0);
+
+    int16_t delay = 0;
+    int16_t nextID = 0;
+	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentMainConnectionID, mainConnectionData.mainConnectionID))
+	{
+		connectionID = nextID;
+		mMappedData.mMainConnectionMap[nextID] = mainConnectionData;
+		mMappedData.mMainConnectionMap[nextID].mainConnectionID = nextID;
+	}
+	else
+	{
+		connectionID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+		return (E_MAX);
+	}
+
+    //now check the connectionTable for all connections in the route. IF connectionID exist
+     delay = calculateDelayForRoute(mainConnectionData.listConnectionID);
+
+    logInfo("DatabaseHandler::enterMainConnectionDB entered new mainConnection with sourceID", mainConnectionData.sourceID, "sinkID:", mainConnectionData.sinkID, "delay:", delay, "assigned ID:", connectionID);
+
+    if (mpDatabaseObserver)
+    {
+        am_MainConnectionType_s mainConnection;
+        mainConnection.mainConnectionID = connectionID;
+        mainConnection.connectionState = mainConnectionData.connectionState;
+        mainConnection.delay = delay;
+        mainConnection.sinkID = mainConnectionData.sinkID;
+        mainConnection.sourceID = mainConnectionData.sourceID;
+        mpDatabaseObserver->newMainConnection(mainConnection);
+        mpDatabaseObserver->mainConnectionStateChanged(connectionID, mainConnectionData.connectionState);
+    }
+
+    //finally, we update the delay value for the maintable
+    if (delay == 0)
+        delay = -1;
+    return (changeDelayMainConnection(delay, connectionID));
+}
+
+/**
+ * Helper method, that inserts a new struct in the map and copies the given into it.
+ * This method uses the increaseID function to secure the global id is properly increased.
+ **/
+bool CAmMapHandler::insertSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+{
+    int16_t nextID = 0;
+	if(  mMappedData.increaseID(&nextID, &mMappedData.mCurrentSinkID, sinkData.sinkID) )
+	{
+		sinkID = nextID;
+		mMappedData.mSinkMap[nextID] = sinkData;
+		mMappedData.mSinkMap[nextID].sinkID = nextID;
+		return (true);
+	}
+	else
+	{
+		sinkID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached!");
+		return (false);
+	}
+}
+
+am_Error_e CAmMapHandler::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+{
+    assert(sinkData.sinkID<DYNAMIC_ID_BOUNDARY);
+    assert(sinkData.domainID!=0);
+    assert(!sinkData.name.empty());
+    assert(sinkData.sinkClassID!=0);
+    //todo: need to check if class exists?,
+    assert(!sinkData.listConnectionFormats.empty());
+    assert(sinkData.muteState>=MS_UNKNOWN && sinkData.muteState<=MS_MAX);
+
+    am_sinkID_t temp_SinkID = 0;
+    am_sinkID_t temp_SinkIndex = 0;
+	//if sinkID is zero and the first Static Sink was already entered, the ID is created
+    CAmCompareObjectWithValue comparator = compareSinkObjectByNameAndFlag;
+    bool checkForFlag = true;
+    am_Sink_s const *reservedDomain = findFirstObjectMatchingCriteria(mMappedData.mSinkMap, sinkData.name, comparator, &checkForFlag);
+    if( NULL!=reservedDomain )
+    {
+    	am_sinkID_t oldSinkID = reservedDomain->sinkID;
+    	mMappedData.mSinkMap[oldSinkID] = sinkData;
+    	mMappedData.mSinkMap[oldSinkID].reserved = 0;
+    	temp_SinkID = oldSinkID;
+    	temp_SinkIndex = oldSinkID;
+    }
+    else
+    {
+		bool result;
+		if ( sinkData.sinkID != 0 || mFirstStaticSink )
+		{
+			//check if the ID already exists
+			if (existSinkNameOrID(sinkData.sinkID, sinkData.name))
+				return (E_ALREADY_EXISTS);
+		}
+		result = insertSinkDB(sinkData, temp_SinkID);
+		if( false == result )
+			return (E_MAX);
+		temp_SinkIndex = temp_SinkID;
+    }
+    //if the first static sink is entered, we need to set it onto the boundary
+    if (sinkData.sinkID == 0 && mFirstStaticSink)
+    {
+        mFirstStaticSink = false;
+    }
+    mMappedData.mSinkMap[temp_SinkIndex].sinkID = temp_SinkID;
+    sinkID = temp_SinkID;
+
+    am_Sink_s sink = mMappedData.mSinkMap[temp_SinkID];
+    logInfo("DatabaseHandler::enterSinkDB entered new sink with name", sink.name, "domainID:", sink.domainID, "classID:", sink.sinkClassID, "volume:", sink.volume, "assigned ID:", sinkID);
+
+    if (mpDatabaseObserver != NULL)
+        mpDatabaseObserver->newSink(sink);
+    return (E_OK);
+}
+
+bool CAmMapHandler::insertCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+{
+    int16_t nextID = 0;
+	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentCrossfaderID, crossfaderData.crossfaderID))
+	{
+		crossfaderID = nextID;
+		mMappedData.mCrossfaderMap[nextID] = crossfaderData;
+		mMappedData.mCrossfaderMap[nextID].crossfaderID = nextID;
+		return (true);
+	}
+	else
+	{
+		crossfaderID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+		return (false);
+	}
+}
+
+am_Error_e CAmMapHandler::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+{
+    assert(crossfaderData.crossfaderID<DYNAMIC_ID_BOUNDARY);
+    assert(crossfaderData.hotSink>=HS_UNKNOWN && crossfaderData.hotSink<=HS_MAX);
+    assert(!crossfaderData.name.empty());
+    assert(existSink(crossfaderData.sinkID_A));
+    assert(existSink(crossfaderData.sinkID_B));
+    assert(existSource(crossfaderData.sourceID));
+
+    am_crossfaderID_t temp_CrossfaderID = 0;
+    am_crossfaderID_t temp_CrossfaderIndex = 0;
+
+    bool result;
+    //if gatewayData is zero and the first Static Sink was already entered, the ID is created
+    if (crossfaderData.crossfaderID != 0 || mFirstStaticCrossfader)
+    {
+        //check if the ID already exists
+        if (existcrossFader(crossfaderData.crossfaderID))
+            return (E_ALREADY_EXISTS);
+    }
+    result = insertCrossfaderDB(crossfaderData, temp_CrossfaderID);
+	if( false == result )
+		return (E_MAX);
+	temp_CrossfaderIndex = temp_CrossfaderID;
+
+    //if the first static sink is entered, we need to set it onto the boundary
+    if ( 0==crossfaderData.crossfaderID && mFirstStaticCrossfader)
+    {
+        mFirstStaticCrossfader = false;
+    }
+
+    mMappedData.mCrossfaderMap[temp_CrossfaderIndex].crossfaderID = temp_CrossfaderID;
+   crossfaderID = temp_CrossfaderID;
+   logInfo("DatabaseHandler::enterCrossfaderDB entered new crossfader with name=", crossfaderData.name, "sinkA= ", crossfaderData.sinkID_A, "sinkB=", crossfaderData.sinkID_B, "source=", crossfaderData.sourceID, "assigned ID:", crossfaderID);
+
+    am_Crossfader_s crossfader(crossfaderData);
+    crossfader.crossfaderID = crossfaderID;
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->newCrossfader(crossfader);
+    return (E_OK);
+}
+
+bool CAmMapHandler::insertGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+{
+    int16_t nextID = 0;
+	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentGatewayID, gatewayData.gatewayID))
+	{
+		gatewayID = nextID;
+		mMappedData.mGatewayMap[nextID] = gatewayData;
+		mMappedData.mGatewayMap[nextID].gatewayID = nextID;
+		return (true);
+	}
+	else
+	{
+		gatewayID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+		return (false);
+	}
+}
+
+am_Error_e CAmMapHandler::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+{
+    assert(gatewayData.gatewayID<DYNAMIC_ID_BOUNDARY);
+    assert(gatewayData.sinkID!=0);
+    assert(gatewayData.sourceID!=0);
+    assert(gatewayData.controlDomainID!=0);
+    assert(gatewayData.domainSinkID!=0);
+    assert(gatewayData.domainSourceID!=0);
+    assert(!gatewayData.name.empty());
+    assert(!gatewayData.convertionMatrix.empty());
+    assert(!gatewayData.listSinkFormats.empty());
+    assert(!gatewayData.listSourceFormats.empty());
+
+    //might be that the sinks and sources are not there during registration time
+    //assert(existSink(gatewayData.sinkID));
+    //assert(existSource(gatewayData.sourceID));
+
+    am_gatewayID_t temp_GatewayID = 0;
+    am_gatewayID_t temp_GatewayIndex = 0;
+    //if gatewayData is zero and the first Static Sink was already entered, the ID is created
+    bool result;
+    if (gatewayData.gatewayID != 0 || mFirstStaticGateway)
+    {
+        //check if the ID already exists
+        if (existGateway(gatewayData.gatewayID))
+            return (E_ALREADY_EXISTS);
+    }
+    result = insertGatewayDB(gatewayData, temp_GatewayID);
+	if( false == result )
+		return (E_MAX);
+
+	temp_GatewayIndex = temp_GatewayID;
+    //if the ID is not created, we add it to the query
+    if (gatewayData.gatewayID == 0 && mFirstStaticGateway)
+    {
+        mFirstStaticGateway = false;
+    }
+    mMappedData.mGatewayMap[temp_GatewayIndex].gatewayID = temp_GatewayID;
+    gatewayID = temp_GatewayID;
+
+    logInfo("DatabaseHandler::enterGatewayDB entered new gateway with name", gatewayData.name, "sourceID:", gatewayData.sourceID, "sinkID:", gatewayData.sinkID, "assigned ID:", gatewayID);
+    am_Gateway_s gateway = gatewayData;
+    gateway.gatewayID = gatewayID;
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->newGateway(gateway);
+    return (E_OK);
+}
+
+void CAmMapHandler::printSinks()
+{
+	CAmMapSink::const_iterator iter = mMappedData.mSinkMap.begin();
+	for(; iter!=mMappedData.mSinkMap.end(); iter++)
+	{
+		am_Sink_Database_s theItem = iter->second;
+		theItem.print();
+	}
+}
+
+void CAmMapHandler::printSinkClasses()
+{
+	CAmMapSinkClass::const_iterator iter = mMappedData.mSinkClassesMap.begin();
+	for(; iter!=mMappedData.mSinkClassesMap.end(); iter++)
+	{
+		am_SinkClass_s theItem = iter->second;
+		printf("\n CHECK SOURCE %d" , theItem.sinkClassID);
+		printf("\n %s ", theItem.name.c_str() );
+		printf("\n\n");
+	}
+}
+
+void CAmMapHandler::printSources()
+{
+	CAmMapSource::const_iterator iter = mMappedData.mSourceMap.begin();
+	for(; iter!=mMappedData.mSourceMap.end(); iter++)
+	{
+		am_Source_Database_s theItem = iter->second;
+		theItem.print();
+	}
+}
+
+void CAmMapHandler::printSourceClasses()
+{
+	CAmMapSourceClass::const_iterator iter = mMappedData.mSourceClassesMap.begin();
+	for(; iter!=mMappedData.mSourceClassesMap.end(); iter++)
+	{
+		am_SourceClass_s theItem = iter->second;
+		printf("\n CHECK SOURCE %d" , theItem.sourceClassID);
+		printf("\n %s ", theItem.name.c_str() );
+		printf("\n\n");
+	}
+}
+
+bool CAmMapHandler::insertSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+{
+    int16_t nextID = 0;
+	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentSourceID, sourceData.sourceID))
+	{
+		sourceID = nextID;
+		mMappedData.mSourceMap[nextID] = sourceData;
+		mMappedData.mSourceMap[nextID].sourceID = nextID;
+		return (true);
+	}
+	else
+	{
+		sourceID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+		return (false);
+	}
+}
+
+am_Error_e CAmMapHandler::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+{
+    assert(sourceData.sourceID<DYNAMIC_ID_BOUNDARY);
+    assert(sourceData.domainID!=0);
+    assert(!sourceData.name.empty());
+    assert(sourceData.sourceClassID!=0);
+    // \todo: need to check if class exists?
+    assert(!sourceData.listConnectionFormats.empty());
+    assert(sourceData.sourceState>=SS_UNKNNOWN && sourceData.sourceState<=SS_MAX);
+
+    bool isFirstStatic = sourceData.sourceID == 0 && mFirstStaticSource;
+    am_sourceID_t temp_SourceID = 0;
+    am_sourceID_t temp_SourceIndex = 0;
+    bool checkForFlag = true;
+    am_Source_Database_s const *reservedSource = findFirstObjectMatchingCriteria(mMappedData.mSourceMap, sourceData.name, compareSourceObjectsByNameAndFlag, &checkForFlag);
+	if( NULL != reservedSource )
+	{
+		am_sourceID_t oldSourceID = reservedSource->sourceID;
+		mMappedData.mSourceMap[oldSourceID] = sourceData;
+		mMappedData.mSourceMap[oldSourceID].reserved = 0;
+		temp_SourceID = oldSourceID;
+		temp_SourceIndex = oldSourceID;
+	}
+	else
+	{
+	    bool result;
+	    if ( !isFirstStatic )
+	    {
+	        //check if the ID already exists
+	    	 if (existSourceNameOrID(sourceData.sourceID, sourceData.name))
+	            return (E_ALREADY_EXISTS);
+	    }
+	    result = insertSourceDB(sourceData, temp_SourceID);
+		if( false == result )
+			return (E_MAX);
+		temp_SourceIndex = temp_SourceID;
+    }
+
+    if ( isFirstStatic )
+    {
+      //if the first static sink is entered, we need to set it onto the boundary if needed
+//    	makeFirstStaticEntry(temp_SourceIndex, temp_SourceID, mMappedData.mSinkMap); //Not necessary anymore
+        mFirstStaticSource = false;
+    }
+    mMappedData.mSourceMap[temp_SourceIndex].sourceID = temp_SourceID;
+    sourceID = temp_SourceID;
+
+    logInfo("DatabaseHandler::enterSourceDB entered new source with name", sourceData.name, "domainID:", sourceData.domainID, "classID:", sourceData.sourceClassID, "visible:", sourceData.visible, "assigned ID:", sourceID);
+
+    am_Source_s source = sourceData;
+    source.sourceID = sourceID;
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->newSource(source);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID)
+{
+    assert(connection.connectionID==0);
+    assert(connection.sinkID!=0);
+    assert(connection.sourceID!=0);
+    //connection format is not checked, because it's project specific
+    int16_t nextID = 0;
+    if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentConnectionID, connection.connectionID))
+	{
+		connectionID = nextID;
+		mMappedData.mConnectionMap[nextID] = connection;
+		mMappedData.mConnectionMap[nextID].connectionID = nextID;
+	}
+	else
+	{
+		connectionID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+		return (E_MAX);
+	}
+
+    logInfo("DatabaseHandler::enterConnectionDB entered new connection sourceID=", connection.sourceID, "sinkID=", connection.sinkID, "sourceID=", connection.sourceID, "connectionFormat=", connection.connectionFormat, "assigned ID=", connectionID);
+    return (E_OK);
+}
+
+bool CAmMapHandler::insertSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+{
+    int16_t nextID = 0;
+	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentSinkClassesID, sinkClass.sinkClassID))
+	{
+		sinkClassID = nextID;
+		mMappedData.mSinkClassesMap[nextID] = sinkClass;
+		mMappedData.mSinkClassesMap[nextID].sinkClassID = nextID;
+		return (true);
+	}
+	else
+	{
+		sinkClassID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+		return (false);
+	}
+}
+
+am_Error_e CAmMapHandler::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
+{
+    assert(sinkClass.sinkClassID<DYNAMIC_ID_BOUNDARY);
+    assert(!sinkClass.name.empty());
+
+    am_sinkClass_t temp_SinkClassID = 0;
+    am_sinkClass_t temp_SinkClassIndex = 0;
+
+	bool result;
+	if (sinkClass.sinkClassID != 0 || mFirstStaticSinkClass)
+	{
+		//check if the ID already exists
+		 if (existSinkClass(sinkClass.sinkClassID))
+			return (E_ALREADY_EXISTS);
+	}
+	result = insertSinkClassDB(sinkClass, temp_SinkClassID);
+	if( false == result )
+		return (E_MAX);
+
+	temp_SinkClassIndex = temp_SinkClassID;
+	//if the ID is not created, we add it to the query
+	if (sinkClass.sinkClassID == 0 && mFirstStaticSinkClass)
+	{
+//		makeFirstStaticEntry(temp_SinkClassIndex, temp_SinkClassID, mMappedData.mSinkClassesMap);
+		mFirstStaticSinkClass = false;
+	}
+	mMappedData.mSinkClassesMap[temp_SinkClassIndex].sinkClassID = temp_SinkClassID;
+	sinkClassID = temp_SinkClassID;
+
+    //todo:change last_insert implementations for multithreaded usage...
+    logInfo("DatabaseHandler::enterSinkClassDB entered new sinkClass");
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->numberOfSinkClassesChanged();
+    return (E_OK);
+}
+
+bool CAmMapHandler::insertSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
+{
+    int16_t nextID = 0;
+	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentSourceClassesID, sourceClass.sourceClassID))
+	{
+		sourceClassID = nextID;
+		mMappedData.mSourceClassesMap[nextID] = sourceClass;
+		mMappedData.mSourceClassesMap[nextID].sourceClassID = nextID;
+		return (true);
+	}
+	else
+	{
+		sourceClassID = 0;
+		logInfo(__PRETTY_FUNCTION__,"Max limit reached.");
+		return (false);
+	}
+}
+
+am_Error_e CAmMapHandler::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
+{
+    assert(sourceClass.sourceClassID<DYNAMIC_ID_BOUNDARY);
+    assert(!sourceClass.name.empty());
+
+    am_sourceClass_t temp_SourceClassID = 0;
+    am_sourceClass_t temp_SourceClassIndex = 0;
+
+	bool result;
+	if (sourceClass.sourceClassID != 0 || mFirstStaticSourceClass)
+	{
+		//check if the ID already exists
+		if (existSourceClass(sourceClass.sourceClassID))
+			return (E_ALREADY_EXISTS);
+	}
+	result = insertSourceClassDB(temp_SourceClassID, sourceClass);
+	if( false == result )
+		return (E_MAX);
+
+	temp_SourceClassIndex = temp_SourceClassID;
+	//if the ID is not created, we add it to the query
+	if (sourceClass.sourceClassID == 0 && mFirstStaticSourceClass)
+	{
+//		makeFirstStaticEntry(temp_SourceClassIndex, temp_SourceClassID, mMappedData.mSourceClassesMap);
+		mFirstStaticSinkClass = false;
+	}
+	mMappedData.mSourceClassesMap[temp_SourceClassIndex].sourceClassID = temp_SourceClassID;
+	sourceClassID = temp_SourceClassID;
+
+	//todo:change last_insert implementations for multithread usage...
+
+    logInfo("DatabaseHandler::enterSourceClassDB entered new sourceClass");
+
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->numberOfSourceClassesChanged();
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::enterSystemProperties(const std::vector<am_SystemProperty_s> & listSystemProperties)
+{
+    assert(!listSystemProperties.empty());
+
+    mMappedData.mSystemProperties = listSystemProperties;
+
+    logInfo("DatabaseHandler::enterSystemProperties entered system properties");
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
+{
+    assert(mainconnectionID!=0);
+    if (!existMainConnection(mainconnectionID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    int16_t delay = calculateDelayForRoute(listConnectionID);
+
+    //now we replace the data in the main connection object with the new one
+    mMappedData.mMainConnectionMap[mainconnectionID].listConnectionID = listConnectionID;
+
+    if (changeDelayMainConnection(delay,mainconnectionID)!=E_OK)
+        logError("DatabaseHandler::changeMainConnectionRouteDB error while changing mainConnectionDelay to ", delay);
+
+    logInfo("DatabaseHandler::changeMainConnectionRouteDB entered new route:", mainconnectionID);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
+{
+    assert(mainconnectionID!=0);
+    assert(connectionState>=CS_UNKNOWN && connectionState<=CS_MAX);
+
+    if (!existMainConnection(mainconnectionID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    mMappedData.mMainConnectionMap[mainconnectionID].connectionState = connectionState;
+
+    logInfo("DatabaseHandler::changeMainConnectionStateDB changed mainConnectionState of MainConnection:", mainconnectionID, "to:", connectionState);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->mainConnectionStateChanged(mainconnectionID, connectionState);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
+{
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mSinkMap[sinkID].mainVolume = mainVolume;
+
+    logInfo("DatabaseHandler::changeSinkMainVolumeDB changed mainVolume of sink:", sinkID, "to:", mainVolume);
+
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->volumeChanged(sinkID, mainVolume);
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
+{
+    assert(sinkID!=0);
+    assert(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX);
+    assert(availability.availabilityReason>=AR_UNKNOWN && availability.availabilityReason<=AR_MAX);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mSinkMap[sinkID].available = availability;
+
+    logInfo("DatabaseHandler::changeSinkAvailabilityDB changed sinkAvailability of sink:", sinkID, "to:", availability.availability, "Reason:", availability.availabilityReason);
+
+    if (mpDatabaseObserver && sourceVisible(sinkID))
+        mpDatabaseObserver->sinkAvailabilityChanged(sinkID, availability);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
+{
+    assert(domainID!=0);
+    assert(domainState>=DS_UNKNOWN && domainState<=DS_MAX);
+
+    if (!existDomain(domainID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mDomainMap[domainID].state = domainState;
+
+    logInfo("DatabaseHandler::changDomainStateDB changed domainState of domain:", domainID, "to:", domainState);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
+{
+    assert(sinkID!=0);
+    assert(muteState>=MS_UNKNOWN && muteState<=MS_MAX);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mSinkMap[sinkID].muteState = muteState;
+
+    logInfo("DatabaseHandler::changeSinkMuteStateDB changed sinkMuteState of sink:", sinkID, "to:", muteState);
+
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->sinkMuteStateChanged(sinkID, muteState);
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+{
+    assert(soundProperty.type>=MSP_UNKNOWN && soundProperty.type<=MSP_MAX);
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    std::vector<am_MainSoundProperty_s>::iterator elementIterator = mMappedData.mSinkMap[sinkID].listMainSoundProperties.begin();
+	for (;elementIterator != mMappedData.mSinkMap[sinkID].listMainSoundProperties.end(); ++elementIterator)
+	{
+		if (elementIterator->type == soundProperty.type)
+			elementIterator->value = soundProperty.value;
+	}
+
+    logInfo("DatabaseHandler::changeMainSinkSoundPropertyDB changed MainSinkSoundProperty of sink:", sinkID, "type:", soundProperty.type, "to:", soundProperty.value);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->mainSinkSoundPropertyChanged(sinkID, soundProperty);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+{
+    assert(soundProperty.type>=MSP_UNKNOWN && soundProperty.type<=MSP_MAX);
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    std::vector<am_MainSoundProperty_s>::iterator elementIterator = mMappedData.mSourceMap[sourceID].listMainSoundProperties.begin();
+	for (;elementIterator != mMappedData.mSourceMap[sourceID].listMainSoundProperties.end(); ++elementIterator)
+	{
+		if (elementIterator->type == soundProperty.type)
+			elementIterator->value = soundProperty.value;
+	}
+
+    logInfo("DatabaseHandler::changeMainSourceSoundPropertyDB changed MainSinkSoundProperty of source:", sourceID, "type:", soundProperty.type, "to:", soundProperty.value);
+
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->mainSourceSoundPropertyChanged(sourceID, soundProperty);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
+{
+    assert(sourceID!=0);
+    assert(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX);
+    assert(availability.availabilityReason>=AR_UNKNOWN && availability.availabilityReason<=AR_MAX);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mSourceMap[sourceID].available = availability;
+
+    logInfo("DatabaseHandler::changeSourceAvailabilityDB changed changeSourceAvailabilityDB of source:", sourceID, "to:", availability.availability, "Reason:", availability.availabilityReason);
+
+    if (mpDatabaseObserver && sourceVisible(sourceID))
+        mpDatabaseObserver->sourceAvailabilityChanged(sourceID, availability);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSystemPropertyDB(const am_SystemProperty_s & property)
+{
+    assert(property.type>=SYP_UNKNOWN && property.type<=SYP_MAX);
+
+    std::vector<am_SystemProperty_s>::iterator elementIterator = mMappedData.mSystemProperties.begin();
+	for (;elementIterator != mMappedData.mSystemProperties.end(); ++elementIterator)
+	{
+		if (elementIterator->type == property.type)
+			elementIterator->value = property.value;
+	}
+
+    logInfo("DatabaseHandler::changeSystemPropertyDB changed system property");
+
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->systemPropertyChanged(property);
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
+{
+    assert(mainConnectionID!=0);
+
+    if (!existMainConnection(mainConnectionID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mMainConnectionMap.erase(mainConnectionID);
+
+    logInfo("DatabaseHandler::removeMainConnectionDB removed:", mainConnectionID);
+    if (mpDatabaseObserver)
+    {
+        mpDatabaseObserver->mainConnectionStateChanged(mainConnectionID, CS_DISCONNECTED);
+        mpDatabaseObserver->removedMainConnection(mainConnectionID);
+    }
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeSinkDB(const am_sinkID_t sinkID)
+{
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    bool visible = sinkVisible(sinkID);
+
+    mMappedData.mSinkMap.erase(sinkID);
+    // todo: Check the tables SinkMainSoundProperty and SinkMainNotificationConfiguration with 'visible' set to true
+    //if visible is true then delete SinkMainSoundProperty and SinkMainNotificationConfiguration ????
+    logInfo("DatabaseHandler::removeSinkDB removed:", sinkID);
+
+    if (mpDatabaseObserver != NULL)
+        mpDatabaseObserver->removedSink(sinkID, visible);
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeSourceDB(const am_sourceID_t sourceID)
+{
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    bool visible = sourceVisible(sourceID);
+
+    mMappedData.mSourceMap.erase(sourceID);
+
+    // todo: Check the tables SourceMainSoundProperty and SourceMainNotificationConfiguration with 'visible' set to true
+    //if visible is true then delete SourceMainSoundProperty and SourceMainNotificationConfiguration ????
+
+    logInfo("DatabaseHandler::removeSourceDB removed:", sourceID);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->removedSource(sourceID, visible);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeGatewayDB(const am_gatewayID_t gatewayID)
+{
+    assert(gatewayID!=0);
+
+    if (!existGateway(gatewayID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mGatewayMap.erase(gatewayID);
+
+    logInfo("DatabaseHandler::removeGatewayDB removed:", gatewayID);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->removeGateway(gatewayID);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
+{
+    assert(crossfaderID!=0);
+
+    if (!existcrossFader(crossfaderID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    mMappedData.mCrossfaderMap.erase(crossfaderID);
+
+    logInfo("DatabaseHandler::removeCrossfaderDB removed:", crossfaderID);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->removeCrossfader(crossfaderID);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeDomainDB(const am_domainID_t domainID)
+{
+    assert(domainID!=0);
+
+    if (!existDomain(domainID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    mMappedData.mDomainMap.erase(domainID);
+
+    logInfo("DatabaseHandler::removeDomainDB removed:", domainID);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->removeDomain(domainID);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeSinkClassDB(const am_sinkClass_t sinkClassID)
+{
+    assert(sinkClassID!=0);
+
+    if (!existSinkClass(sinkClassID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mSinkClassesMap.erase(sinkClassID);
+
+    logInfo("DatabaseHandler::removeSinkClassDB removed:", sinkClassID);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->numberOfSinkClassesChanged();
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeSourceClassDB(const am_sourceClass_t sourceClassID)
+{
+    assert(sourceClassID!=0);
+
+    if (!existSourceClass(sourceClassID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mSourceClassesMap.erase(sourceClassID);
+    logInfo("DatabaseHandler::removeSourceClassDB removed:", sourceClassID);
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->numberOfSourceClassesChanged();
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::removeConnection(const am_connectionID_t connectionID)
+{
+    assert(connectionID!=0);
+
+    mMappedData.mConnectionMap.erase(connectionID);
+
+    logInfo("DatabaseHandler::removeConnection removed:", connectionID);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
+{
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
+    classInfo.sourceClassID  = source.sourceClassID;
+
+    if (!existSourceClass(classInfo.sourceClassID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    am_SourceClass_s tmpClass = mMappedData.mSourceClassesMap.at(classInfo.sourceClassID);
+    classInfo = tmpClass;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
+{
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+        return (E_NON_EXISTENT);
+
+    am_Sink_Database_s mappedSink = mMappedData.mSinkMap.at(sinkID);
+    if( true == mappedSink.reserved )
+    	return (E_NON_EXISTENT);
+	sinkData = mappedSink;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
+{
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+        return (E_NON_EXISTENT);
+
+    am_Source_Database_s mappedSource = mMappedData.mSourceMap.at(sourceID);
+    if( true == mappedSource.reserved )
+    	return (E_NON_EXISTENT);
+
+    sourceData = mappedSource;
+
+    return (E_OK);
+}
+
+am_Error_e am::CAmMapHandler::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
+{
+    assert(mainConnectionID!=0);
+    if (!existMainConnection(mainConnectionID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    am_MainConnection_s temp = mMappedData.mMainConnectionMap.at(mainConnectionID);
+    mainConnectionData = temp;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSinkClassInfoDB(const am_SinkClass_s& sinkClass)
+{
+    assert(sinkClass.sinkClassID!=0);
+    assert(!sinkClass.listClassProperties.empty());
+
+    //check if the ID already exists
+    if (!existSinkClass(sinkClass.sinkClassID))
+        return (E_NON_EXISTENT);
+
+    mMappedData.mSinkClassesMap[sinkClass.sinkClassID].listClassProperties = sinkClass.listClassProperties;
+
+    logInfo("DatabaseHandler::setSinkClassInfoDB set setSinkClassInfo");
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSourceClassInfoDB(const am_SourceClass_s& sourceClass)
+{
+    assert(sourceClass.sourceClassID!=0);
+    assert(!sourceClass.listClassProperties.empty());
+
+    //check if the ID already exists
+    if (!existSourceClass(sourceClass.sourceClassID))
+        return (E_NON_EXISTENT);
+
+    mMappedData.mSourceClassesMap[sourceClass.sourceClassID].listClassProperties = sourceClass.listClassProperties;
+
+    logInfo("DatabaseHandler::setSinkClassInfoDB set setSinkClassInfo");
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
+{
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    am_Sink_Database_s sink = mMappedData.mSinkMap.at(sinkID);
+    sinkClass.sinkClassID  = sink.sinkClassID;
+
+    if (!existSinkClass(sinkClass.sinkClassID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    am_SinkClass_s tmpSinkClass = mMappedData.mSinkClassesMap.at(sinkClass.sinkClassID);
+    sinkClass = tmpSinkClass;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
+{
+    assert(gatewayID!=0);
+    if (!existGateway(gatewayID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    gatewayData = mMappedData.mGatewayMap.at(gatewayID);
+
+    return (E_OK);
+
+}
+
+am_Error_e CAmMapHandler::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
+{
+    assert(crossfaderID!=0);
+    if (!existcrossFader(crossfaderID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    crossfaderData = mMappedData.mCrossfaderMap.at(crossfaderID);
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
+{
+    assert(domainID!=0);
+    listSinkID.clear();
+    if (!existDomain(domainID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    std::map<am_sinkID_t, am_Sink_Database_s>::const_iterator elementIterator = mMappedData.mSinkMap.begin();
+	for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator)
+	{
+		if (0==elementIterator->second.reserved && domainID==elementIterator->second.domainID)
+			listSinkID.push_back(elementIterator->second.sinkID);
+	}
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
+{
+    assert(domainID!=0);
+    listSourceID.clear();
+    if (!existDomain(domainID))
+    {
+        return (E_NON_EXISTENT);
+    }
+     CAmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin();
+	for (;elementIterator != mMappedData.mSourceMap.end(); ++elementIterator)
+	{
+		if (0==elementIterator->second.reserved && domainID==elementIterator->second.domainID)
+			listSourceID.push_back(elementIterator->second.sourceID);
+	}
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listCrossfader) const
+{
+    assert(domainID!=0);
+    listCrossfader.clear();
+    if (!existDomain(domainID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    CAmMapSource::const_iterator sourceIterator = mMappedData.mSourceMap.begin();
+	for (;sourceIterator != mMappedData.mSourceMap.end(); ++sourceIterator)
+	{
+		if (domainID==sourceIterator->second.domainID)
+		{
+			CAmMapCrossfader::const_iterator elementIterator = mMappedData.mCrossfaderMap.begin();
+			for (;elementIterator != mMappedData.mCrossfaderMap.end(); ++elementIterator)
+			{
+				if ( sourceIterator->second.sourceID==elementIterator->second.sourceID )
+					listCrossfader.push_back(elementIterator->second.crossfaderID);
+			}
+		}
+	}
+
+    return (E_OK);
+
+}
+
+am_Error_e CAmMapHandler::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
+{
+    assert(domainID!=0);
+    listGatewaysID.clear();
+    if (!existDomain(domainID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    CAmMapGateway::const_iterator elementIterator = mMappedData.mGatewayMap.begin();
+ 	for (;elementIterator != mMappedData.mGatewayMap.end(); ++elementIterator)
+ 	{
+ 		if (domainID==elementIterator->second.controlDomainID)
+ 			listGatewaysID.push_back(elementIterator->second.gatewayID);
+ 	}
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
+{
+    listMainConnections.clear();
+
+    CAmMapMainConnection::const_iterator elementIterator = mMappedData.mMainConnectionMap.begin();
+    for (;elementIterator != mMappedData.mMainConnectionMap.end(); ++elementIterator)
+    {
+    	listMainConnections.push_back(elementIterator->second);
+    }
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListDomains(std::vector<am_Domain_s> & listDomains) const
+{
+    listDomains.clear();
+
+    CAmMapDomain::const_iterator elementIterator = mMappedData.mDomainMap.begin();
+     for (;elementIterator != mMappedData.mDomainMap.end(); ++elementIterator)
+     {
+    	 if( 0==elementIterator->second.reserved )
+    		 listDomains.push_back(elementIterator->second);
+     }
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListConnections(std::vector<am_Connection_s> & listConnections) const
+{
+    listConnections.clear();
+
+    CAmMapConnection::const_iterator elementIterator = mMappedData.mConnectionMap.begin();
+	for (;elementIterator != mMappedData.mConnectionMap.end(); ++elementIterator)
+	{
+		if( 0==elementIterator->second.reserved )
+			listConnections.push_back(elementIterator->second);
+	}
+
+      return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListSinks(std::vector<am_Sink_s> & listSinks) const
+{
+    listSinks.clear();
+
+	std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair<am_sinkID_t, am_Sink_Database_s>& ref) {
+		if( 0==ref.second.reserved )
+			listSinks.push_back(ref.second);
+	});
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListSources(std::vector<am_Source_s> & listSources) const
+{
+    listSources.clear();
+
+    std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair<am_sourceID_t, am_Source_Database_s>& ref) {
+    		if( 0==ref.second.reserved )
+    		{
+    			listSources.push_back(ref.second);
+    		}
+    	});
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
+{
+    listSourceClasses.clear();
+
+    std::for_each(mMappedData.mSourceClassesMap.begin(), mMappedData.mSourceClassesMap.end(), [&](const std::pair<am_sourceClass_t, am_SourceClass_s>& ref) {
+    	listSourceClasses.push_back(ref.second);
+     });
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
+{
+    listCrossfaders.clear();
+
+    std::for_each(mMappedData.mCrossfaderMap.begin(), mMappedData.mCrossfaderMap.end(), [&](const std::pair<am_crossfaderID_t, am_Crossfader_s>& ref) {
+    	listCrossfaders.push_back(ref.second);
+       });
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListGateways(std::vector<am_Gateway_s> & listGateways) const
+{
+    listGateways.clear();
+
+    std::for_each(mMappedData.mGatewayMap.begin(), mMappedData.mGatewayMap.end(), [&](const std::pair<am_gatewayID_t, am_Gateway_s>& ref) {
+    	listGateways.push_back(ref.second);
+       });
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
+{
+    listSinkClasses.clear();
+
+    std::for_each(mMappedData.mSinkClassesMap.begin(), mMappedData.mSinkClassesMap.end(), [&](const std::pair<am_gatewayID_t, am_SinkClass_s>& ref) {
+    	listSinkClasses.push_back(ref.second);
+       });
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListVisibleMainConnections(std::vector<am_MainConnectionType_s> & listConnections) const
+{
+    listConnections.clear();
+    am_MainConnectionType_s temp;
+    std::for_each(mMappedData.mMainConnectionMap.begin(), mMappedData.mMainConnectionMap.end(), [&](const std::pair<am_mainConnectionID_t, am_MainConnection_Database_s>& ref) {
+    	ref.second.getMainConnectionType(temp);
+    	listConnections.push_back(temp);
+      });
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListMainSinks(std::vector<am_SinkType_s> & listMainSinks) const
+{
+    listMainSinks.clear();
+    am_SinkType_s sinkType;
+    std::for_each(mMappedData.mSinkMap.begin(), mMappedData.mSinkMap.end(), [&](const std::pair<am_sinkID_t, am_Sink_Database_s>& ref) {
+    	if( 0==ref.second.reserved && 1==ref.second.visible )
+    	{
+    		ref.second.getSinkType(sinkType);
+    		listMainSinks.push_back(sinkType);
+    	}
+      });
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListMainSources(std::vector<am_SourceType_s> & listMainSources) const
+{
+    listMainSources.clear();
+    am_SourceType_s temp;
+    std::for_each(mMappedData.mSourceMap.begin(), mMappedData.mSourceMap.end(), [&](const std::pair<am_sourceID_t, am_Source_Database_s>& ref) {
+    	if( 1==ref.second.visible )
+    	{
+    		ref.second.getSourceType(temp);
+			listMainSources.push_back(temp);
+    	}
+      });
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
+{
+    assert(sinkID!=0);
+    if (!existSink(sinkID))
+    	return E_NON_EXISTENT;
+
+    am_Sink_s sink = mMappedData.mSinkMap.at(sinkID);
+    listSoundProperties = sink.listMainSoundProperties;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
+{
+    assert(sourceID!=0);
+    if (!existSource(sourceID))
+    	return E_NON_EXISTENT;
+
+    am_Source_s source = mMappedData.mSourceMap.at(sourceID);
+    listSourceProperties = source.listMainSoundProperties;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
+{
+     listSystemProperties = mMappedData.mSystemProperties;
+    return (E_OK);
+}
+
+am_Error_e am::CAmMapHandler::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const
+{
+   if (!existSink(sinkID))
+	   return E_NON_EXISTENT;
+	am_Sink_s sink = mMappedData.mSinkMap.at(sinkID);
+	listConnectionFormats = sink.listConnectionFormats;
+
+    return (E_OK);
+}
+
+am_Error_e am::CAmMapHandler::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_ConnectionFormat_e> & listConnectionFormats) const
+{
+   if (!existSource(sourceID))
+	   return E_NON_EXISTENT;
+    am_Source_s source = mMappedData.mSourceMap.at(sourceID);
+    listConnectionFormats = source.listConnectionFormats;
+
+    return (E_OK);
+}
+
+am_Error_e am::CAmMapHandler::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> & listConnectionFormat) const
+{
+    ListConnectionFormat::const_iterator iter = mListConnectionFormat.begin();
+    iter = mListConnectionFormat.find(gatewayID);
+    if (iter == mListConnectionFormat.end())
+    {
+        logError("DatabaseHandler::getListGatewayConnectionFormats database error with convertionFormat");
+
+        return E_NON_EXISTENT;
+    }
+    listConnectionFormat = iter->second;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
+{
+    assert(mainConnectionID!=0);
+    if (!existMainConnection(mainConnectionID))
+    	return E_NON_EXISTENT;
+    delay = -1;
+
+    am_MainConnection_s mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
+    delay = mainConnection.delay;
+
+    if (delay == -1)
+        return (E_NOT_POSSIBLE);
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID)
+{
+    assert(connectionID!=0);
+    if (!existMainConnection(connectionID))
+ 		return (E_NON_EXISTENT);
+    mMappedData.mMainConnectionMap[connectionID].delay = delay;
+
+    return (E_OK);
+}
+
+/**
+ * checks for a certain mainConnection
+ * @param mainConnectionID to be checked for
+ * @return true if it exists
+ */
+bool CAmMapHandler::existMainConnection(const am_mainConnectionID_t mainConnectionID) const
+{
+	return existsObjectWithKeyInMap(mainConnectionID, mMappedData.mMainConnectionMap);
+}
+
+/**
+ * checks for a certain Source
+ * @param sourceID to be checked for
+ * @return true if it exists
+ */
+bool CAmMapHandler::existSource(const am_sourceID_t sourceID) const
+{
+	am_Source_Database_s const * source = objectWithKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+	if( NULL!=source )
+		return (0==source->reserved);
+
+	return false;
+}
+
+/**
+ * checks if a source name or ID exists
+ * @param sourceID the sourceID
+ * @param name the name
+ * @return true if it exits
+ */
+bool CAmMapHandler::existSourceNameOrID(const am_sourceID_t sourceID, const std::string & name) const
+{
+	bool returnVal = false;
+	CAmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin();
+	for (;elementIterator != mMappedData.mSourceMap.end(); ++elementIterator)
+	{
+		if( 0==elementIterator->second.reserved &&
+			(sourceID==elementIterator->second.sourceID || name.compare(elementIterator->second.name)==0))
+		{
+			returnVal = true;
+			break;
+		}
+	}
+    return (returnVal);
+}
+
+/**
+ * checks if a name exits
+ * @param name the name
+ * @return true if it exits
+ */
+bool CAmMapHandler::existSourceName(const std::string & name) const
+{
+    return existSourceNameOrID(SHRT_MAX, name);
+}
+
+/**
+ * checks for a certain Sink
+ * @param sinkID to be checked for
+ * @return true if it exists
+ */
+bool CAmMapHandler::existSink(const am_sinkID_t sinkID) const
+{
+	bool returnVal = false;
+	CAmMapSink::const_iterator elementIterator = mMappedData.mSinkMap.begin();
+	for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator)
+	{
+		if( 0==elementIterator->second.reserved &&
+			sinkID==elementIterator->second.sinkID)
+		{
+			returnVal = true;
+			break;
+		}
+	}
+    return (returnVal);
+}
+
+/**
+ * checks if a sink with the ID or the name exists
+ * @param sinkID the ID
+ * @param name the name
+ * @return true if it exists.
+ */
+bool CAmMapHandler::existSinkNameOrID(const am_sinkID_t sinkID, const std::string & name) const
+{
+	bool returnVal = false;
+	CAmMapSink::const_iterator elementIterator = mMappedData.mSinkMap.begin();
+	for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator)
+	{
+		if( 0==elementIterator->second.reserved &&
+			(sinkID==elementIterator->second.sinkID || name.compare(elementIterator->second.name)==0))
+		{
+			returnVal = true;
+			break;
+		}
+	}
+
+    return (returnVal);
+}
+
+/**
+ * checks if a sink with the name exists
+ * @param name the name
+ * @return true if it exists
+ */
+bool CAmMapHandler::existSinkName(const std::string & name) const
+{
+    return existSinkNameOrID(SHRT_MAX, name);
+}
+
+/**
+ * checks for a certain domain
+ * @param domainID to be checked for
+ * @return true if it exists
+ */
+bool CAmMapHandler::existDomain(const am_domainID_t domainID) const
+{
+	am_Domain_Database_s const * source = objectWithKeyIfExistsInMap(domainID, mMappedData.mDomainMap);
+	if( NULL!=source )
+		return (0==source->reserved);
+
+	return false;
+}
+
+/**
+ * checks for certain gateway
+ * @param gatewayID to be checked for
+ * @return true if it exists
+ */
+bool CAmMapHandler::existGateway(const am_gatewayID_t gatewayID) const
+{
+	return existsObjectWithKeyInMap(gatewayID, mMappedData.mGatewayMap);
+}
+
+am_Error_e CAmMapHandler::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t & domainID) const
+{
+    assert(sourceID!=0);
+
+    am_Source_Database_s const * source = objectWithKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+    if( NULL!=source )
+    {
+    	domainID = source->domainID;
+    	return E_OK;
+    }
+    return E_NON_EXISTENT;
+}
+
+am_Error_e am::CAmMapHandler::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t & domainID) const
+{
+    assert(sinkID!=0);
+
+    am_Sink_Database_s const * source = objectWithKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+	if( NULL!=source )
+	{
+		domainID = source->domainID;
+		return E_OK;
+	}
+	return E_NON_EXISTENT;
+}
+
+/**
+ * checks for certain SinkClass
+ * @param sinkClassID
+ * @return true if it exists
+ */
+bool CAmMapHandler::existSinkClass(const am_sinkClass_t sinkClassID) const
+{
+	return existsObjectWithKeyInMap(sinkClassID, mMappedData.mSinkClassesMap);
+}
+
+/**
+ * checks for certain sourceClass
+ * @param sourceClassID
+ * @return true if it exists
+ */
+bool CAmMapHandler::existSourceClass(const am_sourceClass_t sourceClassID) const
+{
+	return existsObjectWithKeyInMap(sourceClassID, mMappedData.mSourceClassesMap);
+}
+
+am_Error_e CAmMapHandler::changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay)
+{
+    assert(connectionID!=0);
+    if(!existConnectionID(connectionID))
+    	return E_NON_EXISTENT;
+
+    mMappedData.mConnectionMap[connectionID].delay = delay;
+
+    //now we need to find all mainConnections that use the changed connection and update their timing
+
+    //first get all route tables for all mainconnections
+
+    CAmMapMainConnection::const_iterator iter = mMappedData.mMainConnectionMap.begin();
+    for(; iter != mMappedData.mMainConnectionMap.end(); ++iter)
+    {
+    	am_MainConnection_s mainConnection = iter->second;
+    	if (std::find(mainConnection.listConnectionID.begin(), mainConnection.listConnectionID.end(), connectionID) != mainConnection.listConnectionID.end())
+    	{
+    	  // Got it.
+    		changeDelayMainConnection(calculateMainConnectionDelay(mainConnection.mainConnectionID), mainConnection.mainConnectionID);
+    	}
+
+    }
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeConnectionFinal(const am_connectionID_t connectionID)
+{
+    assert(connectionID!=0);
+    am_Connection_Database_s const * connection = objectWithKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap);
+    if( NULL!=connection )
+    {
+    	mMappedData.mConnectionMap.at(connectionID).reserved = false;
+    	return E_OK;
+    }
+    return (E_NON_EXISTENT);
+}
+
+am_timeSync_t CAmMapHandler::calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const
+{
+    assert(mainConnectionID!=0);
+    if (!existMainConnection(mainConnectionID))
+  		return -1;
+    am_MainConnection_s mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
+    am_timeSync_t delay = 0;
+	am_timeSync_t min = SHRT_MAX;
+    std::vector<am_connectionID_t>::const_iterator iter = mainConnection.listConnectionID.begin();
+	for(;iter<mainConnection.listConnectionID.end(); ++iter)
+	{
+		am_Connection_Database_s const * source = objectWithKeyIfExistsInMap(*iter, mMappedData.mConnectionMap);
+		if( NULL!=source )
+		{
+			delay += source->delay;
+			min = std::min(min,source->delay);
+		}
+	}
+    if (min < 0)
+        delay = -1;
+    return (delay);
+
+}
+
+/**
+ * registers the Observer at the Database
+ * @param iObserver pointer to the observer
+ */
+void CAmMapHandler::registerObserver(CAmDatabaseObserver *iObserver)
+{
+    assert(iObserver!=NULL);
+    mpDatabaseObserver = iObserver;
+}
+
+/**
+ * gives information about the visibility of a source
+ * @param sourceID the sourceID
+ * @return true if source is visible
+ */
+bool CAmMapHandler::sourceVisible(const am_sourceID_t sourceID) const
+{
+    assert(sourceID!=0);
+    if (!existSource(sourceID))
+    	return false;
+    am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
+    return source.visible;
+}
+
+/**
+ * gives information about the visibility of a sink
+ * @param sinkID the sinkID
+ * @return true if source is visible
+ */
+bool CAmMapHandler::sinkVisible(const am_sinkID_t sinkID) const
+{
+	am_Sink_Database_s const * source = objectWithKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+	if( NULL!=source )
+	{
+		if(0==source->reserved)
+			return source->visible;
+	}
+	return false;
+}
+
+/**
+ * checks if a connection already exists.
+ * Only takes sink, source and format information for search!
+ * @param connection the connection to be checked
+ * @return true if connections exists
+ */
+bool CAmMapHandler::existConnection(const am_Connection_s & connection) const
+{
+	am_Connection_Database_s const * connectionObject = findFirstObjectMatchingCriteria(mMappedData.mConnectionMap, connection, compareConnectionObjectsWithObject);
+	return ( NULL!=connectionObject );
+}
+
+/**
+ * checks if a connection with the given ID exists
+ * @param connectionID
+ * @return true if connection exits
+ */
+bool CAmMapHandler::existConnectionID(const am_connectionID_t connectionID) const
+{
+	am_Connection_Database_s const * connection = objectWithKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap);
+	if( NULL!=connection )
+	{
+		return (0==connection->reserved);
+	}
+	return false;
+}
+
+/**
+ * checks if a CrossFader exists
+ * @param crossfaderID the ID of the crossfader to be checked
+ * @return true if exists
+ */
+bool CAmMapHandler::existcrossFader(const am_crossfaderID_t crossfaderID) const
+{
+     return existsObjectWithKeyInMap(crossfaderID, mMappedData.mCrossfaderMap);
+}
+
+am_Error_e CAmMapHandler::getSoureState(const am_sourceID_t sourceID, am_SourceState_e & sourceState) const
+{
+	am_Source_Database_s const * source = objectWithKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+	if( NULL!=source )
+	{
+		sourceState = source->sourceState;
+		return (E_OK);
+	}
+	else
+	{
+		sourceState =  SS_UNKNNOWN;
+		return (E_NON_EXISTENT);
+	}
+}
+
+am_Error_e CAmMapHandler::changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState)
+{
+    assert(sourceID!=0);
+    assert(sourceState>=SS_UNKNNOWN && sourceState<=SS_MAX);
+    if(existSource(sourceID))
+    {
+    	mMappedData.mSourceMap.at(sourceID).sourceState = sourceState;
+		return (E_OK);
+	}
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::getSinkVolume(const am_sinkID_t sinkID, am_volume_t & volume) const
+{
+    assert(sinkID!=0);
+
+	am_Sink_Database_s const * source = objectWithKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+	if( NULL!=source )
+	{
+		volume = source->volume;
+		return (E_OK);
+	}
+	volume = -1;
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::getSourceVolume(const am_sourceID_t sourceID, am_volume_t & volume) const
+{
+    assert(sourceID!=0);
+	am_Source_Database_s const * source = objectWithKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+	if( NULL!=source )
+	{
+		volume = source->volume;
+		return (E_OK);
+	}
+	volume = -1;
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_SoundPropertyType_e propertyType, int16_t & value) const
+{
+    assert(sinkID!=0);
+
+	am_Sink_Database_s const * source = objectWithKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
+	if( NULL!=source )
+	{
+		std::vector<am_SoundProperty_s>::const_iterator iter = source->listSoundProperties.begin();
+		for(; iter<source->listSoundProperties.end(); ++iter)
+		{
+			if( propertyType == iter->type )
+			{
+				value = iter->value;
+				return (E_OK);
+			}
+		}
+	}
+	value = -1;
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_SoundPropertyType_e propertyType, int16_t & value) const
+{
+    assert(sourceID!=0);
+
+	am_Source_Database_s const * source = objectWithKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
+	if( NULL!=source )
+	{
+		std::vector<am_SoundProperty_s>::const_iterator iter = source->listSoundProperties.begin();
+		for(; iter<source->listSoundProperties.end(); ++iter)
+		{
+			if( propertyType == iter->type )
+			{
+				value = iter->value;
+				return (E_OK);
+			}
+		}
+	}
+	value = -1;
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::getDomainState(const am_domainID_t domainID, am_DomainState_e& state) const
+{
+    assert(domainID!=0);
+
+    am_Domain_Database_s const * source = objectWithKeyIfExistsInMap(domainID, mMappedData.mDomainMap);
+	if( NULL!=source )
+	{
+		state = source->state;
+		return (E_OK);
+	}
+	state = DS_UNKNOWN;
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::peekDomain(const std::string & name, am_domainID_t & domainID)
+{
+    domainID=0;
+
+    CAmCompareObjectWithValue comparator = compareDomainObjectWithValue;
+    am_Domain_Database_s const *reservedDomain = findFirstObjectMatchingCriteria(mMappedData.mDomainMap, name, comparator);
+
+     if( NULL != reservedDomain )
+    {
+    	domainID = reservedDomain->domainID;
+    	return E_OK;
+    }
+    else
+    {
+    	int16_t nextID = 0;
+    	if( mMappedData.increaseID( &nextID, &mMappedData.mCurrentDomainID) )
+    	{
+    		domainID = nextID;
+    		am_Domain_Database_s domain;
+    		domain.domainID = nextID;
+    		domain.name = name;
+    		domain.reserved = 1;
+    		mMappedData.mDomainMap[nextID] = domain;
+    		return E_OK;
+    	}
+    	return E_MAX;
+    }
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::peekSink(const std::string & name, am_sinkID_t & sinkID)
+{
+	am_Sink_Database_s const *reservedSink = findFirstObjectMatchingCriteria(mMappedData.mSinkMap, name, compareSinkObjectByName);
+	if( NULL!=reservedSink )
+    {
+		sinkID = reservedSink->sinkID;
+    	return E_OK;
+    }
+    else
+    {
+    	int16_t nextID = 0;
+    	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentSinkID))
+    	{
+    		if(mFirstStaticSink)
+    		{
+    			nextID = DYNAMIC_ID_BOUNDARY;
+    			mFirstStaticSink = false;
+    		}
+    		sinkID = nextID;
+    		am_Sink_Database_s object;
+    		object.sinkID = nextID;
+    		object.name = name;
+    		object.reserved = 1;
+    		mMappedData.mSinkMap[nextID] = object;
+    		return E_OK;
+    	}
+   		return E_MAX;
+    }
+}
+
+am_Error_e CAmMapHandler::peekSource(const std::string & name, am_sourceID_t & sourceID)
+{
+	am_Source_Database_s const *reservedDomain = findFirstObjectMatchingCriteria(mMappedData.mSourceMap, name, compareSourceObjectByName);
+	if( NULL!=reservedDomain )
+    {
+		sourceID = reservedDomain->sourceID;
+    	return E_OK;
+    }
+    else
+    {
+    	int16_t nextID = 0;
+    	if(mMappedData.increaseID(&nextID, &mMappedData.mCurrentSourceID))
+    	{
+    		if(mFirstStaticSource)
+    		{
+//    			nextID = DYNAMIC_ID_BOUNDARY;
+    			mFirstStaticSource = false;
+    		}
+    		sourceID = nextID;
+    		am_Source_Database_s object;
+    		object.sourceID = nextID;
+    		object.name = name;
+    		object.reserved = 1;
+    		mMappedData.mSourceMap[nextID] = object;
+    		return E_OK;
+    	}
+    	else
+    		return E_MAX;
+    }
+}
+
+am_Error_e CAmMapHandler::changeSinkVolume(const am_sinkID_t sinkID, const am_volume_t volume)
+{
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mSinkMap[sinkID].volume = volume;
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSourceVolume(const am_sourceID_t sourceID, const am_volume_t volume)
+{
+    assert(sourceID!=0);
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    mMappedData.mSourceMap[sourceID].volume = volume;
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeSourceSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sourceID_t sourceID)
+{
+    assert(soundProperty.type>=SP_UNKNOWN && soundProperty.type<=SP_MAX);
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    std::vector<am_SoundProperty_s>::iterator iter = mMappedData.mSourceMap[sourceID].listSoundProperties.begin();
+	for(; iter<mMappedData.mSourceMap[sourceID].listSoundProperties.end(); ++iter)
+	{
+		if( soundProperty.type == iter->type )
+		{
+			iter->value = soundProperty.value;
+			return (E_OK);
+		}
+	}
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::changeSinkSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sinkID_t sinkID)
+{
+    assert(soundProperty.type>=SP_UNKNOWN && soundProperty.type<=SP_MAX);
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    std::vector<am_SoundProperty_s>::iterator iter = mMappedData.mSinkMap[sinkID].listSoundProperties.begin();
+ 	for(; iter<mMappedData.mSinkMap[sinkID].listSoundProperties.end(); ++iter)
+ 	{
+ 		if( soundProperty.type == iter->type )
+ 		{
+ 			iter->value = soundProperty.value;
+ 			return (E_OK);
+ 		}
+ 	}
+ 	return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink)
+{
+    assert(crossfaderID!=0);
+    assert(hotsink>=HS_UNKNOWN && hotsink>=HS_MAX);
+
+    if (!existcrossFader(crossfaderID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    mMappedData.mCrossfaderMap[crossfaderID].hotSink = hotsink;
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getRoutingTree(bool onlyfree, CAmRoutingTree& tree, std::vector<CAmRoutingTreeItem*>& flatTree)
+{
+    am_domainID_t rootID = tree.returnRootDomainID();
+    CAmRoutingTreeItem *parent = tree.returnRootItem();
+    size_t i = 0;
+
+    do
+    {
+        if (i != 0)
+        {
+            parent = flatTree.at(i - 1);
+            rootID = parent->returnDomainID();
+        }
+		std::for_each(mMappedData.mGatewayMap.begin(),mMappedData.mGatewayMap.end(), [&](const std::pair<am_gatewayID_t, am_Gateway_s>& refGateway) {
+			if( rootID==refGateway.second.domainSinkID )
+			{
+				if(!onlyfree || std::find_if(mMappedData.mConnectionMap.begin(),
+											 mMappedData.mConnectionMap.end(),
+											 [refGateway](const std::pair<am_connectionID_t, am_Connection_Database_s>& refConnection)
+											 {
+												return (refConnection.second.sinkID == refGateway.second.sinkID ||
+														refConnection.second.sourceID ==refGateway.second.sourceID);
+											 })==mMappedData.mConnectionMap.end() )
+				{
+				  // additional check to avoid cyclic routes
+					const am_domainID_t domainSourceID = refGateway.second.domainSourceID;
+					bool sourceDomainAlreadyHandledAsSink = false;
+					for (std::vector<CAmRoutingTreeItem*>::const_iterator iFT = flatTree.begin(); iFT != flatTree.end(); ++iFT)
+					{
+						if (domainSourceID == (*iFT)->returnParent()->returnDomainID())
+						{
+							sourceDomainAlreadyHandledAsSink = true;
+							break;
+						}
+					}
+
+					if (!sourceDomainAlreadyHandledAsSink)
+					{
+						// logInfo("DatabaseHandler::getRoutingTree ", rootID, ", ", domainSourceID, ", ", sqlite3_column_int(query, 1));
+						flatTree.push_back(tree.insertItem(domainSourceID, refGateway.second.gatewayID, parent));
+					}
+				}
+			}
+		});
+        i++;
+    } while (flatTree.size() > (i - 1));
+
+    return (E_OK);
+}
+
+am_Error_e am::CAmMapHandler::peekSinkClassID(const std::string & name, am_sinkClass_t & sinkClassID)
+{
+    if (name.empty())
+        return (E_NON_EXISTENT);
+
+    am_SinkClass_s const *reservedDomain = findFirstObjectMatchingCriteria(mMappedData.mSinkClassesMap, name, compareSinkClassObjectByName);
+	if( NULL!=reservedDomain )
+	{
+		sinkClassID = reservedDomain->sinkClassID;
+		return E_OK;
+	}
+	return (E_NON_EXISTENT);
+}
+
+am_Error_e am::CAmMapHandler::peekSourceClassID(const std::string & name, am_sourceClass_t & sourceClassID)
+{
+    if (name.empty())
+        return (E_NON_EXISTENT);
+
+    am_SourceClass_s const *ptrSource = findFirstObjectMatchingCriteria(mMappedData.mSourceClassesMap, name, compareSourceClassObjectByName);
+  	if( NULL!=ptrSource )
+  	{
+  		sourceClassID = ptrSource->sourceClassID;
+  		return E_OK;
+  	}
+  	return (E_NON_EXISTENT);
+}
+
+
+am_Error_e CAmMapHandler::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_ConnectionFormat_e>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+{
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    am_sourceClass_t sourceClassOut(sourceClassID);
+    std::vector<am_MainSoundProperty_s> listMainSoundPropertiesOut(listMainSoundProperties);
+    //check if sinkClass needs to be changed
+
+	std::map<am_sourceID_t, am_Source_Database_s>::iterator iter = mMappedData.mSourceMap.begin();
+	for(; iter!=mMappedData.mSourceMap.end(); ++iter)
+	{
+		if( iter->second.sourceID == sourceID )
+		{
+			if( sourceClassID!=0 )
+				iter->second.sourceClassID = sourceClassID;
+			else if( 0 == iter->second.reserved )
+				sourceClassOut = iter->second.sourceClassID;
+		}
+	}
+
+    //check if soundProperties need to be updated
+    if (!listSoundProperties.empty())
+    {
+    	mMappedData.mSourceMap.at(sourceID).listSoundProperties = listSoundProperties;
+    }
+
+    //check if we have to update the list of connectionformats
+    if (!listConnectionFormats.empty())
+    {
+    	mMappedData.mSourceMap.at(sourceID).listConnectionFormats = listConnectionFormats;
+    }
+
+    //then we need to check if we need to update the listMainSoundProperties
+    if (!listMainSoundProperties.empty() && sourceVisible(sourceID))
+    {
+
+    	mMappedData.mSourceMap.at(sourceID).listMainSoundProperties = listMainSoundProperties;
+    }
+    else //read out the properties
+    {
+        getListMainSourceSoundProperties(sourceID,listMainSoundPropertiesOut);
+    }
+
+    logInfo("DatabaseHandler::changeSource changed changeSink of source:", sourceID);
+
+    if (mpDatabaseObserver != NULL)
+    {
+        mpDatabaseObserver->sourceUpdated(sourceID,sourceClassOut,listMainSoundPropertiesOut,sourceVisible(sourceID));
+    }
+
+    return (E_OK);
+
+}
+
+am_Error_e CAmMapHandler::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_ConnectionFormat_e>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+{
+    assert(sinkID!=0);
+
+    am_sinkClass_t sinkClassOut(sinkClassID);
+    std::vector<am_MainSoundProperty_s> listMainSoundPropertiesOut(listMainSoundProperties);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+	std::map<am_sinkID_t, am_Sink_Database_s>::iterator iter = mMappedData.mSinkMap.begin();
+	for(; iter!=mMappedData.mSinkMap.end(); ++iter)
+	{
+		if( iter->second.sinkID == sinkID )
+		{
+			if( sinkClassID!=0 )
+				iter->second.sinkClassID = sinkClassID;
+			else if( 0 == iter->second.reserved )
+				sinkClassOut = iter->second.sinkClassID;
+		}
+	}
+
+    //check if soundProperties need to be updated
+    if (!listSoundProperties.empty())
+    {
+    	mMappedData.mSinkMap.at(sinkID).listSoundProperties = listSoundProperties;
+    }
+
+    //check if we have to update the list of connectionformats
+    if (!listConnectionFormats.empty())
+    {
+    	mMappedData.mSinkMap.at(sinkID).listConnectionFormats = listConnectionFormats;
+    }
+
+    //then we need to check if we need to update the listMainSoundProperties
+    if (!listMainSoundProperties.empty() && sinkVisible(sinkID))
+    {
+    	mMappedData.mSinkMap.at(sinkID).listMainSoundProperties = listMainSoundProperties;
+    }
+    else //read out the properties
+    {
+        getListMainSinkSoundProperties(sinkID,listMainSoundPropertiesOut);
+    }
+
+    logInfo("DatabaseHandler::changeSink changed changeSink of sink:", sinkID);
+
+    if (mpDatabaseObserver != NULL)
+    {
+        mpDatabaseObserver->sinkUpdated(sinkID,sinkClassOut,listMainSoundPropertiesOut,sinkVisible(sinkID));
+    }
+
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations)
+{
+    assert(sinkID!=0);
+    if (!existSink(sinkID))
+        return (E_DATABASE_ERROR); // todo: here we could change to non existen, but not shown in sequences
+    listMainNotificationConfigurations.clear();
+
+    listMainNotificationConfigurations = mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations;
+
+     return (E_OK);
+}
+
+am_Error_e CAmMapHandler::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations)
+{
+    assert(sourceID!=0);
+    if (!existSource(sourceID))
+        return (E_DATABASE_ERROR); // todo: here we could change to non existen, but not shown in sequences
+
+    listMainNotificationConfigurations = mMappedData.mSourceMap.at(sourceID).listMainNotificationConfigurations;
+
+    return (E_OK);
+}
+
+bool changeMainNotificationConfiguration(std::vector<am_NotificationConfiguration_s> & listMainNotificationConfigurations,
+											  const am_NotificationConfiguration_s & mainNotificationConfiguration)
+{
+	bool changed = false;
+    std::vector<am_NotificationConfiguration_s>::iterator iter = listMainNotificationConfigurations.begin();
+ 	for(; iter<listMainNotificationConfigurations.end(); ++iter)
+ 	{
+ 		if( mainNotificationConfiguration.type == iter->type )
+ 		{
+ 			iter->status = mainNotificationConfiguration.status;
+ 			iter->parameter = mainNotificationConfiguration.parameter;
+ 			changed |= true;
+ 		}
+ 	}
+ 	return changed;
+}
+
+am_Error_e CAmMapHandler::changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration)
+{
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    if(!changeMainNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations, mainNotificationConfiguration))
+    	return (E_NO_CHANGE);
+
+    logInfo("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=",mainNotificationConfiguration.parameter);
+
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->sinkMainNotificationConfigurationChanged(sinkID, mainNotificationConfiguration);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration)
+{
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    if(!changeMainNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listMainNotificationConfigurations, mainNotificationConfiguration))
+    	return (E_NO_CHANGE);
+
+    logInfo("DatabaseHandler::changeMainSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", mainNotificationConfiguration.type, "to status=", mainNotificationConfiguration.status, "and parameter=",mainNotificationConfiguration.parameter);
+
+    if (mpDatabaseObserver)
+        mpDatabaseObserver->sourceMainNotificationConfigurationChanged(sourceID, mainNotificationConfiguration);
+    return (E_OK);
+}
+
+am_Error_e CAmMapHandler::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_ConnectionFormat_e>& listSourceConnectionFormats, const std::vector<am_ConnectionFormat_e>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix)
+{
+    assert(gatewayID!=0);
+
+   if (!existGateway(gatewayID))
+   {
+       return (E_NON_EXISTENT);
+   }
+
+   if (!listSourceConnectionFormats.empty())
+   {
+	   mMappedData.mGatewayMap.at(gatewayID).listSourceFormats = listSourceConnectionFormats;
+   }
+
+   if (!listSinkConnectionFormats.empty())
+   {
+	   mMappedData.mGatewayMap.at(gatewayID).listSinkFormats = listSinkConnectionFormats;
+   }
+
+   if (!convertionMatrix.empty())
+   {
+       mListConnectionFormat.clear();
+       mListConnectionFormat.insert(std::make_pair(gatewayID, convertionMatrix));
+   }
+
+   logInfo("DatabaseHandler::changeGatewayDB changed Gateway with ID", gatewayID);
+
+   //todo: check if observer needs to be adopted.
+   return (E_OK);
+}
+
+bool changeNotificationConfiguration(std::vector<am_NotificationConfiguration_s> & listNotificationConfigurations, const am_NotificationConfiguration_s & notificationConfiguration)
+{
+	bool changed = false;
+    std::vector<am_NotificationConfiguration_s>::iterator iter = listNotificationConfigurations.begin();
+ 	for(; iter<listNotificationConfigurations.end(); ++iter)
+ 	{
+ 		if( notificationConfiguration.type == iter->type )
+ 		{
+ 			iter->status = notificationConfiguration.status;
+ 			iter->parameter = notificationConfiguration.parameter;
+ 			changed |= true;
+ 		}
+ 	}
+ 	return changed;
+}
+
+am_Error_e CAmMapHandler::changeSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s notificationConfiguration)
+{
+    assert(sinkID!=0);
+
+    if (!existSink(sinkID))
+    {
+        return (E_NON_EXISTENT);
+    }
+    if(!changeNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listNotificationConfigurations, notificationConfiguration))
+    	return (E_NO_CHANGE);
+
+    logInfo("DatabaseHandler::changeMainSinkNotificationConfigurationDB changed MainNotificationConfiguration of source:", sinkID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=",notificationConfiguration.parameter);
+
+    //todo:: inform obsever here...
+    return (E_NON_EXISTENT);
+}
+
+am_Error_e CAmMapHandler::changeSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s notificationConfiguration)
+{
+    assert(sourceID!=0);
+
+    if (!existSource(sourceID))
+    {
+        return (E_NON_EXISTENT);
+    }
+
+    if(!changeNotificationConfiguration(mMappedData.mSourceMap.at(sourceID).listNotificationConfigurations, notificationConfiguration))
+    	return (E_NO_CHANGE);
+
+    logInfo("DatabaseHandler::changeSourceNotificationConfigurationDB changed MainNotificationConfiguration of source:", sourceID, "type:", notificationConfiguration.type, "to status=", notificationConfiguration.status, "and parameter=",notificationConfiguration.parameter);
+
+    //todo:: implement observer function
+    return (E_NON_EXISTENT);
+}
+
+}
diff --git a/AudioManagerDaemon/src/CAmRouter.cpp b/AudioManagerDaemon/src/CAmRouter.cpp
index fe5a960..36fa310 100644
--- a/AudioManagerDaemon/src/CAmRouter.cpp
+++ b/AudioManagerDaemon/src/CAmRouter.cpp
@@ -24,12 +24,12 @@
 #include <algorithm>
 #include <vector>
 #include <iterator>
-#include "CAmDatabaseHandler.h"
+#include "CAmDatabaseHandlerInterface.h"
 #include "CAmControlSender.h"
 
 namespace am {
 
-CAmRouter::CAmRouter(CAmDatabaseHandler* iDatabaseHandler, CAmControlSender* iSender) :
+CAmRouter::CAmRouter(CAmDatabaseHandlerInterface* iDatabaseHandler, CAmControlSender* iSender) :
         mpDatabaseHandler(iDatabaseHandler), //
         mpControlSender(iSender)
 {
diff --git a/AudioManagerDaemon/src/CAmRoutingReceiver.cpp b/AudioManagerDaemon/src/CAmRoutingReceiver.cpp
index a9f8642..38fb913 100644
--- a/AudioManagerDaemon/src/CAmRoutingReceiver.cpp
+++ b/AudioManagerDaemon/src/CAmRoutingReceiver.cpp
@@ -22,7 +22,7 @@
 #include "CAmRoutingReceiver.h"
 #include <cassert>
 #include <algorithm>
-#include "CAmDatabaseHandler.h"
+#include "CAmDatabaseHandlerInterface.h"
 #include "CAmRoutingSender.h"
 #include "CAmControlSender.h"
 #include "shared/CAmDltWrapper.h"
@@ -31,7 +31,7 @@
 namespace am
 {
 
-CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
+CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler) :
         mpDatabaseHandler(iDatabaseHandler), //
         mpRoutingSender(iRoutingSender), //
         mpControlSender(iControlSender), //
@@ -51,7 +51,7 @@ CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAm
     assert(mpSocketHandler!=NULL);
 }
 
-CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandler *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
+CAmRoutingReceiver::CAmRoutingReceiver(CAmDatabaseHandlerInterface *iDatabaseHandler, CAmRoutingSender *iRoutingSender, CAmControlSender *iControlSender, CAmSocketHandler *iSocketHandler, CAmDbusWrapper *iDBusWrapper) :
         mpDatabaseHandler(iDatabaseHandler), //
         mpRoutingSender(iRoutingSender), //
         mpControlSender(iControlSender), //
diff --git a/AudioManagerDaemon/src/main.cpp b/AudioManagerDaemon/src/main.cpp
index de10b73..f9414a8 100755
--- a/AudioManagerDaemon/src/main.cpp
+++ b/AudioManagerDaemon/src/main.cpp
@@ -52,6 +52,7 @@
 #include <new>
 #include "CAmRouter.h"
 #include "CAmDatabaseHandler.h"
+#include "CAmMapHandler.h"
 #include "CAmControlSender.h"
 #include "CAmCommandSender.h"
 #include "CAmRoutingSender.h"
@@ -313,30 +314,36 @@ void mainProgram()
     CAmWatchdog iWatchdog(&iSocketHandler);
 #endif /*WITH_SYSTEMD_WATCHDOG*/
 
-    CAmDatabaseHandler iDatabaseHandler(databasePath);
+#ifdef WITH_DATABASE_STORAGE
+    CAmDatabaseHandler * ptr_iDatabaseHandler = new CAmMapHandler(databasePath);
+#else
+    CAmMapHandler * ptr_iDatabaseHandler = new CAmMapHandler();
+#endif /*WITH_DATABASE_STORAGE*/
+    CAmDatabaseHandlerInterface & iDatabaseHandler = *ptr_iDatabaseHandler;
+
     CAmRoutingSender iRoutingSender(listRoutingPluginDirs);
     CAmCommandSender iCommandSender(listCommandPluginDirs);
     CAmControlSender iControlSender(controllerPlugin,&iSocketHandler);
-    CAmRouter iRouter(&iDatabaseHandler, &iControlSender);
+    CAmRouter iRouter(ptr_iDatabaseHandler, &iControlSender);
 
 #ifdef WITH_DBUS_WRAPPER
-    CAmCommandReceiver iCommandReceiver(&iDatabaseHandler, &iControlSender, &iSocketHandler, &iDBusWrapper);
-    CAmRoutingReceiver iRoutingReceiver(&iDatabaseHandler, &iRoutingSender, &iControlSender, &iSocketHandler, &iDBusWrapper);
+    CAmCommandReceiver iCommandReceiver(ptr_iDatabaseHandler, &iControlSender, &iSocketHandler, &iDBusWrapper);
+    CAmRoutingReceiver iRoutingReceiver(ptr_iDatabaseHandler, &iRoutingSender, &iControlSender, &iSocketHandler, &iDBusWrapper);
 #ifdef WITH_NSM
-    CAmControlReceiver iControlReceiver(&iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter, &iNodeStateCommunicator);
+    CAmControlReceiver iControlReceiver(ptr_iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter, &iNodeStateCommunicator);
     iNodeStateCommunicator.registerControlSender(&iControlSender);
 #else /*WITH_NSM*/
-    CAmControlReceiver iControlReceiver(&iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter);
+    CAmControlReceiver iControlReceiver(ptr_iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter);
 #endif /*WITH_NSM*/
 #else /*WITH_DBUS_WRAPPER*/
-    CAmCommandReceiver iCommandReceiver(&iDatabaseHandler,&iControlSender,&iSocketHandler);
-    CAmRoutingReceiver iRoutingReceiver(&iDatabaseHandler,&iRoutingSender,&iControlSender,&iSocketHandler);
-    CAmControlReceiver iControlReceiver(&iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter);
+    CAmCommandReceiver iCommandReceiver(ptr_iDatabaseHandler,&iControlSender,&iSocketHandler);
+    CAmRoutingReceiver iRoutingReceiver(ptr_iDatabaseHandler,&iRoutingSender,&iControlSender,&iSocketHandler);
+    CAmControlReceiver iControlReceiver(ptr_iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter);
 #endif /*WITH_DBUS_WRAPPER*/
 
 
 #ifdef WITH_TELNET
-    CAmTelnetServer iTelnetServer(&iSocketHandler, &iCommandSender, &iCommandReceiver, &iRoutingSender, &iRoutingReceiver, &iControlSender, &iControlReceiver, &iDatabaseHandler, &iRouter, telnetport, maxConnections);
+    CAmTelnetServer iTelnetServer(&iSocketHandler, &iCommandSender, &iCommandReceiver, &iRoutingSender, &iRoutingReceiver, &iControlSender, &iControlReceiver, ptr_iDatabaseHandler, &iRouter, telnetport, maxConnections);
     CAmDatabaseObserver iObserver(&iCommandSender, &iRoutingSender, &iSocketHandler, &iTelnetServer);
 #else /*WITH_TELNET*/
     CAmDatabaseObserver iObserver(&iCommandSender,&iRoutingSender, &iSocketHandler);
@@ -358,7 +365,11 @@ void mainProgram()
 
     //start the mainloop here....
     iSocketHandler.start_listenting();
-
+    if(ptr_iDatabaseHandler)
+    {
+		delete ptr_iDatabaseHandler;
+		ptr_iDatabaseHandler = NULL;
+    }
 }
 
 /**
diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
new file mode 100644
index 0000000..c1f0cce
--- /dev/null
+++ b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
@@ -0,0 +1,2286 @@
+/**
+ * Copyright (C) 2012, BMW AG
+ *
+ * This file is part of GENIVI Project AudioManager.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
+ *
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#include "CAmMapHandlerTest.h"
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <set>
+#include <ios>
+#include "shared/CAmDltWrapper.h"
+
+using namespace am;
+using namespace testing;
+
+//extern int GetRandomNumber(int nLow, int nHigh);
+//extern bool equalSoundProperty (const am_SoundProperty_s a, const am_SoundProperty_s b);
+extern bool equalMainSoundProperty(const am_MainSoundProperty_s a, const am_MainSoundProperty_s b);
+extern bool equalNotificationConfiguration(const am_NotificationConfiguration_s a, const am_NotificationConfiguration_s b);
+//extern bool equalRoutingElement(const am_RoutingElement_s a, const am_RoutingElement_s b);
+extern bool equalClassProperties(const am_ClassProperty_s a, const am_ClassProperty_s b);
+extern std::string int2string(int i);
+
+CAmMapHandlerTest::CAmMapHandlerTest() :
+        plistRoutingPluginDirs(), //
+        plistCommandPluginDirs(), //
+        pSocketHandler(),//
+        pDatabaseHandler(), //
+        pRoutingSender(plistRoutingPluginDirs), //
+        pCommandSender(plistCommandPluginDirs), //
+        pMockInterface(), //
+        pRoutingInterfaceBackdoor(), //
+        pCommandInterfaceBackdoor(), //
+        pControlSender(), //
+        pRouter(&pDatabaseHandler, &pControlSender), //
+        pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,  &pSocketHandler, &pRouter), //
+        pObserver(&pCommandSender,&pRoutingSender, &pSocketHandler)
+{
+    pDatabaseHandler.registerObserver(&pObserver);
+    pCommandInterfaceBackdoor.injectInterface(&pCommandSender, &pMockInterface);
+}
+
+CAmMapHandlerTest::~CAmMapHandlerTest()
+{
+}
+
+void CAmMapHandlerTest::createMainConnectionSetup()
+{
+    //fill the connection database
+    am_Connection_s connection;
+    am_Source_s source;
+    am_Sink_s sink;
+    std::vector<am_connectionID_t> connectionList;
+
+    //we create 9 sources and sinks:
+
+
+
+    for (uint16_t i = 1; i < 10; i++)
+    {
+        am_sinkID_t forgetSink;
+        am_sourceID_t forgetSource;
+        am_connectionID_t connectionID;
+
+        pCF.createSink(sink);
+        sink.sinkID = i;
+        sink.name = "sink" + int2string(i);
+        sink.domainID = 4;
+        pCF.createSource(source);
+        source.sourceID = i;
+        source.name = "source" + int2string(i);
+        source.domainID = 4;
+
+        connection.sinkID = i;
+        connection.sourceID = i;
+        connection.delay = -1;
+        connection.connectionFormat = CF_GENIVI_ANALOG;
+        connection.connectionID = 0;
+
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
+        ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
+        connectionList.push_back(connectionID);
+
+    }
+
+    //create a mainConnection
+    am_MainConnection_s mainConnection;
+    am_mainConnectionID_t mainConnectionID;
+    std::vector<am_MainConnection_s> mainConnectionList;
+    mainConnection.listConnectionID = connectionList;
+    mainConnection.mainConnectionID = 0;
+    mainConnection.sinkID = 1;
+    mainConnection.sourceID = 1;
+    mainConnection.connectionState = CS_CONNECTED;
+    mainConnection.delay = -1;
+
+    //enter mainconnection in database
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
+    ASSERT_NE(0, mainConnectionID);
+
+    //read out the mainconnections and check if they are equal to the data written.
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(mainConnectionList));
+    bool equal = true;
+    std::vector<am_MainConnection_s>::iterator listIterator = mainConnectionList.begin();
+    for (; listIterator < mainConnectionList.end(); ++listIterator)
+    {
+        if (listIterator->mainConnectionID == mainConnectionID)
+        {
+            equal = equal && (listIterator->connectionState == mainConnection.connectionState) && (listIterator->sinkID == mainConnection.sinkID) && (listIterator->sourceID == mainConnection.sourceID) && (listIterator->delay == mainConnection.delay) && (std::equal(listIterator->listConnectionID.begin(), listIterator->listConnectionID.end(), connectionList.begin()));
+        }
+    }
+    ASSERT_EQ(true, equal);
+}
+
+void CAmMapHandlerTest::SetUp()
+{
+}
+
+void CAmMapHandlerTest::TearDown()
+{
+}
+
+TEST_F(CAmMapHandlerTest,getMainConnectionInfo)
+{
+    //fill the connection database
+    am_Connection_s connection;
+    am_Source_s source;
+    am_Sink_s sink;
+    std::vector<am_connectionID_t> connectionList;
+
+    //we create 9 sources and sinks:
+    uint16_t i = 1;
+    for (; i < 10; i++)
+    {
+        am_sinkID_t forgetSink;
+        am_sourceID_t forgetSource;
+        am_connectionID_t connectionID;
+
+        pCF.createSink(sink);
+        sink.sinkID = i;
+        sink.name = "sink" + int2string(i);
+        sink.domainID = 4;
+        pCF.createSource(source);
+        source.sourceID = i;
+        source.name = "source" + int2string(i);
+        source.domainID = 4;
+
+        connection.sinkID = i;
+        connection.sourceID = i;
+        connection.delay = -1;
+        connection.connectionFormat = CF_GENIVI_ANALOG;
+        connection.connectionID = 0;
+
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
+        ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
+        connectionList.push_back(connectionID);
+
+    }
+
+    //create a mainConnection
+    am_MainConnection_s mainConnection;
+    am_mainConnectionID_t mainConnectionID;
+    std::vector<am_MainConnection_s> mainConnectionList;
+    mainConnection.listConnectionID = connectionList;
+    mainConnection.mainConnectionID = 0;
+    mainConnection.sinkID = 1;
+    mainConnection.sourceID = 1;
+    mainConnection.connectionState = CS_CONNECTED;
+    mainConnection.delay = -1;
+
+    //enter mainconnection in database
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
+    ASSERT_NE(0, mainConnectionID);
+
+    //read out the mainconnections and check if they are equal to the data written.
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(mainConnectionList));
+    bool equal = true;
+    std::vector<am_MainConnection_s>::iterator listIterator = mainConnectionList.begin();
+    for (; listIterator < mainConnectionList.end(); ++listIterator)
+    {
+        if (listIterator->mainConnectionID == mainConnectionID)
+        {
+            equal = equal && (listIterator->connectionState == mainConnection.connectionState) && (listIterator->sinkID == mainConnection.sinkID) && (listIterator->sourceID == mainConnection.sourceID) && (listIterator->delay == mainConnection.delay) && (std::equal(listIterator->listConnectionID.begin(), listIterator->listConnectionID.end(), connectionList.begin()));
+        }
+    }ASSERT_EQ(true, equal);
+
+    am_MainConnection_s mainConnectionT;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getMainConnectionInfoDB(mainConnectionID,mainConnectionT));
+    ASSERT_TRUE( (mainConnection.connectionState==mainConnectionT.connectionState) && (mainConnection.delay==mainConnectionT.delay) && (std::equal(mainConnection.listConnectionID.begin(),mainConnection.listConnectionID.end(),mainConnectionT.listConnectionID.begin())) && (mainConnection.sinkID==mainConnectionT.sinkID) && (mainConnection.sourceID==mainConnectionT.sourceID) && (mainConnectionID==mainConnectionT.mainConnectionID));
+
+}
+
+TEST_F(CAmMapHandlerTest,getSinkInfo)
+{
+    //fill the connection database
+    am_Sink_s staticSink, firstDynamicSink, secondDynamicSink;
+    am_sinkID_t staticSinkID, firstDynamicSinkID, secondDynamicSinkID;
+    std::vector<am_Sink_s> sinkList;
+
+    pCF.createSink(staticSink);
+    staticSink.sinkID = 4;
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(staticSink.sinkID,staticSinkID)
+        << "ERROR: ID not the one given in staticSink";
+
+    pCF.createSink(firstDynamicSink);
+    firstDynamicSink.name = "firstdynamic";
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(firstDynamicSink,firstDynamicSinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(firstDynamicSinkID,DYNAMIC_ID_BOUNDARY)
+        << "ERROR: ID not the one given in firstDynamicSink";
+
+    pCF.createSink(secondDynamicSink);
+    secondDynamicSink.name = "seconddynamic";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(secondDynamicSink,secondDynamicSinkID))
+        << "ERROR: database error";
+    ASSERT_NEAR(secondDynamicSinkID,DYNAMIC_ID_BOUNDARY,10)
+        << "ERROR: ID not the one given in secondDynamicSink";
+
+    //now read back and check the returns agains the given values
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(sinkList))
+        << "ERROR: database error";
+    bool equal = true;
+
+    std::vector<am_Sink_s>::iterator listIterator = sinkList.begin();
+    for (; listIterator < sinkList.end(); ++listIterator)
+    {
+        if (listIterator->sinkID == staticSinkID)
+        {
+            equal = equal && pCF.compareSink(listIterator, staticSink);
+        }
+
+        if (listIterator->sinkID == firstDynamicSinkID)
+        {
+            equal = equal && pCF.compareSink(listIterator, firstDynamicSink);
+        }
+
+        if (listIterator->sinkID == secondDynamicSinkID)
+        {
+            equal = equal && pCF.compareSink(listIterator, secondDynamicSink);
+        }
+    }ASSERT_EQ(true, equal);
+
+    am_Sink_s sinkData;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getSinkInfoDB(secondDynamicSinkID,sinkData));
+    ASSERT_TRUE( (secondDynamicSink.available.availability == sinkData.available.availability) && //
+            (secondDynamicSink.available.availabilityReason == sinkData.available.availabilityReason) && //
+            (secondDynamicSink.sinkClassID == sinkData.sinkClassID) && //
+            (secondDynamicSink.domainID == sinkData.domainID) && //
+            (secondDynamicSink.visible == sinkData.visible) && //
+            (secondDynamicSink.name.compare(sinkData.name) == 0) && //
+            (secondDynamicSink.volume == sinkData.volume) && //
+            std::equal(secondDynamicSink.listConnectionFormats.begin(), secondDynamicSink.listConnectionFormats.end(), sinkData.listConnectionFormats.begin()) && //
+            std::equal(secondDynamicSink.listMainSoundProperties.begin(), secondDynamicSink.listMainSoundProperties.end(), sinkData.listMainSoundProperties.begin(), equalMainSoundProperty) && //
+            std::equal(secondDynamicSink.listNotificationConfigurations.begin(), secondDynamicSink.listNotificationConfigurations.end(), sinkData.listNotificationConfigurations.begin(), equalNotificationConfiguration) && //
+            std::equal(secondDynamicSink.listMainNotificationConfigurations.begin(), secondDynamicSink.listMainNotificationConfigurations.end(), sinkData.listMainNotificationConfigurations.begin(), equalNotificationConfiguration) //
+            );
+
+}
+
+TEST_F(CAmMapHandlerTest,getSourceInfo)
+{
+    //fill the connection database
+    am_Source_s staticSource, firstDynamicSource, secondDynamicSource;
+    am_sourceID_t staticSourceID, firstDynamicSourceID, secondDynamicSourceID;
+    std::vector<am_Source_s> sourceList;
+
+    pCF.createSource(staticSource);
+    staticSource.sourceID = 4;
+    staticSource.name = "Static";
+
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(staticSource.sourceID,staticSourceID)
+        << "ERROR: ID not the one given in staticSource";
+
+    pCF.createSource(firstDynamicSource);
+    firstDynamicSource.name = "firstDynamicSource";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(firstDynamicSource,firstDynamicSourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(firstDynamicSourceID,DYNAMIC_ID_BOUNDARY)
+        << "ERROR: ID not the one given in firstDynamicSink";
+
+
+    pCF.createSource(secondDynamicSource);
+    secondDynamicSource.name = "secondDynamicSource";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(secondDynamicSource,secondDynamicSourceID))
+        << "ERROR: database error";
+    ASSERT_NEAR(secondDynamicSourceID,DYNAMIC_ID_BOUNDARY,10)
+        << "ERROR: ID not the one given in secondDynamicSink";
+
+    //now read back and check the returns agains the given values
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(sourceList))
+        << "ERROR: database error";
+
+    bool equal = true;
+
+    std::vector<am_Source_s>::iterator listIterator = sourceList.begin();
+    for (; listIterator < sourceList.end(); ++listIterator)
+    {
+        if (listIterator->sourceID == staticSourceID)
+        {
+            equal = equal && pCF.compareSource(listIterator, staticSource);
+        }
+
+        if (listIterator->sourceID == firstDynamicSourceID)
+        {
+            equal = equal && pCF.compareSource(listIterator, firstDynamicSource);
+        }
+
+        if (listIterator->sourceID == secondDynamicSourceID)
+        {
+            equal = equal && pCF.compareSource(listIterator, secondDynamicSource);
+        }
+    }
+
+    ASSERT_EQ(true, equal);
+
+    am_Source_s sourceData;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getSourceInfoDB(secondDynamicSourceID,sourceData));
+    ASSERT_TRUE((secondDynamicSource.available.availability == sourceData.available.availability) && //
+            (secondDynamicSource.available.availabilityReason == sourceData.available.availabilityReason) && //
+            (secondDynamicSource.sourceClassID == sourceData.sourceClassID) && (secondDynamicSource.domainID == sourceData.domainID) && //
+            (secondDynamicSource.interruptState == sourceData.interruptState) && (secondDynamicSource.visible == sourceData.visible) && //
+            (secondDynamicSource.name.compare(sourceData.name) == 0) && (secondDynamicSource.volume == sourceData.volume) && //
+            std::equal(secondDynamicSource.listConnectionFormats.begin(), secondDynamicSource.listConnectionFormats.end(), sourceData.listConnectionFormats.begin()) && //
+            std::equal(secondDynamicSource.listMainSoundProperties.begin(), secondDynamicSource.listMainSoundProperties.end(), sourceData.listMainSoundProperties.begin(), equalMainSoundProperty) && //
+            std::equal(secondDynamicSource.listMainNotificationConfigurations.begin(), secondDynamicSource.listMainNotificationConfigurations.end(), sourceData.listMainNotificationConfigurations.begin(), equalNotificationConfiguration) && //
+            std::equal(secondDynamicSource.listNotificationConfigurations.begin(), secondDynamicSource.listNotificationConfigurations.end(), sourceData.listNotificationConfigurations.begin(), equalNotificationConfiguration) //
+    );
+
+}
+
+TEST_F(CAmMapHandlerTest, peekSourceID)
+{
+
+    std::string sourceName("myClassID");
+    am_sourceClass_t sourceClassID, peekID;
+    am_SourceClass_s sourceClass;
+    am_ClassProperty_s classProperty;
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 13;
+    sourceClass.name = sourceName;
+    sourceClass.sourceClassID = 0;
+    sourceClass.listClassProperties.push_back(classProperty);
+
+    //first we peek without an existing class
+    ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSourceClassID(sourceName,sourceClassID));
+
+    //now we enter the class into the database
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
+
+    //first we peek without an existing class
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSourceClassID(sourceName,peekID));
+    ASSERT_EQ(sourceClassID, peekID);
+}
+
+TEST_F(CAmMapHandlerTest, peekSinkID)
+{
+
+    std::string sinkName("myClassID");
+    am_sinkClass_t sinkClassID, peekID;
+    am_SinkClass_s sinkClass;
+    am_ClassProperty_s classProperty;
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 13;
+    sinkClass.name = sinkName;
+    sinkClass.sinkClassID = 0;
+    sinkClass.listClassProperties.push_back(classProperty);
+
+    //first we peek without an existing class
+    ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSinkClassID(sinkName,sinkClassID));
+
+    //now we enter the class into the database
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
+
+    //first we peek without an existing class
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSinkClassID(sinkName,peekID));
+    ASSERT_EQ(sinkClassID, peekID);
+}
+
+TEST_F(CAmMapHandlerTest,crossfaders)
+{
+
+
+
+    am_Crossfader_s crossfader;
+    am_crossfaderID_t crossfaderID;
+    am_Sink_s sinkA, sinkB;
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    am_sinkID_t sinkAID, sinkBID;
+    pCF.createSink(sinkA);
+    pCF.createSink(sinkB);
+    sinkB.name = "sinkB";
+    pCF.createSource(source);
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkB,sinkBID));
+
+    crossfader.crossfaderID = 0;
+    crossfader.hotSink = HS_SINKA;
+    crossfader.sinkID_A = sinkAID;
+    crossfader.sinkID_B = sinkBID;
+    crossfader.sourceID = sourceID;
+    crossfader.name = "Crossfader";
+    crossfader.hotSink = HS_UNKNOWN;
+
+    std::vector<am_Crossfader_s> listCrossfaders;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterCrossfaderDB(crossfader,crossfaderID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListCrossfaders(listCrossfaders));
+    ASSERT_EQ(crossfader.sinkID_A, listCrossfaders[0].sinkID_A);
+    ASSERT_EQ(crossfader.sinkID_B, listCrossfaders[0].sinkID_B);
+    ASSERT_EQ(crossfader.sourceID, listCrossfaders[0].sourceID);
+    ASSERT_EQ(crossfader.hotSink, listCrossfaders[0].hotSink);
+    ASSERT_EQ(100, listCrossfaders[0].crossfaderID);
+    ASSERT_EQ(crossfader.name.compare(listCrossfaders[0].name), 0);
+}
+
+TEST_F(CAmMapHandlerTest,crossfadersGetFromDomain)
+{
+
+
+
+    am_Crossfader_s crossfader;
+    am_crossfaderID_t crossfaderID;
+    am_Sink_s sinkA, sinkB;
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    am_sinkID_t sinkAID, sinkBID;
+    am_domainID_t domainID;
+    am_Domain_s domain;
+    pCF.createSink(sinkA);
+    pCF.createSink(sinkB);
+    pCF.createDomain(domain);
+    sinkB.name = "sinkB";
+    pCF.createSource(source);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    source.domainID = domainID;
+    sinkA.domainID = domainID;
+    sinkB.domainID = domainID;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkB,sinkBID));
+
+    crossfader.crossfaderID = 0;
+    crossfader.hotSink = HS_SINKA;
+    crossfader.sinkID_A = sinkAID;
+    crossfader.sinkID_B = sinkBID;
+    crossfader.sourceID = sourceID;
+    crossfader.name = "Crossfader";
+    crossfader.hotSink = HS_UNKNOWN;
+
+    std::vector<am_crossfaderID_t> listCrossfaders;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterCrossfaderDB(crossfader,crossfaderID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListCrossfadersOfDomain(source.domainID,listCrossfaders));
+    ASSERT_EQ(100, listCrossfaders[0]);
+
+}
+
+TEST_F(CAmMapHandlerTest,sourceState)
+{
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    std::vector<am_Source_s> listSources;
+    pCF.createSource(source);
+    source.sourceState = SS_OFF;
+
+    //prepare the test
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+
+    //change the source state
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceState(sourceID,SS_ON));
+
+    //read out the changed values
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_EQ(listSources[0].sourceState, SS_ON);
+}
+
+TEST_F(CAmMapHandlerTest,sinkVolumeChange)
+{
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    std::vector<am_Sink_s> listSinks;
+    pCF.createSink(sink);
+    sink.volume = 23;
+
+    //prepare the test
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+    //change the volume and check the read out
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkVolume(sinkID,34));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_EQ(listSinks[0].volume, 34);
+}
+
+TEST_F(CAmMapHandlerTest,sourceVolumeChange)
+{
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    std::vector<am_Source_s> listSources;
+    pCF.createSource(source);
+    source.volume = 23;
+
+    //prepare test
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+
+    //change the volume and check the read out
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceVolume(sourceID,34));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_EQ(listSources[0].volume, 34);
+}
+
+TEST_F(CAmMapHandlerTest, peekSource)
+{
+    std::vector<am_Source_s> listSources;
+    am_sourceID_t sourceID, source2ID, source3ID;
+    am_Source_s source;
+    pCF.createSource(source);
+
+    //peek a source that does not exits
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource"),sourceID));
+
+    //make sure it is not in the list
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_TRUE(listSources.empty());
+    ASSERT_EQ(sourceID, DYNAMIC_ID_BOUNDARY);
+
+    //now enter the source with the same name and make sure it does not get a new ID
+    source.name = "newsource";
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source2ID));
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_EQ(sourceID, source2ID);
+    ASSERT_TRUE(listSources.at(0).sourceID==sourceID);
+
+    //now we peek again. This time, the source exists
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(source.name,source3ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_TRUE(listSources.size()==1);
+    ASSERT_EQ(source3ID, source2ID);
+}
+
+TEST_F(CAmMapHandlerTest, peekSourceDouble)
+{
+    std::vector<am_Source_s> listSources;
+    am_sourceID_t sourceID;
+    am_sourceID_t source2ID;
+    am_sourceID_t source3ID;
+    am_Source_s source;
+    pCF.createSource(source);
+
+    //peek a source that does not exits
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource"),sourceID));
+
+    //peek a second source that does not exits
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource2"),source2ID));
+
+    //make sure they are is not in the list
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_TRUE(listSources.empty());
+    ASSERT_EQ(sourceID, 100);
+    source.name = "newsource";
+
+    //now enter the source with the same name than the first peek and make sure it does not get a new ID
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source3ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_EQ(sourceID, source3ID);
+    ASSERT_TRUE(listSources[0].sourceID==sourceID);
+}
+
+TEST_F(CAmMapHandlerTest, peekSink)
+{
+    std::vector<am_Sink_s> listSinks;
+    am_sinkID_t sinkID, sink2ID, sink3ID;
+    am_Sink_s sink;
+    pCF.createSink(sink);
+
+    //peek a sink that does not exits
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("newsink"),sinkID));
+
+    //make sure it is not in the list
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_TRUE(listSinks.empty());
+    ASSERT_EQ(sinkID, 100);
+    sink.name = "newsink";
+
+    //now enter the source with the same name and make sure it does not get a new ID
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink2ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_EQ(sinkID, sink2ID);
+    ASSERT_TRUE(listSinks[0].sinkID==sinkID);
+
+    //now we peek again, this time, the sink exists
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(sink.name,sink3ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_TRUE(listSinks.size()==1);
+    ASSERT_EQ(sink3ID, sink2ID);
+}
+
+TEST_F(CAmMapHandlerTest, peekSinkDouble)
+{
+    std::vector<am_Sink_s> listSinks;
+    am_sinkID_t sinkID;
+    am_sinkID_t sink2ID;
+    am_sinkID_t sink3ID;
+    am_Sink_s sink;
+    pCF.createSink(sink);
+
+    //peek a sink that does not exits
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("newsink"),sinkID));
+
+    //peek again
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("nextsink"),sink2ID));
+
+    //make sure they are is not in the list
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_TRUE(listSinks.empty());
+    ASSERT_EQ(sinkID, 100);
+    sink.name = "newsink";
+
+    //now enter the sink with the same name than the first peek and make sure it does not get a new ID
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink3ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_EQ(sinkID, sink3ID);
+    ASSERT_TRUE(listSinks[0].sinkID==sinkID);
+}
+
+TEST_F(CAmMapHandlerTest,changeConnectionTimingInformationCheckMainConnection)
+{
+    std::vector<am_Connection_s> connectionList;
+    std::vector<am_MainConnectionType_s> mainList;
+
+    //prepare the test, it is one mainconnection, so we expect one callback
+    createMainConnectionSetup();
+
+    //first get all visible mainconnections and make sure, the delay is set to -1 for the first entry
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(mainList));
+    ASSERT_EQ(mainList[0].delay, -1);
+
+    //no go through all connections and set the delay time to 24 for each connection
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
+    std::vector<am_Connection_s>::iterator iteratorConnectionList = connectionList.begin();
+    for (; iteratorConnectionList < connectionList.end(); ++iteratorConnectionList)
+    {
+        ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(iteratorConnectionList->connectionID,24));
+    }
+
+    //we read the result again and expect that the value is now different from -1
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(mainList));
+    ASSERT_EQ(mainList[0].delay, 216);
+}
+
+TEST_F(CAmMapHandlerTest,changeConnectionTimingInformation)
+{
+    am_Connection_s connection;
+    am_connectionID_t connectionID;
+    std::vector<am_Connection_s> connectionList;
+    pCF.createConnection(connection);
+
+    //enter a connection
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
+
+    //change the timing and check it
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(connectionID,24));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
+    ASSERT_TRUE(connectionList[0].delay==24);
+}
+
+TEST_F(CAmMapHandlerTest,getSinkClassOfSink)
+{
+    std::vector<am_SinkClass_s> sinkClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SinkClass_s sinkClass, returnClass;
+    am_ClassProperty_s classProperty;
+    am_sinkClass_t sinkClassID;
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sinkClass.name = "test";
+    sinkClass.sinkClassID = 4;
+    sinkClass.listClassProperties = classPropertyList;
+    pCF.createSink(sink);
+    sink.sinkClassID = 4;
+
+    //prepare test
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+    //enter a new sinkclass, read out again and check
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
+    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
+    ASSERT_EQ(sinkClassList[0].sinkClassID, 4);
+    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.getSinkClassInfoDB(sinkID,returnClass));
+    ASSERT_EQ(sinkClassList[0].name, returnClass.name);
+    ASSERT_EQ(sinkClassList[0].sinkClassID, returnClass.sinkClassID);
+    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),returnClass.listClassProperties.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest,getSourceClassOfSource)
+{
+    std::vector<am_SourceClass_s> sourceClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SourceClass_s sourceClass, sinkSourceClass;
+    am_ClassProperty_s classProperty;
+    am_sourceClass_t sourceClassID;
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sourceClass.name = "test";
+    sourceClass.sourceClassID = 1;
+    sourceClass.listClassProperties = classPropertyList;
+    pCF.createSource(source);
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
+    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, 1);
+    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getSourceClassInfoDB(sourceID,sinkSourceClass));
+    ASSERT_EQ(sourceClassList[0].name, sinkSourceClass.name);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, sinkSourceClass.sourceClassID);
+    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),sinkSourceClass.listClassProperties.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest,removeSourceClass)
+{
+    std::vector<am_SourceClass_s> sourceClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SourceClass_s sourceClass;
+    am_ClassProperty_s classProperty;
+    am_sourceClass_t sourceClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sourceClass.name = "test";
+    sourceClass.sourceClassID = 3;
+    sourceClass.listClassProperties = classPropertyList;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
+    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, 3);
+    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+    ASSERT_EQ(E_OK, pDatabaseHandler.removeSourceClassDB(3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
+    ASSERT_TRUE(sourceClassList.empty());
+}
+
+TEST_F(CAmMapHandlerTest,updateSourceClass)
+{
+    std::vector<am_SourceClass_s> sourceClassList;
+    std::vector<am_ClassProperty_s> classPropertyList, changedPropertyList;
+    am_SourceClass_s sourceClass, changedClass;
+    am_ClassProperty_s classProperty;
+    am_sourceClass_t sourceClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sourceClass.name = "test";
+    sourceClass.sourceClassID = 0;
+    sourceClass.listClassProperties = classPropertyList;
+    changedClass = sourceClass;
+    changedClass.listClassProperties[1].value = 6;
+    changedPropertyList = changedClass.listClassProperties;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
+    changedClass.sourceClassID = sourceClassID;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
+    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, 100);
+    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceClassInfoDB(changedClass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
+    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, 100);
+    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),changedPropertyList.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest,enterSourceClass)
+{
+    std::vector<am_SourceClass_s> sourceClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SourceClass_s sourceClass;
+    am_ClassProperty_s classProperty;
+    am_sourceClass_t sourceClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sourceClass.name = "test";
+    sourceClass.sourceClassID = 0;
+    sourceClass.listClassProperties = classPropertyList;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
+    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, 100);
+    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest,enterSourceClassStatic)
+{
+    std::vector<am_SourceClass_s> sourceClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SourceClass_s sourceClass;
+    am_ClassProperty_s classProperty;
+    am_sourceClass_t sourceClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sourceClass.name = "test";
+    sourceClass.sourceClassID = 3;
+    sourceClass.listClassProperties = classPropertyList;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
+    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, 3);
+    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest,removeSinkClass)
+{
+    std::vector<am_SinkClass_s> sinkClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SinkClass_s sinkClass;
+    am_ClassProperty_s classProperty;
+    am_sinkClass_t sinkClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sinkClass.name = "test";
+    sinkClass.sinkClassID = 0;
+    sinkClass.listClassProperties = classPropertyList;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
+    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
+    ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
+    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+    ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkClassDB(sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
+    ASSERT_TRUE(sinkClassList.empty());
+}
+
+TEST_F(CAmMapHandlerTest,updateSinkClass)
+{
+    std::vector<am_SinkClass_s> sinkClassList;
+    std::vector<am_ClassProperty_s> classPropertyList, changedPropertyList;
+    am_SinkClass_s sinkClass, changedClass;
+    am_ClassProperty_s classProperty;
+    am_sinkClass_t sinkClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sinkClass.name = "test";
+    sinkClass.sinkClassID = 0;
+    sinkClass.listClassProperties = classPropertyList;
+    changedClass = sinkClass;
+    changedClass.listClassProperties[1].value = 6;
+    changedPropertyList = changedClass.listClassProperties;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
+    changedClass.sinkClassID = sinkClassID;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
+    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
+    ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
+    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkClassInfoDB(changedClass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
+    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
+    ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
+    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),changedPropertyList.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest,enterSinkClass)
+{
+    std::vector<am_SinkClass_s> sinkClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SinkClass_s sinkClass;
+    am_ClassProperty_s classProperty;
+    am_sinkClass_t sinkClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sinkClass.name = "test";
+    sinkClass.sinkClassID = 0;
+    sinkClass.listClassProperties = classPropertyList;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
+    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
+    ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
+    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest,enterSinkClassStatic)
+{
+    std::vector<am_SinkClass_s> sinkClassList;
+    std::vector<am_ClassProperty_s> classPropertyList;
+    am_SinkClass_s sinkClass;
+    am_ClassProperty_s classProperty;
+    am_sinkClass_t sinkClassID;
+    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
+    classProperty.value = 1;
+    classPropertyList.push_back(classProperty);
+    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
+    classProperty.value = 4;
+    classPropertyList.push_back(classProperty);
+    sinkClass.name = "test";
+    sinkClass.sinkClassID = 4;
+    sinkClass.listClassProperties = classPropertyList;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
+    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
+    ASSERT_EQ(sinkClassList[0].sinkClassID, 4);
+    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
+}
+
+TEST_F(CAmMapHandlerTest, changeSystemProperty)
+{
+    std::vector<am_SystemProperty_s> listSystemProperties, listReturn;
+    am_SystemProperty_s systemProperty;
+
+    systemProperty.type = SYP_UNKNOWN;
+    systemProperty.value = 33;
+    listSystemProperties.push_back(systemProperty);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSystemProperties(listSystemProperties));
+    systemProperty.value = 444;
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSystemPropertyDB(systemProperty));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSystemProperties(listReturn));
+    ASSERT_EQ(listReturn[0].type, systemProperty.type);
+    ASSERT_EQ(listReturn[0].value, systemProperty.value);
+}
+
+TEST_F(CAmMapHandlerTest, systemProperties)
+{
+    std::vector<am_SystemProperty_s> listSystemProperties, listReturn;
+    am_SystemProperty_s systemProperty;
+
+    systemProperty.type = SYP_UNKNOWN;
+    systemProperty.value = 33;
+    listSystemProperties.push_back(systemProperty);
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSystemProperties(listSystemProperties));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSystemProperties(listReturn));
+    ASSERT_EQ(listReturn[0].type, systemProperty.type);
+    ASSERT_EQ(listReturn[0].value, systemProperty.value);
+}
+
+TEST_F(CAmMapHandlerTest,enterSourcesCorrect)
+{
+    //fill the connection database
+    am_Source_s staticSource, firstDynamicSource, secondDynamicSource;
+    am_sourceID_t staticSourceID, firstDynamicSourceID, secondDynamicSourceID;
+    std::vector<am_Source_s> sourceList;
+
+    pCF.createSource(staticSource);
+    staticSource.sourceID = 4;
+    staticSource.name = "Static";
+
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(staticSource.sourceID,staticSourceID)
+        << "ERROR: ID not the one given in staticSource";
+
+    pCF.createSource(firstDynamicSource);
+    firstDynamicSource.name = "firstDynamicSource";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(firstDynamicSource,firstDynamicSourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(firstDynamicSourceID,DYNAMIC_ID_BOUNDARY)
+        << "ERROR: ID not the one given in firstDynamicSink";
+
+    pCF.createSource(secondDynamicSource);
+    secondDynamicSource.name = "secondDynamicSource";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(secondDynamicSource,secondDynamicSourceID))
+        << "ERROR: database error";
+    ASSERT_NEAR(secondDynamicSourceID,DYNAMIC_ID_BOUNDARY,10)
+        << "ERROR: ID not the one given in secondDynamicSink";
+
+    //now read back and check the returns agains the given values
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(sourceList))
+        << "ERROR: database error";
+    bool equal = true;
+
+    std::vector<am_Source_s>::iterator listIterator = sourceList.begin();
+    for (; listIterator < sourceList.end(); ++listIterator)
+    {
+        if (listIterator->sourceID == staticSourceID)
+        {
+            equal = equal && pCF.compareSource(listIterator, staticSource);
+        }
+
+        if (listIterator->sourceID == firstDynamicSourceID)
+        {
+            equal = equal && pCF.compareSource(listIterator, firstDynamicSource);
+        }
+
+        if (listIterator->sourceID == secondDynamicSourceID)
+        {
+            equal = equal && pCF.compareSource(listIterator, secondDynamicSource);
+        }
+
+    }
+    ASSERT_EQ(true, equal);
+}
+
+TEST_F(CAmMapHandlerTest, changeSourceMainSoundProperty)
+{
+    std::vector<am_Source_s> listSources;
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    pCF.createSource(source);
+    am_MainSoundProperty_s property;
+    property.type = MSP_UNKNOWN;
+    property.value = 33;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSourceSoundPropertyDB(property,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    std::vector<am_MainSoundProperty_s>::iterator listIterator = listSources[0].listMainSoundProperties.begin();
+    for (; listIterator < listSources[0].listMainSoundProperties.end(); ++listIterator)
+    {
+        if (listIterator->type == property.type)
+        {
+            ASSERT_EQ(listIterator->value, property.value);
+        }
+    }
+}
+
+TEST_F(CAmMapHandlerTest, changeSinkMuteState)
+{
+    std::vector<am_Sink_s> listSinks;
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    pCF.createSink(sink);
+    am_MuteState_e muteState = MS_MUTED;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMuteStateDB(muteState,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_EQ(muteState, listSinks[0].muteState);
+}
+
+TEST_F(CAmMapHandlerTest, changeSinkMainSoundProperty)
+{
+    std::vector<am_Sink_s> listSinks;
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    pCF.createSink(sink);
+    am_MainSoundProperty_s property;
+    property.type = MSP_UNKNOWN;
+    property.value = 33;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSinkSoundPropertyDB(property,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    std::vector<am_MainSoundProperty_s>::iterator listIterator = listSinks[0].listMainSoundProperties.begin();
+    for (; listIterator < listSinks[0].listMainSoundProperties.end(); ++listIterator)
+    {
+        if (listIterator->type == property.type)
+        {
+            ASSERT_EQ(listIterator->value, property.value);
+        }
+    }
+}
+
+TEST_F(CAmMapHandlerTest, peekDomain)
+{
+    std::vector<am_Domain_s> listDomains;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+    am_domainID_t domain2ID;
+    pCF.createDomain(domain);
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
+    ASSERT_TRUE(listDomains.empty());
+    ASSERT_EQ(domainID, 1);
+    domain.name = "newdomain";
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
+    ASSERT_EQ(domainID, domain2ID);
+    ASSERT_TRUE(listDomains[0].domainID==domainID);
+}
+
+TEST_F(CAmMapHandlerTest, peekDomainFirstEntered)
+{
+    std::vector<am_Domain_s> listDomains;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+    am_domainID_t domain2ID;
+    pCF.createDomain(domain);
+    domain.name = "newdomain";
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domain2ID));
+    ASSERT_EQ(domainID, domain2ID);
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
+    ASSERT_TRUE(listDomains.size()==1);
+}
+
+TEST_F(CAmMapHandlerTest, changeDomainState)
+{
+    std::vector<am_Domain_s> listDomains;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+    pCF.createDomain(domain);
+    am_DomainState_e newState = DS_INDEPENDENT_STARTUP;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.changDomainStateDB(newState,domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
+    ASSERT_EQ(newState, listDomains[0].state);
+}
+
+TEST_F(CAmMapHandlerTest, changeMainConnectionState)
+{
+    std::vector<am_MainConnection_s> listMainConnections;
+    createMainConnectionSetup();
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionStateDB(1,CS_DISCONNECTING));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(listMainConnections));
+    ASSERT_EQ(CS_DISCONNECTING, listMainConnections[0].connectionState);
+}
+
+TEST_F(CAmMapHandlerTest, changeSinkAvailability)
+{
+    std::vector<am_Sink_s> listSinks;
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    pCF.createSink(sink);
+    am_Availability_s availability;
+    availability.availability = A_UNKNOWN;
+    availability.availabilityReason = AR_GENIVI_TEMPERATURE;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkAvailabilityDB(availability,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_EQ(availability.availability, listSinks[0].available.availability);
+    ASSERT_EQ(availability.availabilityReason, listSinks[0].available.availabilityReason);
+}
+
+TEST_F(CAmMapHandlerTest, changeSourceAvailability)
+{
+    std::vector<am_Source_s> listSources;
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    pCF.createSource(source);
+    am_Availability_s availability;
+    availability.availability = A_UNKNOWN;
+    availability.availabilityReason = AR_GENIVI_TEMPERATURE;
+    source.visible = true;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceAvailabilityDB(availability,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
+    ASSERT_EQ(availability.availability, listSources[0].available.availability);
+    ASSERT_EQ(availability.availabilityReason, listSources[0].available.availabilityReason);
+}
+
+TEST_F(CAmMapHandlerTest,changeMainConnectionRoute)
+{
+    std::vector<am_MainConnection_s> originalList;
+    std::vector<am_MainConnection_s> newList;
+    createMainConnectionSetup();
+    //fill the connection database
+    am_Connection_s connection;
+    am_Source_s source;
+    am_Sink_s sink;
+    std::vector<am_connectionID_t> listConnectionID;
+
+    uint16_t i = 1;
+    for (; i < 10; i++)
+    {
+        am_sinkID_t forgetSink;
+        am_sourceID_t forgetSource;
+        am_connectionID_t connectionID;
+
+        connection.sinkID = i + 20;
+        connection.sourceID = i + 20;
+        connection.delay = -1;
+        connection.connectionFormat = CF_GENIVI_ANALOG;
+        connection.connectionID = 0;
+
+        pCF.createSink(sink);
+        sink.sinkID = i + 20;
+        sink.name = "sink" + int2string(i + 20);
+        sink.domainID = 4;
+        pCF.createSource(source);
+        source.sourceID = i + 20;
+        source.name = "source" + int2string(i + 30);
+        source.domainID = 4;
+
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
+        ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
+        listConnectionID.push_back(connectionID);
+        ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(originalList));
+
+    }
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionRouteDB(1,listConnectionID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(newList));
+    ASSERT_FALSE(std::equal(newList[0].listConnectionID.begin(),newList[0].listConnectionID.end(),originalList[0].listConnectionID.begin()));
+}
+
+TEST_F(CAmMapHandlerTest,changeMainSinkVolume)
+{
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    am_mainVolume_t newVol = 20;
+    std::vector<am_Sink_s> listSinks;
+    pCF.createSink(sink);
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMainVolumeDB(newVol,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
+    ASSERT_EQ(listSinks[0].mainVolume, newVol);
+}
+
+TEST_F(CAmMapHandlerTest,getMainSourceSoundProperties)
+{
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    pCF.createSource(source);
+    std::vector<am_MainSoundProperty_s> mainSoundProperties = source.listMainSoundProperties;
+    std::vector<am_MainSoundProperty_s> listMainSoundProperties;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSourceSoundProperties(sourceID,listMainSoundProperties));
+    ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
+}
+
+TEST_F(CAmMapHandlerTest,getMainSinkSoundProperties)
+{
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    pCF.createSink(sink);
+    std::vector<am_MainSoundProperty_s> mainSoundProperties = sink.listMainSoundProperties;
+    std::vector<am_MainSoundProperty_s> listMainSoundProperties;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinkSoundProperties(sinkID,listMainSoundProperties));
+    ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
+}
+
+TEST_F(CAmMapHandlerTest,getMainSources)
+{
+    am_Source_s source, source1, source2;
+    am_sourceID_t sourceID;
+    pCF.createSource(source);
+    pCF.createSource(source1);
+    pCF.createSource(source2);
+    source1.name = "source1";
+    source2.name = "source2";
+    bool equal = true;
+    source1.visible = false;
+    std::vector<am_SourceType_s> listMainSources;
+    std::vector<am_Source_s> listSources;
+
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    source.sourceID = sourceID;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source1,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source2,sourceID));
+    source2.sourceID = sourceID;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSources(listMainSources));
+    listSources.push_back(source);
+    listSources.push_back(source2);
+    std::vector<am_SourceType_s>::iterator listIterator = listMainSources.begin();
+    for (; listIterator < listMainSources.end(); ++listIterator)
+    {
+        equal = equal && pCF.compareSinkMainSource(listIterator, listSources);
+    }
+    ASSERT_TRUE(equal);
+}
+
+TEST_F(CAmMapHandlerTest,getMainSinks)
+{
+	am_Sink_s sink, sink1, sink2;
+    am_sinkID_t sinkID;
+    pCF.createSink(sink);
+    pCF.createSink(sink1);
+    pCF.createSink(sink2);
+    sink1.name = "sink1";
+    sink2.name = "sink2";
+    bool equal = true;
+    sink1.visible = false;
+    std::vector<am_SinkType_s> listMainSinks;
+    std::vector<am_Sink_s> listSinks;
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    sink.sinkID = sinkID;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink1,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink2,sinkID));
+    sink2.sinkID = sinkID;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinks(listMainSinks));
+    listSinks.push_back(sink);
+    listSinks.push_back(sink2);
+
+    std::vector<am_SinkType_s>::iterator listIterator = listMainSinks.begin();
+    for (; listIterator < listMainSinks.end(); ++listIterator)
+    {
+        equal = equal && pCF.compareSinkMainSink(listIterator, listSinks);
+    }
+    ASSERT_TRUE(equal);
+}
+
+TEST_F(CAmMapHandlerTest,getVisibleMainConnections)
+{
+    createMainConnectionSetup();
+    std::vector<am_MainConnectionType_s> listVisibleMainConnections;
+    std::vector<am_MainConnection_s> listMainConnections;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(listVisibleMainConnections));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(listMainConnections));
+    ASSERT_EQ(listMainConnections[0].mainConnectionID, listVisibleMainConnections[0].mainConnectionID);
+    ASSERT_EQ(listMainConnections[0].connectionState, listVisibleMainConnections[0].connectionState);
+    ASSERT_EQ(listMainConnections[0].delay, listVisibleMainConnections[0].delay);
+    ASSERT_EQ(listMainConnections[0].sinkID, listVisibleMainConnections[0].sinkID);
+    ASSERT_EQ(listMainConnections[0].sourceID, listVisibleMainConnections[0].sourceID);
+}
+
+TEST_F(CAmMapHandlerTest,getListSourcesOfDomain)
+{
+    am_Source_s source, source2;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+    am_sourceID_t sourceID;
+    std::vector<am_sourceID_t> sourceList, sourceCheckList;
+    pCF.createSource(source);
+    source.sourceID = 1;
+    source.name = "testSource";
+    source.domainID = 1;
+    pCF.createSource(source2);
+    source2.sourceID = 0;
+    source2.name = "testSource2";
+    source2.domainID = 5;
+    pCF.createDomain(domain);
+    sourceCheckList.push_back(1); //sink.sinkID);
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source2,sourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListSourcesOfDomain(2,sourceList))
+        << "ERROR: database error";ASSERT_TRUE(sourceList.empty());
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSourcesOfDomain(1,sourceList))
+        << "ERROR: database error";
+    ASSERT_TRUE(std::equal(sourceList.begin(),sourceList.end(),sourceCheckList.begin()) && !sourceList.empty());
+}
+
+TEST_F(CAmMapHandlerTest,getListSinksOfDomain)
+{
+    am_Sink_s sink, sink2;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+    am_sinkID_t sinkID;
+    std::vector<am_sinkID_t> sinkList, sinkCheckList;
+    pCF.createSink(sink);
+    sink.sinkID = 1;
+    sink.domainID = 1;
+    pCF.createSink(sink2);
+    sink2.domainID = 5;
+    sink2.name = "sink2";
+    pCF.createDomain(domain);
+    sinkCheckList.push_back(1); //sink.sinkID);
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink2,sinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListSinksOfDomain(2,sinkList))
+        << "ERROR: database error";ASSERT_TRUE(sinkList.empty());
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinksOfDomain(1,sinkList))
+        << "ERROR: database error";
+    ASSERT_TRUE(std::equal(sinkList.begin(),sinkList.end(),sinkCheckList.begin()) && !sinkList.empty());
+}
+
+TEST_F(CAmMapHandlerTest,getListGatewaysOfDomain)
+{
+    am_Gateway_s gateway, gateway2;
+    am_gatewayID_t gatewayID1, gatewayID2;
+    am_domainID_t domainID;
+    am_Domain_s domain;
+    std::vector<am_gatewayID_t> gatewayList, gatewayCheckList;
+
+    pCF.createDomain(domain);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+
+    pCF.createGateway(gateway);
+    gateway.gatewayID = 1;
+    gateway.name = "testGateway";
+    gateway.controlDomainID = domainID;
+    gateway.sourceID = 1;
+    gateway.sinkID = 1;
+    gateway.domainSinkID = 1;
+    gateway.domainSourceID = 1;
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID1))
+        << "ERROR: database error";
+    ASSERT_EQ(true, gatewayID1==1);
+
+    pCF.createGateway(gateway2);
+    gateway2.gatewayID = 2;
+    gateway2.name = "testGateway2";
+    gateway2.controlDomainID = 4;
+    gateway2.sourceID = 1;
+    gateway2.sinkID = 1;
+    gateway2.domainSinkID = 1;
+    gateway2.domainSourceID = 1;
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
+        << "ERROR: database error";
+    ASSERT_EQ(true, gatewayID2==2);
+    gatewayCheckList.push_back(gatewayID1);
+
+    am_Sink_s sink;
+    am_Source_s source;
+    am_sinkID_t sinkID;
+    am_sourceID_t sourceID;
+    pCF.createSink(sink);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    sink.sinkID = sinkID;
+
+    pCF.createSource(source);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    source.sourceID = sourceID;
+
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListGatewaysOfDomain(2,gatewayList))
+        << "ERROR: database error";
+    ASSERT_TRUE(gatewayList.empty());
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListGatewaysOfDomain(domainID,gatewayList))
+        << "ERROR: database error";
+    ASSERT_TRUE(std::equal(gatewayList.begin(),gatewayList.end(),gatewayCheckList.begin()) && !gatewayList.empty());
+}
+
+TEST_F(CAmMapHandlerTest,removeDomain)
+{
+    am_Domain_s domain;
+    am_domainID_t domainID;
+    std::vector<am_Domain_s> listDomains;
+    pCF.createDomain(domain);
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeDomainDB(domainID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListDomains(listDomains))
+        << "ERROR: database error";
+    ASSERT_TRUE(listDomains.empty());
+}
+
+TEST_F(CAmMapHandlerTest,removeGateway)
+{
+
+
+    am_Gateway_s gateway;
+    am_gatewayID_t gatewayID;
+    std::vector<am_Gateway_s> listGateways;
+    pCF.createGateway(gateway);
+    am_Sink_s sink;
+    am_Source_s source;
+    am_sinkID_t sinkID;
+    am_sourceID_t sourceID;
+    pCF.createSink(sink);
+    pCF.createSource(source);
+    sink.sinkID = 1;
+    source.sourceID = 2;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeGatewayDB(gatewayID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListGateways(listGateways))
+        << "ERROR: database error";
+    ASSERT_TRUE(listGateways.empty());
+}
+
+TEST_F(CAmMapHandlerTest,removeSink)
+{
+    am_Sink_s sink;
+    am_sinkID_t sinkID;
+    std::vector<am_Sink_s> listSinks;
+    pCF.createSink(sink);
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
+        << "ERROR: database error";
+    ASSERT_TRUE(listSinks.empty());
+}
+
+TEST_F(CAmMapHandlerTest,removeSource)
+{
+    //fill the connection database
+    am_Source_s source;
+    am_sourceID_t sourceID;
+    std::vector<am_Source_s> listSources;
+    pCF.createSource(source);
+
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources))
+        << "ERROR: database error";
+    ASSERT_TRUE(listSources.empty());
+}
+
+TEST_F(CAmMapHandlerTest, removeMainConnection)
+{
+    createMainConnectionSetup();
+
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeMainConnectionDB(1))
+        << "ERROR: database error";
+}
+
+TEST_F(CAmMapHandlerTest,removeNonexistentMainConnectionFail)
+{
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeMainConnectionDB(34))
+        << "ERROR: database error";
+}
+
+TEST_F(CAmMapHandlerTest,removeNonexistentSource)
+{
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeSourceDB(3))
+        << "ERROR: database error";
+}
+
+TEST_F(CAmMapHandlerTest,removeNonexistentSink)
+{
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeSinkDB(2))
+        << "ERROR: database error";
+}
+
+TEST_F(CAmMapHandlerTest,removeNonexistentGateway)
+{
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeGatewayDB(12))
+        << "ERROR: database error";
+}
+
+TEST_F(CAmMapHandlerTest,registerGatewayCorrect)
+{
+
+
+    //initialize gateway
+    std::vector<am_Gateway_s> returnList;
+    am_Gateway_s gateway, gateway1, gateway2;
+    am_gatewayID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0;
+
+    pCF.createGateway(gateway);
+    pCF.createGateway(gateway1);
+    gateway1.gatewayID = 20;
+    pCF.createGateway(gateway2);
+    am_Sink_s sink;
+    am_Source_s source;
+    am_sinkID_t sinkID;
+    am_sourceID_t sourceID;
+    pCF.createSink(sink);
+    pCF.createSource(source);
+    sink.sinkID = 1;
+    source.sourceID = 2;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
+        << "ERROR: database error";
+    ASSERT_EQ(100,gatewayID)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1))
+        << "ERROR: database error";
+    ASSERT_EQ(gateway1.gatewayID,gatewayID1)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
+        << "ERROR: database error";
+    ASSERT_EQ(101,gatewayID2)
+        << "ERROR: domainID zero";
+
+    //now check if we read out the correct values
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListGateways(returnList));
+    bool equal = true;
+    std::vector<am_Gateway_s>::iterator listIterator = returnList.begin();
+
+    for (; listIterator < returnList.end(); ++listIterator)
+    {
+        if (listIterator->gatewayID == gatewayID)
+        {
+            equal = equal && pCF.compareGateway(listIterator, gateway);
+        }
+
+        if (listIterator->gatewayID == gatewayID1)
+        {
+            equal = equal && pCF.compareGateway(listIterator, gateway1);
+        }
+
+        if (listIterator->gatewayID == gatewayID2)
+        {
+            equal = equal && pCF.compareGateway(listIterator, gateway2);
+        }
+    }
+
+    ASSERT_EQ(true, equal);
+}
+
+TEST_F(CAmMapHandlerTest,getGatewayInfo)
+{
+
+
+    //initialize gateway
+    std::vector<am_Gateway_s> returnList;
+    am_Gateway_s gateway, gateway1, gateway2;
+    am_gatewayID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0;
+
+    pCF.createGateway(gateway);
+    pCF.createGateway(gateway1);
+    gateway1.gatewayID = 20;
+    pCF.createGateway(gateway2);
+    am_Sink_s sink;
+    am_Source_s source;
+    am_sinkID_t sinkID;
+    am_sourceID_t sourceID;
+    pCF.createSink(sink);
+    pCF.createSource(source);
+    sink.sinkID = 1;
+    source.sourceID = 2;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
+        << "ERROR: database error";
+    ASSERT_EQ(100,gatewayID)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1))
+        << "ERROR: database error";
+    ASSERT_EQ(gateway1.gatewayID,gatewayID1)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
+        << "ERROR: database error";
+    ASSERT_EQ(101,gatewayID2)
+        << "ERROR: domainID zero";
+
+    //now check if we read out the correct values
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListGateways(returnList));
+    bool equal = true;
+    std::vector<am_Gateway_s>::iterator listIterator = returnList.begin();
+
+    for (; listIterator < returnList.end(); ++listIterator)
+    {
+        if (listIterator->gatewayID == gatewayID)
+        {
+            equal = equal && pCF.compareGateway(listIterator, gateway);
+        }
+
+        if (listIterator->gatewayID == gatewayID1)
+        {
+            equal = equal && pCF.compareGateway(listIterator, gateway1);
+        }
+
+        if (listIterator->gatewayID == gatewayID2)
+        {
+            equal = equal && pCF.compareGateway(listIterator, gateway2);
+        }
+    }
+
+    ASSERT_EQ(true, equal);
+
+    am_Gateway_s gatewayInfo;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getGatewayInfoDB(20,gatewayInfo));
+    ASSERT_TRUE(pCF.compareGateway1(gateway1,gatewayInfo));
+
+}
+
+TEST_F(CAmMapHandlerTest,enterSinkThatAlreadyExistFail)
+{
+    //fill the connection database
+    am_Sink_s staticSink, SecondSink;
+    am_sinkID_t staticSinkID, SecondSinkID;
+
+    pCF.createSink(staticSink);
+    staticSink.sinkID = 43;
+    staticSink.name = "Static";
+
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(staticSink.sinkID,staticSinkID)
+        << "ERROR: ID not the one given in staticSink";
+
+    pCF.createSink(SecondSink);
+    SecondSink.sinkID = 43;
+    SecondSink.name = "SecondSink";
+
+    ASSERT_EQ(E_ALREADY_EXISTS,pDatabaseHandler.enterSinkDB(SecondSink,SecondSinkID))
+        << "ERROR: database error";
+}
+
+TEST_F(CAmMapHandlerTest,enterSourcesThatAlreadyExistFail)
+{
+    //fill the connection database
+    am_Source_s staticSource, SecondSource;
+    am_sourceID_t staticSourceID, SecondSourceID;
+    pCF.createSource(staticSource);
+    staticSource.sourceID = 4;
+
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
+        << "ERROR: database error";
+    ASSERT_EQ(staticSource.sourceID,staticSourceID)
+        << "ERROR: ID not the one given in staticSource";
+
+    pCF.createSource(SecondSource);
+    SecondSource.sourceID = 4;
+
+    ASSERT_EQ(E_ALREADY_EXISTS,pDatabaseHandler.enterSourceDB(SecondSource,SecondSourceID))
+        << "ERROR: database error";
+}
+
+TEST_F(CAmMapHandlerTest,registerDomainCorrect)
+{
+    //initialize domain
+    std::vector<am_Domain_s> returnList;
+    am_Domain_s domain;
+    am_domainID_t domainID = 0;
+    pCF.createDomain(domain);
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
+        << "ERROR: database error";
+    ASSERT_NE(0,domainID)
+        << "ERROR: domainID zero";
+
+    //now check if we read out the correct values
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(returnList));
+    bool equal = true;
+    std::vector<am_Domain_s>::iterator listIterator = returnList.begin();
+    for (; listIterator < returnList.end(); ++listIterator)
+    {
+        if (listIterator->domainID == domainID)
+        {
+            equal = equal && (listIterator->name.compare(domain.name) == 0) && (listIterator->busname.compare(domain.busname) == 0) && (listIterator->complete == domain.complete) && (listIterator->early == domain.early) && (listIterator->state == domain.state);
+        }
+    }
+    ASSERT_EQ(true, equal);
+}
+
+TEST_F(CAmMapHandlerTest,registerConnectionCorrect)
+{
+    am_Connection_s connection;
+    am_connectionID_t connectionID;
+    std::vector<am_Connection_s> returnList;
+    pCF.createConnection(connection);
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection,connectionID))
+        << "ERROR: database error";;
+    ASSERT_NE(0,connectionID)
+        << "ERROR: connectionID zero";
+
+    //now check if we read out the correct values
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(returnList));
+    bool equal = false;
+    std::vector<am_Connection_s>::iterator listIterator = returnList.begin();
+    for (; listIterator < returnList.end(); ++listIterator)
+    {
+        if (listIterator->connectionID == connectionID)
+        {
+            equal = (listIterator->sourceID == connection.sourceID) && (listIterator->sinkID == connection.sinkID) && (listIterator->delay == connection.delay) && (listIterator->connectionFormat = connection.connectionFormat);
+        }
+    }
+    ASSERT_EQ(true, equal);
+}
+
+TEST_F(CAmMapHandlerTest,enterMainConnectionCorrect)
+{
+    createMainConnectionSetup();
+}
+
+TEST_F(CAmMapHandlerTest,enterSinksCorrect)
+{
+    //fill the connection database
+    am_Sink_s staticSink, firstDynamicSink, secondDynamicSink;
+    am_sinkID_t staticSinkID, firstDynamicSinkID, secondDynamicSinkID;
+    std::vector<am_Sink_s> sinkList;
+
+    pCF.createSink(staticSink);
+    staticSink.sinkID = 4;
+
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(staticSink.sinkID,staticSinkID)
+        << "ERROR: ID not the one given in staticSink";
+
+    pCF.createSink(firstDynamicSink);
+    firstDynamicSink.name = "firstdynamic";
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(firstDynamicSink,firstDynamicSinkID))
+        << "ERROR: database error";
+    ASSERT_EQ(firstDynamicSinkID,DYNAMIC_ID_BOUNDARY)
+        << "ERROR: ID not the one given in firstDynamicSink";
+
+    pCF.createSink(secondDynamicSink);
+    secondDynamicSink.name = "seconddynamic";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(secondDynamicSink,secondDynamicSinkID))
+        << "ERROR: database error";
+    ASSERT_NEAR(secondDynamicSinkID,DYNAMIC_ID_BOUNDARY,10)
+        << "ERROR: ID not the one given in secondDynamicSink";
+
+    //now read back and check the returns agains the given values
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(sinkList))
+        << "ERROR: database error";
+    bool equal = true;
+
+    std::vector<am_Sink_s>::iterator listIterator = sinkList.begin();
+    for (; listIterator < sinkList.end(); ++listIterator)
+    {
+        if (listIterator->sinkID == staticSinkID)
+        {
+            equal = equal && pCF.compareSink(listIterator, staticSink);
+        }
+
+        if (listIterator->sinkID == firstDynamicSinkID)
+        {
+            equal = equal && pCF.compareSink(listIterator, firstDynamicSink);
+        }
+
+        if (listIterator->sinkID == secondDynamicSinkID)
+        {
+            equal = equal && pCF.compareSink(listIterator, secondDynamicSink);
+        }
+    }
+    ASSERT_EQ(true, equal);
+}
+
+TEST_F(CAmMapHandlerTest,enterNotificationConfigurationCorrect)
+{
+    am_Sink_s testSinkData, readoutData;
+    pCF.createSink(testSinkData);
+    testSinkData.sinkID = 4;
+    am_sinkID_t sinkID;
+    std::vector<am_Sink_s> listSinks;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+    testSinkData.listNotificationConfigurations.push_back(notify);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
+        << "ERROR: database error";
+
+    ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].parameter,notify.parameter);
+    ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].status,notify.status);
+    ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].type,notify.type);
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.getSinkInfoDB(testSinkData.sinkID,readoutData))
+            << "ERROR: database error";
+
+    ASSERT_EQ(readoutData.listNotificationConfigurations[2].parameter,notify.parameter);
+    ASSERT_EQ(readoutData.listNotificationConfigurations[2].status,notify.status);
+    ASSERT_EQ(readoutData.listNotificationConfigurations[2].type,notify.type);
+
+}
+
+TEST_F(CAmMapHandlerTest,enterMainNotificationConfigurationCorrect)
+{
+    am_Sink_s testSinkData;
+    pCF.createSink(testSinkData);
+    testSinkData.sinkID = 4;
+    am_sinkID_t sinkID;
+    std::vector<am_Sink_s> listSinks;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+
+    testSinkData.listMainNotificationConfigurations.push_back(notify);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
+        << "ERROR: database error";
+
+    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
+    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].status,notify.status);
+    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].type,notify.type);
+}
+
+TEST_F(CAmMapHandlerTest,removeNotificationsSink)
+{
+    am_Sink_s testSinkData;
+    pCF.createSink(testSinkData);
+    testSinkData.sinkID = 4;
+    am_sinkID_t sinkID;
+    std::vector<am_Sink_s> listSinks;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+
+    testSinkData.listMainNotificationConfigurations.push_back(notify);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
+        << "ERROR: database error";
+
+    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
+    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].status,notify.status);
+    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].type,notify.type);
+
+    //now we remove the sink
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID));
+}
+
+TEST_F(CAmMapHandlerTest,removeNotificationsSource)
+{
+    am_Source_s testSourceData;
+    pCF.createSource(testSourceData);
+    testSourceData.sourceID = 4;
+    am_sourceID_t sourceID;
+    std::vector<am_Source_s> listSources;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+
+    testSourceData.listMainNotificationConfigurations.push_back(notify);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources))
+        << "ERROR: database error";
+
+    ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
+    ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].status,notify.status);
+    ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].type,notify.type);
+
+    //now we remove the sink
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID));
+}
+
+TEST_F(CAmMapHandlerTest,getMainNotificationsSink)
+{
+    am_Sink_s testSinkData;
+    pCF.createSink(testSinkData);
+    testSinkData.sinkID = 4;
+    am_sinkID_t sinkID;
+    std::vector<am_Sink_s> listSinks;
+    std::vector<am_NotificationConfiguration_s>returnList;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+
+    testSinkData.listMainNotificationConfigurations.push_back(notify);
+
+    am_NotificationConfiguration_s notify1;
+    notify1.type=NT_MAX;
+    notify1.status=NS_PERIODIC;
+    notify1.parameter=5;
+
+    testSinkData.listMainNotificationConfigurations.push_back(notify1);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList))
+        << "ERROR: database error";
+
+    std::equal(testSinkData.listMainNotificationConfigurations.begin(),testSinkData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);
+
+}
+
+TEST_F(CAmMapHandlerTest,getMainNotificationsSources)
+{
+    am_Source_s testSourceData;
+    pCF.createSource(testSourceData);
+    testSourceData.sourceID = 4;
+    am_sourceID_t sourceID;
+    std::vector<am_Source_s> listSources;
+    std::vector<am_NotificationConfiguration_s>returnList;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+
+    testSourceData.listMainNotificationConfigurations.push_back(notify);
+
+    am_NotificationConfiguration_s notify1;
+    notify1.type=NT_MAX;
+    notify1.status=NS_PERIODIC;
+    notify1.parameter=5;
+
+    testSourceData.listMainNotificationConfigurations.push_back(notify1);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList))
+        << "ERROR: database error";
+
+    std::equal(testSourceData.listMainNotificationConfigurations.begin(),testSourceData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);
+
+}
+
+TEST_F(CAmMapHandlerTest,changeMainNotificationsSources)
+{
+    am_Source_s testSourceData;
+    pCF.createSource(testSourceData);
+    testSourceData.sourceID = 4;
+    am_sourceID_t sourceID;
+    std::vector<am_Source_s> listSources;
+    std::vector<am_NotificationConfiguration_s>returnList,returnList1;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+
+    testSourceData.listMainNotificationConfigurations.push_back(notify);
+
+    am_NotificationConfiguration_s notify1;
+    notify1.type=NT_MAX;
+    notify1.status=NS_PERIODIC;
+    notify1.parameter=5;
+
+    am_NotificationConfiguration_s notify2;
+    notify2.type=NT_MAX;
+    notify2.status=NS_CHANGE;
+    notify2.parameter=10;
+
+    testSourceData.listMainNotificationConfigurations.push_back(notify1);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList))
+        << "ERROR: database error";
+
+    ASSERT_EQ(true, std::equal(testSourceData.listMainNotificationConfigurations.begin(),
+    				 testSourceData.listMainNotificationConfigurations.end(),
+    				 returnList.begin(),
+    				 equalNotificationConfiguration));
+
+    //change a setting
+    ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSourceNotificationConfigurationDB(sourceID,notify2));
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList1))
+        << "ERROR: database error";
+
+    ASSERT_EQ(returnList1[3].parameter,notify2.parameter);
+    ASSERT_EQ(returnList1[3].status,notify2.status);
+    ASSERT_EQ(returnList1[3].type,notify2.type);
+
+}
+
+TEST_F(CAmMapHandlerTest,changeMainNotificationsSink)
+{
+    am_Sink_s testSinkData;
+    pCF.createSink(testSinkData);
+    testSinkData.sinkID = 4;
+    am_sinkID_t sinkID;
+    std::vector<am_Sink_s> listSinks;
+    std::vector<am_NotificationConfiguration_s>returnList,returnList1;
+
+    am_NotificationConfiguration_s notify;
+    notify.type=NT_UNKNOWN;
+    notify.status=NS_CHANGE;
+    notify.parameter=25;
+
+    testSinkData.listMainNotificationConfigurations.push_back(notify);
+
+    am_NotificationConfiguration_s notify1;
+    notify1.type=NT_MAX;
+    notify1.status=NS_PERIODIC;
+    notify1.parameter=5;
+
+    am_NotificationConfiguration_s notify2;
+    notify2.type=NT_MAX;
+    notify2.status=NS_CHANGE;
+    notify2.parameter=27;
+
+    testSinkData.listMainNotificationConfigurations.push_back(notify1);
+
+    //enter the sink in the database
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
+        << "ERROR: database error";
+
+    //read it again
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList))
+        << "ERROR: database error";
+
+    std::equal(testSinkData.listMainNotificationConfigurations.begin(),testSinkData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify2))
+        << "ERROR: database error";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList1))
+        << "ERROR: database error";
+
+    ASSERT_EQ(returnList1[3].parameter,notify2.parameter);
+    ASSERT_EQ(returnList1[3].status,notify2.status);
+    ASSERT_EQ(returnList1[3].type,notify2.type);
+}
+
+TEST_F(CAmMapHandlerTest, peekDomain_2)
+{
+    std::vector<am_Domain_s> listDomains;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+    am_domainID_t domain2ID;
+    pCF.createDomain(domain);
+    ASSERT_EQ(E_OK,pDatabaseHandler.peekDomain(std::string("newdomain"),domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
+    ASSERT_TRUE(listDomains.empty());
+    ASSERT_EQ(domainID, 1);
+
+    domain.name = "anotherdomain";
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
+    ASSERT_EQ(domain2ID, 2);
+
+    domain.name = "newdomain";
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
+    ASSERT_EQ(domainID, domain2ID);               // FAILS, ID is 2 instead of 1
+    ASSERT_TRUE(listDomains[0].domainID==domainID);
+}
+
+//Commented out - gives always a warning..
+//TEST_F(databaseTest,registerDomainFailonID0)
+//{
+//	am_Domain_s domain;
+//	am_domainID_t domainID=5;
+//	pCF.createDomain(domain);
+//	domain.domainID=1;
+//	ASSERT_DEATH(pDatabaseHandler.enterDomainDB(domain,domainID),"Assertion `domainData.domainID==0'");
+//}
+
+int main(int argc, char **argv)
+{
+    CAmDltWrapper::instance()->registerApp("databse", "databasetest");
+    logInfo("Database Test started ");
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.h b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.h
new file mode 100644
index 0000000..9720731
--- /dev/null
+++ b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.h
@@ -0,0 +1,73 @@
+/**
+ * Copyright (C) 2012, BMW AG
+ *
+ * This file is part of GENIVI Project AudioManager.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
+ *
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#ifndef MAPHANDLERTEST_H_
+#define MAPHANDLERTEST_H_
+
+#define UNIT_TEST 1
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "CAmMapHandler.h"
+#include "CAmControlReceiver.h"
+#include "CAmControlSender.h"
+#include "CAmDatabaseObserver.h"
+#include "CAmRoutingSender.h"
+#include "CAmRouter.h"
+#include "CAmControlSender.h"
+#include "../IAmControlBackdoor.h"
+#include "../IAmCommandBackdoor.h"
+#include "../CAmCommonFunctions.h"
+#include "../MockIAmControlSend.h"
+#include "../MockIAmCommandSend.h"
+#include "shared/CAmSocketHandler.h"
+
+namespace am
+{
+
+class CAmMapHandlerTest: public ::testing::Test
+{
+public:
+	CAmMapHandlerTest();
+    ~CAmMapHandlerTest();
+    std::vector<std::string> plistRoutingPluginDirs;
+    std::vector<std::string> plistCommandPluginDirs;
+    CAmSocketHandler pSocketHandler;
+    CAmMapHandler pDatabaseHandler;
+    CAmRoutingSender pRoutingSender;
+    CAmCommandSender pCommandSender;
+    MockIAmCommandSend pMockInterface;
+    IAmRoutingBackdoor pRoutingInterfaceBackdoor;
+    IAmCommandBackdoor pCommandInterfaceBackdoor;
+    CAmControlSender pControlSender;
+    CAmRouter pRouter;
+    CAmControlReceiver pControlReceiver;
+    CAmDatabaseObserver pObserver;
+    CAmCommonFunctions pCF;
+    void SetUp();
+    void TearDown();
+
+    void createMainConnectionSetup();
+};
+
+}
+
+#endif /* MAPHANDLERTEST_H_ */
diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CMakeLists.txt b/AudioManagerDaemon/test/AmMapHandlerTest/CMakeLists.txt
new file mode 100644
index 0000000..aa00640
--- /dev/null
+++ b/AudioManagerDaemon/test/AmMapHandlerTest/CMakeLists.txt
@@ -0,0 +1,92 @@
+# Copyright (C) 2012, BMW AG
+#
+# This file is part of GENIVI Project AudioManager.
+# 
+# Contributions are licensed to the GENIVI Alliance under one or more
+# Contribution License Agreements.
+# 
+# copyright
+# This Source Code Form is subject to the terms of the
+# Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+# this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# 
+# author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
+#
+# For further information see http://www.genivi.org/.
+#
+
+cmake_minimum_required(VERSION 2.6)
+
+PROJECT(AmMapHandlerTest)
+
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -DUNIT_TEST=1 -DDLT_CONTEXT=AudioManager")
+
+
+FIND_PACKAGE(PkgConfig)
+#pkg_check_modules(SQLITE REQUIRED sqlite3)
+
+IF(WITH_DLT)    
+    pkg_check_modules(DLT REQUIRED automotive-dlt>=2.2.0)   
+ENDIF(WITH_DLT)
+
+INCLUDE_DIRECTORIES(   
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${AUDIO_INCLUDE_FOLDER}
+    ${DBUS_ARCH_INCLUDE_DIR}
+    ${DBUS_INCLUDE_FOLDER} 
+    ${CMAKE_SOURCE_DIR} 
+    ${STD_INCLUDE_DIRS}
+    ${DLT_INCLUDE_DIRS}
+    ${DBUS_INCLUDE_DIR}
+    ${INCLUDE_FOLDER}
+    ${GOOGLE_TEST_INCLUDE_DIR}
+    ${GMOCK_INCLUDE_DIR}
+)
+
+file(GLOB DATABASE_SRCS_CXX 
+    "../../src/CAmMapHandler.cpp"
+    "../../src/CAmDatabaseHandler.cpp"
+    "../../src/CAmDatabaseObserver.cpp"
+    "../../src/CAmCommandSender.cpp"
+    "../../src/CAmRoutingSender.cpp"
+    "../../src/CAmControlReceiver.cpp"
+    "../../src/CAmControlSender.cpp"
+    "../../src/CAmRouter.cpp"
+    "../../src/CAmDltWrapper.cpp"
+    "../../src/CAmSocketHandler.cpp"
+    "../../src/CAmCommandReceiver.cpp"
+    "../../src/CAmRoutingReceiver.cpp"
+    "../../src/CAmDbusWrapper.cpp"
+    "../CAmCommonFunctions.cpp" 
+    "*.cpp"
+    )
+    
+IF(WITH_NSM)
+    SET (DATABASE_SRCS_CXX
+        ${DATABASE_SRCS_CXX}
+    "../../src/CAmNodeStateCommunicator.cpp")
+ENDIF(WITH_NSM)
+
+ADD_EXECUTABLE( AmMapHandlerTest ${DATABASE_SRCS_CXX})
+
+TARGET_LINK_LIBRARIES( AmMapHandlerTest 
+	${SQLITE_LIBRARIES}
+	${DLT_LIBRARIES}
+	${DBUS_LIBRARY}
+	${CMAKE_THREAD_LIBS_INIT}
+	${CMAKE_DL_LIBS}
+    gtest
+    gmock
+)
+
+ADD_DEPENDENCIES(AmMapHandlerTest gtest gmock)
+
+INSTALL(TARGETS AmMapHandlerTest 
+        DESTINATION "~/AudioManagerTest/"
+        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
+        COMPONENT tests
+)
+
+SET(ADD_DEPEND "audiomanager-bin" "dlt" "libdbus-1-3(>=1.2.16)"  "libpthread-stubs0")
+set_property(GLOBAL APPEND PROPERTY tests_prop "${ADD_DEPEND}")
+
diff --git a/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.cpp b/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.cpp
index 3de815d..dd06384 100644
--- a/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.cpp
+++ b/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.cpp
@@ -12,7 +12,7 @@
  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  *
  *
- * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
+ * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
  *
  * For further information see http://www.genivi.org/.
  *
@@ -29,8 +29,12 @@ CAmRouterTest::CAmRouterTest() :
         plistRoutingPluginDirs(), //
         plistCommandPluginDirs(), //
         pSocketHandler(), //
-        pDatabaseHandler(std::string(":memory:")), //
         pControlSender(), //
+#ifdef WITH_DATABASE_STORAGE
+		pDatabaseHandler(std::string(":memory:")),
+#else
+		pDatabaseHandler(),
+#endif
         pRouter(&pDatabaseHandler, &pControlSender), //
         pRoutingSender(plistRoutingPluginDirs), //
         pCommandSender(plistCommandPluginDirs), //
@@ -49,11 +53,17 @@ CAmRouterTest::CAmRouterTest() :
 
 CAmRouterTest::~CAmRouterTest()
 {
+
 }
 
 void CAmRouterTest::SetUp()
 {
     logInfo("Routing Test started ");
+#ifdef WITH_DATABASE_STORAGE
+    printf("\n  WITH_DATABASE_STORAGE = 1 \n");
+#else
+    printf("\n  WITH_DATABASE_STORAGE = 0 \n");
+#endif
 }
 
 void CAmRouterTest::TearDown()
diff --git a/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.h b/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.h
index ea7cd92..951eed5 100644
--- a/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.h
+++ b/AudioManagerDaemon/test/AmRouterTest/CAmRouterTest.h
@@ -12,7 +12,7 @@
  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  *
  *
- * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
+* \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
  *
  * For further information see http://www.genivi.org/.
  *
@@ -30,7 +30,11 @@
 #include <string>
 #include <vector>
 #include <set>
-#include "CAmDatabaseHandler.h"
+#ifdef WITH_DATABASE_STORAGE
+   #include "CAmDatabaseHandler.h"
+#else
+    #include "CAmMapHandler.h"
+#endif
 #include "CAmControlReceiver.h"
 #include "CAmControlSender.h"
 #include "CAmDatabaseObserver.h"
@@ -43,6 +47,7 @@
 #include "../MockIAmControlSend.h"
 #include "../MockIAmCommandSend.h"
 
+
 namespace am
 {
 
@@ -54,8 +59,12 @@ public:
     std::vector<std::string> plistRoutingPluginDirs;
     std::vector<std::string> plistCommandPluginDirs;
     CAmSocketHandler pSocketHandler;
-    CAmDatabaseHandler pDatabaseHandler;
     CAmControlSender pControlSender;
+#ifdef WITH_DATABASE_STORAGE
+    CAmDatabaseHandler pDatabaseHandler;
+#else
+    CAmMapHandler pDatabaseHandler;
+#endif
     CAmRouter pRouter;
     CAmRoutingSender pRoutingSender;
     CAmCommandSender pCommandSender;
diff --git a/AudioManagerDaemon/test/AmRouterTest/CMakeLists.txt b/AudioManagerDaemon/test/AmRouterTest/CMakeLists.txt
index d820118..bff2205 100644
--- a/AudioManagerDaemon/test/AmRouterTest/CMakeLists.txt
+++ b/AudioManagerDaemon/test/AmRouterTest/CMakeLists.txt
@@ -44,6 +44,7 @@ INCLUDE_DIRECTORIES(
 )
 
 file(GLOB ROUTING_SRCS_CXX 
+    "../../src/CAmMapHandler.cpp"
     "../../src/CAmDatabaseHandler.cpp"
     "../../src/CAmDatabaseObserver.cpp"
     "../../src/CAmCommandSender.cpp"
diff --git a/AudioManagerDaemon/test/CAmCommonFunctions.cpp b/AudioManagerDaemon/test/CAmCommonFunctions.cpp
index 8c5821d..7ee9090 100644
--- a/AudioManagerDaemon/test/CAmCommonFunctions.cpp
+++ b/AudioManagerDaemon/test/CAmCommonFunctions.cpp
@@ -133,8 +133,17 @@ std::string int2string(int i)
 
 bool CAmCommonFunctions::compareSource(std::vector<am_Source_s>::iterator listIterator, const am_Source_s& sourceData)
 {
-    return (listIterator->available.availability == sourceData.available.availability) && (listIterator->available.availabilityReason == sourceData.available.availabilityReason) && (listIterator->sourceClassID == sourceData.sourceClassID) && (listIterator->domainID == sourceData.domainID) && (listIterator->interruptState == sourceData.interruptState) && (listIterator->visible == sourceData.visible) && (listIterator->name.compare(sourceData.name) == 0) && (listIterator->volume == sourceData.volume) && std::equal(listIterator->listConnectionFormats.begin(), listIterator->listConnectionFormats.end(), sourceData.listConnectionFormats.begin())
-            && std::equal(listIterator->listMainSoundProperties.begin(), listIterator->listMainSoundProperties.end(), sourceData.listMainSoundProperties.begin(), equalMainSoundProperty) && std::equal(listIterator->listSoundProperties.begin(), listIterator->listSoundProperties.end(), sourceData.listSoundProperties.begin(), equalSoundProperty);
+    return (listIterator->available.availability == sourceData.available.availability) && \
+    		(listIterator->available.availabilityReason == sourceData.available.availabilityReason) &&
+    		(listIterator->sourceClassID == sourceData.sourceClassID) &&
+    		(listIterator->domainID == sourceData.domainID) &&
+    		(listIterator->interruptState == sourceData.interruptState) &&
+    		(listIterator->visible == sourceData.visible) &&
+    		(listIterator->name.compare(sourceData.name) == 0) &&
+    		(listIterator->volume == sourceData.volume) &&
+    		std::equal(listIterator->listConnectionFormats.begin(), listIterator->listConnectionFormats.end(), sourceData.listConnectionFormats.begin()) &&
+            std::equal(listIterator->listMainSoundProperties.begin(), listIterator->listMainSoundProperties.end(), sourceData.listMainSoundProperties.begin(), equalMainSoundProperty) &&
+            std::equal(listIterator->listSoundProperties.begin(), listIterator->listSoundProperties.end(), sourceData.listSoundProperties.begin(), equalSoundProperty);
 }
 
 bool CAmCommonFunctions::compareSink(std::vector<am_Sink_s>::iterator listIterator, const am_Sink_s& sinkData)
diff --git a/AudioManagerDaemon/test/CMakeLists.txt b/AudioManagerDaemon/test/CMakeLists.txt
index c897645..7cd134b 100644
--- a/AudioManagerDaemon/test/CMakeLists.txt
+++ b/AudioManagerDaemon/test/CMakeLists.txt
@@ -22,6 +22,7 @@ set(EXECUTABLE_OUTPUT_PATH ${TEST_EXECUTABLE_OUTPUT_PATH})
 
 add_subdirectory (AmControlInterfaceTest)
 add_subdirectory (AmDatabaseHandlerTest)
+add_subdirectory (AmMapHandlerTest)
 add_subdirectory (AmRouterTest)
 add_subdirectory (AmRoutingInterfaceTest)
 add_subdirectory (AmSocketHandlerTest)