AudioManagerDaemon/test/CommonFunctions.cpp

   1 /*
   2  * CommonFunctions.cpp
   3  *
   4  *  Created on: Dec 10, 2011
   5  *      Author: christian
   6  */
   7
   8 #include "CommonFunctions.h"
   9 #include "CommandInterfaceBackdoor.h"
  10 #include "RoutingInterfaceBackdoor.h"
  11 #include "ControlInterfaceBackdoor.h"
  12
  13 CommandInterfaceBackdoor::CommandInterfaceBackdoor() {
  14 }
  15 CommandInterfaceBackdoor::~CommandInterfaceBackdoor() {
  16 }
  17
  18 bool CommandInterfaceBackdoor::unloadPlugins(CommandSender *CommandSender) {
  19         assert(CommandSender != NULL);
  20         CommandSender->unloadLibraries();
  21         CommandSender->mListInterfaces.clear();
  22         if (CommandSender->mListInterfaces.empty())
  23                 return true;
  24         return false;
  25 }
  26
  27 bool CommandInterfaceBackdoor::injectInterface(CommandSender *CommandSender,
  28                 CommandSendInterface *CommandSendInterface) {
  29         assert(CommandSender != NULL);
  30         assert(CommandSendInterface != NULL);
  31         CommandSender->mListInterfaces.push_back(CommandSendInterface);
  32         return true; //todo: check if it worked
  33 }
  34
  35 RoutingInterfaceBackdoor::RoutingInterfaceBackdoor() {
  36 }
  37 RoutingInterfaceBackdoor::~RoutingInterfaceBackdoor() {
  38 }
  39
  40 bool RoutingInterfaceBackdoor::unloadPlugins(RoutingSender *RoutingSender) {
  41         assert(RoutingSender != NULL);
  42         RoutingSender->unloadLibraries();
  43         RoutingSender->mListInterfaces.clear();
  44         if (RoutingSender->mListInterfaces.empty())
  45                 return true;
  46         return false;
  47 }
  48
  49 bool RoutingInterfaceBackdoor::injectInterface(RoutingSender *RoutingSender,
  50         RoutingSendInterface *newInterface, const std::string& busname) {
  51         assert(RoutingSender != NULL);
  52         assert(newInterface != NULL);
  53
  54         RoutingSender::InterfaceNamePairs newInterfacePair;
  55         newInterfacePair.routingInterface = newInterface;
  56         newInterfacePair.busName = busname;
  57         RoutingSender->mListInterfaces.push_back(newInterfacePair);
  58         return true; //todo: check if it worked
  59 }
  60
  61 ControlInterfaceBackdoor::ControlInterfaceBackdoor() {}
  62
  63 ControlInterfaceBackdoor::~ControlInterfaceBackdoor() {}
  64
  65 bool ControlInterfaceBackdoor::replaceController(ControlSender *controlSender, ControlSendInterface *newController)
  66 {
  67         controlSender->mController=newController;
  68         return true;
  69 }
  70
  71
  72 int GetRandomNumber(int nLow, int nHigh) {
  73         return (rand() % (nHigh - nLow + 1)) + nLow;
  74 }
  75
  76 bool equalSoundProperty(const am_SoundProperty_s a,
  77                 const am_SoundProperty_s b) {
  78         return (a.type == b.type && a.value == b.value);
  79 }
  80
  81 bool equalMainSoundProperty(const am_MainSoundProperty_s a,
  82                 const am_MainSoundProperty_s b) {
  83         return (a.type == b.type && a.value == b.value);
  84 }
  85
  86 bool equalRoutingElement(const am_RoutingElement_s a,
  87                 const am_RoutingElement_s b) {
  88         return (a.connectionFormat == b.connectionFormat && a.domainID == b.domainID
  89                         && a.sinkID == b.sinkID && a.sourceID == b.sourceID);
  90 }
  91
  92 bool equalClassProperties(const am_ClassProperty_s a,
  93                 const am_ClassProperty_s b) {
  94         return (a.classProperty == b.classProperty && a.value == b.value);
  95 }
  96
  97 std::string int2string(int i) {
  98         std::stringstream out;
  99         out << i;
 100         return out.str();
 101 }
 102
 103 bool CommonFunctions::compareSource(
 104                 std::vector<am_Source_s>::iterator listIterator,
 105                 const am_Source_s& sourceData) {
 106         return (listIterator->available.availability
 107                         == sourceData.available.availability)
 108                         && (listIterator->available.availabilityReason
 109                                         == sourceData.available.availabilityReason)
 110                         && (listIterator->sourceClassID == sourceData.sourceClassID)
 111                         && (listIterator->domainID == sourceData.domainID)
 112                         && (listIterator->interruptState == sourceData.interruptState)
 113                         && (listIterator->visible == sourceData.visible)
 114                         && (listIterator->name.compare(sourceData.name) == 0)
 115                         && (listIterator->volume == sourceData.volume)
 116                         && std::equal(listIterator->listConnectionFormats.begin(),
 117                                         listIterator->listConnectionFormats.end(),
 118                                         sourceData.listConnectionFormats.begin())
 119                         && std::equal(listIterator->listMainSoundProperties.begin(),
 120                                         listIterator->listMainSoundProperties.end(),
 121                                         sourceData.listMainSoundProperties.begin(),
 122                                         equalMainSoundProperty)
 123                         && std::equal(listIterator->listSoundProperties.begin(),
 124                                         listIterator->listSoundProperties.end(),
 125                                         sourceData.listSoundProperties.begin(), equalSoundProperty);
 126 }
 127
 128 bool CommonFunctions::compareSink(std::vector<am_Sink_s>::iterator listIterator,
 129                 const am_Sink_s& sinkData) {
 130         return (listIterator->available.availability
 131                         == sinkData.available.availability)
 132                         && (listIterator->available.availabilityReason
 133                                         == sinkData.available.availabilityReason)
 134                         && (listIterator->sinkClassID == sinkData.sinkClassID)
 135                         && (listIterator->domainID == sinkData.domainID)
 136                         && (listIterator->mainVolume == sinkData.mainVolume)
 137                         && (listIterator->muteState == sinkData.muteState)
 138                         && (listIterator->visible == sinkData.visible)
 139                         && (listIterator->name.compare(sinkData.name) == 0)
 140                         && (listIterator->volume == sinkData.volume)
 141                         && std::equal(listIterator->listConnectionFormats.begin(),
 142                                         listIterator->listConnectionFormats.end(),
 143                                         sinkData.listConnectionFormats.begin())
 144                         && std::equal(listIterator->listMainSoundProperties.begin(),
 145                                         listIterator->listMainSoundProperties.end(),
 146                                         sinkData.listMainSoundProperties.begin(),
 147                                         equalMainSoundProperty)
 148                         && std::equal(listIterator->listSoundProperties.begin(),
 149                                         listIterator->listSoundProperties.end(),
 150                                         sinkData.listSoundProperties.begin(), equalSoundProperty);
 151 }
 152
 153 bool CommonFunctions::compareGateway(
 154                 std::vector<am_Gateway_s>::iterator listIterator,
 155                 const am_Gateway_s& gatewayData) {
 156         return (listIterator->name.compare(gatewayData.name) == 0)
 157                         && (listIterator->sinkID == gatewayData.sinkID)
 158                         && (listIterator->sourceID == gatewayData.sourceID)
 159                         && (listIterator->controlDomainID == gatewayData.controlDomainID)
 160                         && (listIterator->domainSinkID == gatewayData.domainSinkID)
 161                         && (listIterator->domainSourceID == gatewayData.domainSourceID)
 162                         && std::equal(listIterator->convertionMatrix.begin(),
 163                                         listIterator->convertionMatrix.end(),
 164                                         gatewayData.convertionMatrix.begin())
 165                         && std::equal(listIterator->listSourceFormats.begin(),
 166                                         listIterator->listSourceFormats.end(),
 167                                         gatewayData.listSourceFormats.begin())
 168                         && std::equal(listIterator->listSinkFormats.begin(),
 169                                         listIterator->listSinkFormats.end(),
 170                                         gatewayData.listSinkFormats.begin());
 171 }
 172
 173 bool CommonFunctions::compareGateway1(const am_Gateway_s gateway1,
 174                 const am_Gateway_s gatewayData) {
 175         return (gateway1.name.compare(gatewayData.name) == 0)
 176                         && (gateway1.sinkID == gatewayData.sinkID)
 177                         && (gateway1.sourceID == gatewayData.sourceID)
 178                         && (gateway1.controlDomainID == gatewayData.controlDomainID)
 179                         && (gateway1.domainSinkID == gatewayData.domainSinkID)
 180                         && (gateway1.domainSourceID == gatewayData.domainSourceID)
 181                         && std::equal(gateway1.convertionMatrix.begin(),
 182                                         gateway1.convertionMatrix.end(),
 183                                         gatewayData.convertionMatrix.begin())
 184                         && std::equal(gateway1.listSourceFormats.begin(),
 185                                         gateway1.listSourceFormats.end(),
 186                                         gatewayData.listSourceFormats.begin())
 187                         && std::equal(gateway1.listSinkFormats.begin(),
 188                                         gateway1.listSinkFormats.end(),
 189                                         gatewayData.listSinkFormats.begin());
 190 }
 191
 192 bool CommonFunctions::compareSinkMainSink(
 193                 std::vector<am_SinkType_s>::iterator listIterator,
 194                 const std::vector<am_Sink_s>& sinkList) {
 195         std::vector<am_Sink_s>::const_iterator sinkListIterator = sinkList.begin();
 196         for (; sinkListIterator < sinkList.end(); ++sinkListIterator) {
 197                 if (listIterator->sinkID == sinkListIterator->sinkID) {
 198                         return (listIterator->name.compare(sinkListIterator->name) == 0)
 199                                         && (listIterator->availability.availability
 200                                                         == sinkListIterator->available.availability)
 201                                         && (listIterator->availability.availabilityReason
 202                                                         == sinkListIterator->available.availabilityReason)
 203                                         && (listIterator->muteState == sinkListIterator->muteState)
 204                                         && (listIterator->volume == sinkListIterator->mainVolume)
 205                                         && (listIterator->sinkClassID
 206                                                         == sinkListIterator->sinkClassID);
 207                 }
 208         }
 209         return false;
 210 }
 211
 212 bool CommonFunctions::compareSinkMainSource(
 213                 std::vector<am_SourceType_s>::iterator listIterator,
 214                 const std::vector<am_Source_s>& sourceList) {
 215         std::vector<am_Source_s>::const_iterator sinkListIterator =
 216                         sourceList.begin();
 217         for (; sinkListIterator < sourceList.end(); ++sinkListIterator) {
 218                 if (listIterator->sourceID == sinkListIterator->sourceID) {
 219                         return (listIterator->name.compare(sinkListIterator->name) == 0)
 220                                         && (listIterator->availability.availability
 221                                                         == sinkListIterator->available.availability)
 222                                         && (listIterator->availability.availabilityReason
 223                                                         == sinkListIterator->available.availabilityReason)
 224                                         && (listIterator->sourceClassID
 225                                                         == sinkListIterator->sourceClassID);
 226                 }
 227         }
 228         return false;
 229 }
 230
 231 std::vector<am_ConnectionFormat_e> CommonFunctions::getStandardConnectionFormatList() {
 232         std::vector < am_ConnectionFormat_e > list;
 233         list.push_back(CF_ANALOG);
 234         list.push_back(CF_STEREO);
 235         return list;
 236 }
 237
 238 std::vector<am_SoundProperty_s> CommonFunctions::getStandardSoundPropertyList() {
 239         std::vector < am_SoundProperty_s > soundPropertyList;
 240         am_SoundProperty_s soundProperty;
 241         soundProperty.type = SP_BASS;
 242         soundProperty.value = 23;
 243         soundPropertyList.push_back(soundProperty);
 244         soundProperty.type = SP_MID;
 245         soundProperty.value = 2;
 246         soundPropertyList.push_back(soundProperty);
 247         return soundPropertyList;
 248 }
 249
 250 std::vector<am_MainSoundProperty_s> CommonFunctions::getStandardMainSoundPropertyList() {
 251         std::vector < am_MainSoundProperty_s > mainSoundPropertyList;
 252         am_MainSoundProperty_s mainSoundProperty;
 253         mainSoundProperty.type = MSP_NAVIGATION_OFFSET;
 254         mainSoundProperty.value = 23;
 255         mainSoundPropertyList.push_back(mainSoundProperty);
 256         mainSoundProperty.type = MSP_TEST;
 257         mainSoundProperty.value = 3;
 258         mainSoundPropertyList.push_back(mainSoundProperty);
 259         return mainSoundPropertyList;
 260 }
 261
 262 void CommonFunctions::createSink(am_Sink_s& sink) const {
 263         sink.name = "AnySink";
 264         sink.domainID = 4;
 265         sink.available.availability = A_AVAILABLE;
 266         sink.available.availabilityReason = AR_NEWMEDIA;
 267         sink.sinkClassID = 1;
 268         sink.listConnectionFormats = getStandardConnectionFormatList();
 269         sink.listSoundProperties = getStandardSoundPropertyList();
 270         sink.listMainSoundProperties = getStandardMainSoundPropertyList();
 271         sink.mainVolume = 12;
 272         sink.muteState = MS_UNMUTED;
 273         sink.visible = true;
 274         sink.volume = 23;
 275         sink.sinkID = 0;
 276 }
 277
 278 void CommonFunctions::createSource(am_Source_s& source) const {
 279         source.name = "AnySource";
 280         source.domainID = 4;
 281         source.available.availability = A_AVAILABLE;
 282         source.available.availabilityReason = AR_NEWMEDIA;
 283         source.sourceClassID = 1;
 284         source.listConnectionFormats = getStandardConnectionFormatList();
 285         source.listSoundProperties = getStandardSoundPropertyList();
 286         source.listMainSoundProperties = getStandardMainSoundPropertyList();
 287         source.interruptState = IS_OFF;
 288         source.visible = true;
 289         source.volume = 23;
 290         source.sourceID = 0;
 291         source.sourceState = SS_ON;
 292 }
 293
 294 void CommonFunctions::createDomain(am_Domain_s & domain) const {
 295
 296         domain.domainID = 0;
 297         domain.name = "AnyDomain";
 298         domain.nodename = "AnyNode";
 299         domain.busname = "AnyBusname";
 300         domain.complete = true;
 301         domain.early = true;
 302         domain.state = DS_CONTROLLED;
 303 }
 304
 305 void CommonFunctions::createGateway(am_Gateway_s & gateway) {
 306         gateway.name = "AnyGateway";
 307         gateway.sinkID = 1;
 308         gateway.sourceID = 2;
 309         gateway.controlDomainID = 1;
 310         gateway.domainSinkID = 3;
 311         gateway.domainSourceID = 4;
 312         gateway.convertionMatrix = getStandardConvertionMatrix();
 313         gateway.listSourceFormats = getStandardConnectionFormatList();
 314         gateway.listSinkFormats = getStandardConnectionFormatList();
 315         gateway.gatewayID = 0;
 316
 317 }
 318
 319 void CommonFunctions::createConnection(am_Connection_s & connection) const {
 320         connection.connectionID = 0;
 321         connection.sinkID = 1;
 322         connection.sourceID = 2;
 323         connection.delay = -1;
 324         connection.connectionFormat = CF_ANALOG;
 325 }
 326
 327 void CommonFunctions::createMainConnection(am_MainConnection_s & mainConnection,
 328                 am_Route_s route) const {
 329         mainConnection.connectionID = 0;
 330         mainConnection.connectionState = CS_CONNECTED;
 331         mainConnection.route = route;
 332         mainConnection.delay = -1;
 333 }
 334
 335 std::vector<bool> CommonFunctions::getStandardConvertionMatrix() {
 336         std::vector<bool> convMatrix;
 337         convMatrix.push_back(true);
 338         convMatrix.push_back(false);
 339         convMatrix.push_back(true);
 340         convMatrix.push_back(false);
 341         convMatrix.push_back(true);
 342         convMatrix.push_back(true);
 343         return convMatrix;
 344 }
 345
 346 void CommonFunctions::connectionList2RoutingList(
 347                 std::vector<am_RoutingElement_s> & routingList,
 348                 const std::vector<am_Connection_s>& connectionList) {
 349         am_RoutingElement_s routingElement;
 350         std::vector<am_Connection_s>::const_iterator cIterator =
 351                         connectionList.begin();
 352         for (; cIterator < connectionList.end(); ++cIterator) {
 353                 routingElement.sinkID = cIterator->sinkID;
 354                 routingElement.sourceID = cIterator->sourceID;
 355                 routingElement.connectionFormat = cIterator->connectionFormat;
 356                 routingElement.domainID = 4; //todo: make this test read out the real value
 357                 routingList.push_back(routingElement);
 358         }
 359 }
 360
 361
 362
 363
 364
 365
 366
 367
 368