LayerManagerPlugins/Communicators/DBUSCommunicator/test/DBUSCommunicatorTest.cpp

   1 /***************************************************************************
   2  *
   3  * Copyright 2010,2011 BMW Car IT GmbH
   4  *
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  ****************************************************************************/
  19
  20 #ifndef DBUSDBUSCommunicatorTest_H_
  21 #define DBUSDBUSCommunicatorTest_H_
  22
  23 #include <gtest/gtest.h>
  24 #include <gmock/gmock.h>
  25 #include "ICommunicator.h"
  26 #include "DBUSCommunicator.h"
  27 #include "mock_CommandExecutor.h"
  28 #include "mock_Layerlist.h"
  29 //#include "FieldMatcher.h"
  30 #include <vector>
  31 #include <pthread.h>
  32
  33 using ::testing::Field;
  34 using ::testing::Property;
  35 using ::testing::Matcher;
  36 using ::testing::Pointee;
  37 using ::testing::AllOf;
  38 using ::testing::SafeMatcherCast;
  39 using ::testing::MatcherCast;
  40 using ::testing::DefaultValue;
  41 using ::testing::Eq;
  42 using ::testing::An;
  43 using ::testing::ElementsAreArray;
  44 using ::testing::ElementsAre;
  45 using ::testing::NotNull;
  46
  47 std::string DBUSCOMMAND_SYSTEM =
  48         "dbus-send --system --type=method_call --print-reply --dest=org.genivi.layermanagementservice /org/genivi/layermanagementservice org.genivi.layermanagementservice.";
  49 std::string DBUSCOMMAND_SESSION =
  50         "dbus-send --type=method_call --print-reply --dest=org.genivi.layermanagementservice /org/genivi/layermanagementservice org.genivi.layermanagementservice.";
  51 std::string DBUSCOMMAND = DBUSCOMMAND_SYSTEM;
  52
  53 class DBUSCommunicatorTest: public ::testing::Test {
  54 public:
  55     pthread_t processThread;
  56     bool running;
  57     ICommunicator* communicatorUnderTest;
  58     MockCommandExecutor mockCommandExecutor;
  59     MockLayerList layerlist;
  60
  61     DBUSCommunicatorTest() {
  62     }
  63
  64     virtual ~DBUSCommunicatorTest() {
  65     }
  66
  67     static void *processLoop(void * ptr) {
  68         while (((DBUSCommunicatorTest*) ptr)->running) {
  69             ((DBUSCommunicatorTest*) ptr)->communicatorUnderTest->process(100);
  70         }
  71         return NULL;
  72     }
  73
  74     void SetUp() {
  75         char* useSessionBus = getenv("LM_USE_SESSION_BUS");
  76         if (NULL != useSessionBus && strcmp(useSessionBus, "enable") == 0) {
  77             DBUSCOMMAND = DBUSCOMMAND_SESSION;
  78         } else {
  79             DBUSCOMMAND = DBUSCOMMAND_SYSTEM;
  80         }
  81         communicatorUnderTest = new DBUSCommunicator(&mockCommandExecutor);
  82         this->communicatorUnderTest->start();
  83         running = true;
  84         pthread_create(&processThread, NULL, processLoop, (void*) this);
  85     }
  86
  87     void TearDown() {
  88         running = false;
  89         this->communicatorUnderTest->stop();
  90         pthread_join(processThread, NULL);
  91         if (communicatorUnderTest) {
  92             delete communicatorUnderTest;
  93         }
  94     }
  95 };
  96
  97 MATCHER_P(DebugCommandEq, onoff, "DebugCommand has onoff set to %(onoff)s") {
  98     return ((DebugCommand*)arg)->m_onoff == onoff;
  99 }
 100
 101 TEST_F(DBUSCommunicatorTest, TurnDebugOnAndOff) {
 102     EXPECT_CALL(this->mockCommandExecutor, execute(DebugCommandEq(false) ) ).Times(1);
 103     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("Debug boolean:false")).c_str()));
 104     EXPECT_CALL(this->mockCommandExecutor, execute(DebugCommandEq(true) ) ).Times(1);
 105     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("Debug boolean:true")).c_str()));
 106     EXPECT_CALL(this->mockCommandExecutor, execute(DebugCommandEq(false) ) ).Times(1);
 107     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("Debug boolean:false")).c_str()));
 108 }
 109
 110 TEST_F(DBUSCommunicatorTest, ListAllLayerIDS) {
 111     DefaultValue<Scene*>::Set((Scene*) &this->layerlist);
 112     EXPECT_CALL(this->layerlist, getLayerIDs(NotNull(),NotNull() )).Times(1);
 113     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("ListAllLayerIDS")).c_str()));
 114 }
 115
 116 TEST_F(DBUSCommunicatorTest, listAlllayerGroupIDS) {
 117     std::list<int> defaultlist;
 118     DefaultValue<Scene*>::Set((Scene*) &this->layerlist);
 119     DefaultValue<std::list<int> >::Set(defaultlist);
 120     EXPECT_CALL(this->layerlist, getLayerGroupIDs(NotNull(),NotNull()) ).Times(1);
 121     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("ListAllLayerGroupIDS")).c_str()));
 122 }
 123
 124 TEST_F(DBUSCommunicatorTest, listAllSurfaceGroupIDS) {
 125     std::list<int> defaultlist;
 126     DefaultValue<Scene*>::Set((Scene*) &this->layerlist);
 127     DefaultValue<std::list<int> >::Set(defaultlist);
 128     EXPECT_CALL(this->layerlist, getSurfaceGroupIDs(NotNull(),NotNull() )).Times(1);
 129     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("ListAllSurfaceGroupIDS")).c_str()));
 130 }
 131
 132 TEST_F(DBUSCommunicatorTest, listSurfacesOfSurfacegroup) {
 133
 134     std::list<int> defaultlist;
 135     DefaultValue<Scene*>::Set((Scene*) &this->layerlist);
 136     DefaultValue<std::list<int> >::Set(defaultlist);
 137     DefaultValue<SurfaceGroup*>::Set(new SurfaceGroup());
 138     EXPECT_CALL(this->layerlist, getSurfaceGroup(Eq(84567u) )).Times(1);
 139     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("ListSurfacesOfSurfacegroup uint32:84567")).c_str()));
 140
 141 }
 142
 143 TEST_F(DBUSCommunicatorTest, listlayersOflayergroup) {
 144
 145     std::list<int> defaultlist;
 146     DefaultValue<Scene*>::Set((Scene*) &this->layerlist);
 147     DefaultValue<std::list<int> >::Set(defaultlist);
 148     DefaultValue<LayerGroup*>::Set(new LayerGroup());
 149
 150     EXPECT_CALL(this->layerlist, getLayerGroup(Eq(345u) )).Times(1);
 151     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("ListLayersOfLayergroup uint32:345")).c_str()));
 152
 153 }
 154
 155 TEST_F(DBUSCommunicatorTest, listSurfaceoflayer) {
 156
 157     Scene scene;
 158     DefaultValue<Layer*>::Set(scene.createLayer(234));
 159     DefaultValue<Scene*>::Set((Scene*) &layerlist);
 160     EXPECT_CALL(this->layerlist, getLayer(Eq(234u) )).Times(1);
 161     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("ListSurfaceofLayer uint32:234")).c_str()));
 162 }
 163
 164 TEST_F(DBUSCommunicatorTest, getPropertiesOfSurface) {
 165
 166     Scene scene;
 167     unsigned int newID = 0;
 168     DefaultValue<Scene*>::Set((Scene*) &layerlist);
 169     DefaultValue<Surface*>::Set(scene.createSurface(newID));
 170     EXPECT_CALL(this->layerlist, getSurface(Eq(876u) )).Times(1);
 171     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetPropertiesOfSurface uint32:876")).c_str()));
 172 }
 173
 174 TEST_F(DBUSCommunicatorTest, getPropertiesOflayer) {
 175
 176     Scene scene;
 177     DefaultValue<Layer*>::Set(scene.createLayer(0));
 178     DefaultValue<Scene*>::Set((Scene*) &layerlist);
 179     EXPECT_CALL(this->layerlist, getLayer(Eq(876u) )).Times(1);
 180     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetPropertiesOfLayer uint32:876")).c_str()));
 181 }
 182 /*
 183 MATCHER_P4(SurfaceCreateCommandEq, nativeHandle, OriginalWidth, OriginalHeight, pixelformat, "%(*)s"){
 184     return ((SurfaceCreateCommand*)arg)->m_nativeHandle == nativeHandle
 185         && ((SurfaceCreateCommand*)arg)->m_originalHeight == OriginalHeight
 186         && ((SurfaceCreateCommand*)arg)->m_originalWidth == OriginalWidth
 187         && ((SurfaceCreateCommand*)arg)->m_pixelformat == pixelformat;
 188 }
 189 */
 190
 191 /*
 192 TEST_F(DBUSCommunicatorTest, CreateSurface) {
 193
 194     EXPECT_CALL(this->mockCommandExecutor, execute( SurfaceCreateCommandEq(44u,33u,22u,PIXELFORMAT_RGBA8888))).Times(1);
 195     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateSurface uint32:44 uint32:33 uint32:22 uint32:2 ")).c_str());
 196
 197     EXPECT_CALL(this->mockCommandExecutor, execute( SurfaceCreateCommandEq(404u,303u,0u,PIXELFORMAT_RGB888))).Times(1);
 198     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateSurface uint32:404 uint32:303 uint32:0 uint32:1 ")).c_str());
 199 }
 200 */
 201
 202 MATCHER_P2(LayerCreateCommandEq, OriginalWidth, OriginalHeight, "%(*)s"){
 203     return ((LayerCreateCommand*)arg)->m_originalHeight == OriginalHeight
 204         && ((LayerCreateCommand*)arg)->m_originalWidth == OriginalWidth;
 205 }
 206
 207 TEST_F(DBUSCommunicatorTest, CreateLayer) {
 208
 209     uint resolution[2] = { 0, 0 };
 210     DefaultValue<uint*>::Set(resolution);
 211
 212     EXPECT_CALL(this->mockCommandExecutor, execute( LayerCreateCommandEq(0u,0u))).Times(1);
 213     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateLayer")).c_str()));
 214 }
 215
 216 MATCHER_P(SurfaceRemoveCommandEq, idToRemove, "%(*)s"){
 217     return ((SurfaceRemoveCommand*)arg)->m_idToRemove == idToRemove;
 218 }
 219
 220 TEST_F(DBUSCommunicatorTest, RemoveSurface) {
 221
 222     EXPECT_CALL(this->mockCommandExecutor, execute( SurfaceRemoveCommandEq(8u))).Times(1);
 223     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveSurface uint32:8")).c_str()));
 224
 225     EXPECT_CALL(this->mockCommandExecutor, execute( SurfaceRemoveCommandEq(5u))).Times(1);
 226     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveSurface uint32:5")).c_str()));
 227 }
 228
 229 MATCHER_P(LayerRemoveCommandEq, idToRemove, "%(*)s"){
 230     return ((LayerRemoveCommand*)arg)->m_idToRemove == idToRemove;
 231 }
 232
 233 TEST_F(DBUSCommunicatorTest, Removelayer) {
 234     EXPECT_CALL(this->mockCommandExecutor, execute( LayerRemoveCommandEq(8u))).Times(1);
 235     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveLayer uint32:8")).c_str()));
 236
 237     EXPECT_CALL(this->mockCommandExecutor, execute( LayerRemoveCommandEq(5u))).Times(1);
 238     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveLayer uint32:5")).c_str()));
 239 }
 240
 241 MATCHER_P2(SurfaceSetOpacityCommandEq, id, Opacity, "%(*)s"){
 242     return ((SurfaceSetOpacityCommand*)arg)->m_id == id
 243         && ((SurfaceSetOpacityCommand*)arg)->m_opacity == Opacity;
 244 }
 245
 246 TEST_F(DBUSCommunicatorTest, SetSurfaceOpacity) {
 247     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetOpacityCommandEq(36u,0.88) )).Times(1);
 248     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceOpacity uint32:36 double:0.88")).c_str()));
 249
 250     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetOpacityCommandEq(44u,0.001) )).Times(1);
 251     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceOpacity uint32:44 double:0.001")).c_str()));
 252 }
 253
 254 /*
 255 TEST_F(DBUSCommunicatorTest, Exit) {
 256     EXPECT_CALL(this->mockCommandExecutor, execute(Field(&Command::commandType,Eq(Command::Exit)) ) ).Times(1);
 257     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("Exit")).c_str());
 258
 259     //EXPECT_EXIT(ASSERT_NE(-1, system((DBUSCOMMAND + std::string("Exit")).c_str());, ::testing::ExitedWithCode(0), "");
 260 }
 261 */
 262
 263 /*
 264 TEST_F(DBUSCommunicatorTest, Commit) {
 265     EXPECT_CALL(this->mockCommandExecutor, execute(Field(&ICommand::commandType, Eq(ICommand::CommitChanges)) ) ).Times(1);
 266     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CommitChanges")).c_str());
 267 }
 268 */
 269
 270 MATCHER_P5(SurfaceSetSourceRectangleCommandEq, id, x, y, width, height, "%(*)s"){
 271     return ((SurfaceSetSourceRectangleCommand*)arg)->m_id == id
 272         && ((SurfaceSetSourceRectangleCommand*)arg)->m_x == x
 273         && ((SurfaceSetSourceRectangleCommand*)arg)->m_y == y
 274         && ((SurfaceSetSourceRectangleCommand*)arg)->m_width == width
 275         && ((SurfaceSetSourceRectangleCommand*)arg)->m_height == height;
 276 }
 277
 278 TEST_F(DBUSCommunicatorTest, SetSurfaceSourceRegion) {
 279
 280     EXPECT_CALL(this->mockCommandExecutor, execute( SurfaceSetSourceRectangleCommandEq(36u,1u,2u,3u,4u))).Times(1);
 281     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceSourceRegion uint32:36 uint32:1 uint32:2 uint32:3 uint32:4")).c_str()));
 282
 283     EXPECT_CALL(this->mockCommandExecutor, execute( SurfaceSetSourceRectangleCommandEq(44u,15u,25u,35u,45u))).Times(1);
 284     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceSourceRegion uint32:44 uint32:15 uint32:25 uint32:35 uint32:45 ")).c_str()));
 285 }
 286
 287 MATCHER_P5(LayerSetSourceRectangleCommandEq, id, x, y, width, height, "%(*)s"){
 288     return ((LayerSetSourceRectangleCommand*)arg)->m_id == id
 289         && ((LayerSetSourceRectangleCommand*)arg)->m_x == x
 290         && ((LayerSetSourceRectangleCommand*)arg)->m_y == y
 291         && ((LayerSetSourceRectangleCommand*)arg)->m_width == width
 292         && ((LayerSetSourceRectangleCommand*)arg)->m_height == height;
 293 }
 294
 295 TEST_F(DBUSCommunicatorTest, SetlayerSourceRegion) {
 296
 297     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetSourceRectangleCommandEq(36u,1u,2u,3u,4u))).Times(1);
 298     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerSourceRegion uint32:36 uint32:1 uint32:2 uint32:3 uint32:4")).c_str()));
 299
 300     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetSourceRectangleCommandEq(44u,15u,25u,35u,45u))).Times(1);
 301     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerSourceRegion uint32:44 uint32:15 uint32:25 uint32:35 uint32:45 ")).c_str()));
 302 }
 303
 304 MATCHER_P5(LayerSetDestinationRectangleCommandEq, id, x, y, width, height, "%(*)s") {
 305     return ((LayerSetDestinationRectangleCommand*)arg)->m_id == id
 306         && ((LayerSetDestinationRectangleCommand*)arg)->m_x == x
 307         && ((LayerSetDestinationRectangleCommand*)arg)->m_y == y
 308         && ((LayerSetDestinationRectangleCommand*)arg)->m_width == width
 309         && ((LayerSetDestinationRectangleCommand*)arg)->m_height == height;
 310 }
 311
 312 TEST_F(DBUSCommunicatorTest, SetlayerDestinationRegion) {
 313
 314     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetDestinationRectangleCommandEq(36u,1u,2u,3u,4u))).Times(1);
 315     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerDestinationRegion uint32:36 uint32:1 uint32:2 uint32:3 uint32:4")).c_str()));
 316
 317     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetDestinationRectangleCommandEq(44u,15u,25u,35u,45u))).Times(1);
 318     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerDestinationRegion uint32:44 uint32:15 uint32:25 uint32:35 uint32:45 ")).c_str()));
 319 }
 320
 321 MATCHER_P5(SurfaceSetDestinationRectangleCommandEq, id, x, y, width, height, "%(*)s") {
 322     return ((SurfaceSetDestinationRectangleCommand*)arg)->m_id == id
 323         && ((SurfaceSetDestinationRectangleCommand*)arg)->m_x == x
 324         && ((SurfaceSetDestinationRectangleCommand*)arg)->m_y == y
 325         && ((SurfaceSetDestinationRectangleCommand*)arg)->m_width == width
 326         && ((SurfaceSetDestinationRectangleCommand*)arg)->m_height == height;
 327 }
 328
 329 TEST_F(DBUSCommunicatorTest, SetSurfaceDestinationRegion) {
 330
 331     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetDestinationRectangleCommandEq(36u,1u,2u,3u,4u))).Times(1);
 332     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceDestinationRegion uint32:36 uint32:1 uint32:2 uint32:3 uint32:4")).c_str()));
 333
 334     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetDestinationRectangleCommandEq(44u,15u,25u,35u,45u))).Times(1);
 335     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceDestinationRegion uint32:44 uint32:15 uint32:25 uint32:35 uint32:45 ")).c_str()));
 336 }
 337
 338 MATCHER_P3(LayerSetPositionCommandEq, id, x, y, "%(*)s"){
 339     return ((LayerSetPositionCommand*)arg)->m_id == id
 340         && ((LayerSetPositionCommand*)arg)->m_x == x
 341         && ((LayerSetPositionCommand*)arg)->m_y == y;
 342 }
 343
 344 TEST_F(DBUSCommunicatorTest, SetlayerPosition) {
 345     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetPositionCommandEq(36u,1u,2u))).Times(1);
 346     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerPosition uint32:36 uint32:1 uint32:2")).c_str()));
 347
 348     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetPositionCommandEq(44u,15u,25u))).Times(1);
 349     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerPosition uint32:44 uint32:15 uint32:25 ")).c_str()));
 350 }
 351
 352 MATCHER_P3(SurfaceSetPositionCommandEq, id, x, y, "%(*)s"){
 353     return ((SurfaceSetPositionCommand*)arg)->m_id == id
 354         && ((SurfaceSetPositionCommand*)arg)->m_x == x
 355         && ((SurfaceSetPositionCommand*)arg)->m_y == y;
 356 }
 357
 358 TEST_F(DBUSCommunicatorTest, SetSurfacePosition) {
 359     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetPositionCommandEq(36u,3u,4u))).Times(1);
 360     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacePosition uint32:36 uint32:3 uint32:4")).c_str()));
 361
 362     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetPositionCommandEq(44u,35u,45u))).Times(1);
 363     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacePosition uint32:44 uint32:35 uint32:45 ")).c_str()));
 364 }
 365
 366 MATCHER_P3(LayerSetDimensionCommandEq, id, width, height, "%(*)s"){
 367     return ((LayerSetDimensionCommand*)arg)->m_id == id
 368         && ((LayerSetDimensionCommand*)arg)->m_width == width
 369         && ((LayerSetDimensionCommand*)arg)->m_height == height;
 370 }
 371
 372 TEST_F(DBUSCommunicatorTest, SetlayerDimension) {
 373     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetDimensionCommandEq(8554u,400u,444u))).Times(1);
 374     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerDimension uint32:8554 uint32:400 uint32:444")).c_str()));
 375
 376     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetDimensionCommandEq(34589u,400u,444u))).Times(1);
 377     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerDimension uint32:34589 uint32:400 uint32:444")).c_str()));
 378 }
 379
 380 MATCHER_P3(SurfaceSetDimensionCommandEq, id, width, height, "%(*)s"){
 381     return ((SurfaceSetDimensionCommand*)arg)->m_id == id
 382         && ((SurfaceSetDimensionCommand*)arg)->m_width == width
 383         && ((SurfaceSetDimensionCommand*)arg)->m_height == height;
 384 }
 385
 386 TEST_F(DBUSCommunicatorTest, SetSurfaceDimension) {
 387     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetDimensionCommandEq(36u,3u,4u))).Times(1);
 388     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceDimension uint32:36 uint32:3 uint32:4")).c_str()));
 389
 390     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetDimensionCommandEq(44u,35u,45u))).Times(1);
 391     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceDimension uint32:44 uint32:35 uint32:45 ")).c_str()));
 392 }
 393
 394 MATCHER_P2(LayerSetOpacityCommandEq, id, Opacity, "%(*)s"){
 395     return ((LayerSetOpacityCommand*)arg)->m_id == id
 396         && ((LayerSetOpacityCommand*)arg)->m_opacity == Opacity;
 397 }
 398
 399 TEST_F(DBUSCommunicatorTest, SetlayerOpacity) {
 400
 401     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetOpacityCommandEq(36u,0.88))).Times(1);
 402     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerOpacity uint32:36 double:0.88")).c_str()));
 403
 404     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetOpacityCommandEq(44u,0.001))).Times(1);
 405     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerOpacity uint32:44 double:0.001")).c_str()));
 406 }
 407
 408 MATCHER_P(LayerGetOpacityCommandEq, id, "%(*)s"){
 409     return ((LayerGetOpacityCommand*)arg)->m_id == id;
 410 }
 411
 412 TEST_F(DBUSCommunicatorTest, GetlayerOpacity) {
 413
 414     EXPECT_CALL(this->mockCommandExecutor, execute(LayerGetOpacityCommandEq(36u))).Times(1);
 415     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerOpacity uint32:36")).c_str()));
 416
 417     EXPECT_CALL(this->mockCommandExecutor, execute(LayerGetOpacityCommandEq(44u))).Times(1);
 418     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerOpacity uint32:44 ")).c_str()));
 419 }
 420
 421 MATCHER_P2(SurfacegroupSetOpacityCommandEq, id, Opacity, "%(*)s") {
 422     return ((SurfacegroupSetOpacityCommand*)arg)->m_id == id
 423         && ((SurfacegroupSetOpacityCommand*)arg)->m_opacity == Opacity;
 424 }
 425
 426 TEST_F(DBUSCommunicatorTest, SetSurfacegroupOpacity) {
 427
 428     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupSetOpacityCommandEq(36u,0.88))).Times(1);
 429     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacegroupOpacity uint32:36 double:0.88")).c_str()));
 430
 431     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupSetOpacityCommandEq(44u,0.001))).Times(1);
 432     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacegroupOpacity uint32:44 double:0.001")).c_str()));
 433 }
 434
 435 MATCHER_P2(LayergroupSetOpacityCommandEq, id, Opacity, "%(*)s"){
 436     return ((LayergroupSetOpacityCommand*)arg)->m_id == id
 437         && ((LayergroupSetOpacityCommand*)arg)->m_opacity == Opacity;
 438 }
 439
 440 TEST_F(DBUSCommunicatorTest, SetlayergroupOpacity) {
 441
 442     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupSetOpacityCommandEq(36u,0.88))).Times(1);
 443     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayergroupOpacity uint32:36 double:0.88")).c_str()));
 444
 445     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupSetOpacityCommandEq(44u,0.001))).Times(1);
 446     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayergroupOpacity uint32:44 double:0.001")).c_str()));
 447 }
 448
 449 MATCHER_P2(SurfaceSetOrientationCommandEq, id, Orientation, "%(*)s") {
 450     return ((SurfaceSetOrientationCommand*)arg)->m_id == id
 451         && ((SurfaceSetOrientationCommand*)arg)->m_orientation == Orientation;
 452 }
 453
 454 TEST_F(DBUSCommunicatorTest, SetSurfaceOrientation) {
 455
 456     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetOrientationCommandEq(36u,0))).Times(1);
 457     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceOrientation uint32:36 uint32:0")).c_str()));
 458
 459     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetOrientationCommandEq(44u,1))).Times(1);
 460     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceOrientation uint32:44 uint32:1")).c_str()));
 461 }
 462
 463 MATCHER_P2(LayerSetOrientationCommandEq, id, Orientation, "%(*)s") {
 464     return ((LayerSetOrientationCommand*)arg)->m_id == id
 465         && ((LayerSetOrientationCommand*)arg)->m_orientation == Orientation;
 466 }
 467
 468 TEST_F(DBUSCommunicatorTest, SetlayerOrientation) {
 469
 470     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetOrientationCommandEq(36u,0))).Times(1);
 471     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerOrientation uint32:36 uint32:0")).c_str()));
 472
 473     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetOrientationCommandEq(44u,1))).Times(1);
 474     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerOrientation uint32:44 uint32:1")).c_str()));
 475 }
 476
 477 MATCHER_P2(SurfaceSetVisibilityCommandEq, id, visibility, "%(*)s"){
 478     return ((SurfaceSetVisibilityCommand*)arg)->m_idtoSet == id
 479         && ((SurfaceSetVisibilityCommand*)arg)->m_visibility == visibility;
 480 }
 481
 482 TEST_F(DBUSCommunicatorTest, SetSurfaceVisibility) {
 483
 484     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetVisibilityCommandEq(36u,false))).Times(1);
 485     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceVisibility uint32:36 boolean:false")).c_str()));
 486
 487     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetVisibilityCommandEq(44u,true))).Times(1);
 488     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceVisibility uint32:44 boolean:true")).c_str()));
 489
 490     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetVisibilityCommandEq(36u,false))).Times(1);
 491     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceVisibility uint32:36 boolean:false")).c_str()));
 492
 493     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetVisibilityCommandEq(44u,true))).Times(1);
 494     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfaceVisibility uint32:44 boolean:true")).c_str()));
 495 }
 496
 497 MATCHER_P2(LayerSetVisibilityCommandEq, id, visibility, "%(*)s"){
 498     return ((LayerSetVisibilityCommand*)arg)->m_idtoSet == id
 499         && ((LayerSetVisibilityCommand*)arg)->m_visibility == visibility;
 500 }
 501
 502 TEST_F(DBUSCommunicatorTest, SetlayerVisibility) {
 503
 504     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetVisibilityCommandEq(36u,false))).Times(1);
 505     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerVisibility uint32:36 boolean:false")).c_str()));
 506
 507     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetVisibilityCommandEq(44u,true))).Times(1);
 508     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerVisibility uint32:44 boolean:true")).c_str()));
 509
 510     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetVisibilityCommandEq(36u,false))).Times(1);
 511     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerVisibility uint32:36 boolean:false")).c_str()));
 512
 513     EXPECT_CALL(this->mockCommandExecutor, execute(LayerSetVisibilityCommandEq(44u,true))).Times(1);
 514     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayerVisibility uint32:44 boolean:true")).c_str()));
 515 }
 516
 517 MATCHER_P2(SurfacegroupSetVisibilityCommandEq, id, visibility, "%(*)s"){
 518     return ((SurfacegroupSetVisibilityCommand*)arg)->m_idtoSet == id
 519         && ((SurfacegroupSetVisibilityCommand*)arg)->m_visibility == visibility;
 520 }
 521
 522 TEST_F(DBUSCommunicatorTest, SetSurfacegroupVisibility) {
 523
 524     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupSetVisibilityCommandEq(36u,false))).Times(1);
 525     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacegroupVisibility uint32:36 boolean:false")).c_str()));
 526
 527     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupSetVisibilityCommandEq(44u,true))).Times(1);
 528     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacegroupVisibility uint32:44 boolean:true")).c_str()));
 529
 530     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupSetVisibilityCommandEq(36u,false))).Times(1);
 531     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacegroupVisibility uint32:36 boolean:false")).c_str()));
 532
 533     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupSetVisibilityCommandEq(44u,true))).Times(1);
 534     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetSurfacegroupVisibility uint32:44 boolean:true")).c_str()));
 535
 536 }
 537
 538 MATCHER_P2(LayergroupSetVisibilityCommandEq, id, visibility, "%(*)s"){
 539     return ((LayergroupSetVisibilityCommand*)arg)->m_idtoSet == id
 540         && ((LayergroupSetVisibilityCommand*)arg)->m_visibility == visibility;
 541 }
 542
 543 TEST_F(DBUSCommunicatorTest, SetlayergroupVisibility) {
 544
 545     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupSetVisibilityCommandEq(36u,false))).Times(1);
 546     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayergroupVisibility uint32:36 boolean:false")).c_str()));
 547
 548     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupSetVisibilityCommandEq(44u,true))).Times(1);
 549     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayergroupVisibility uint32:44 boolean:true")).c_str()));
 550
 551     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupSetVisibilityCommandEq(36u,false))).Times(1);
 552     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayergroupVisibility uint32:36 boolean:false")).c_str()));
 553
 554     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupSetVisibilityCommandEq(44u,true))).Times(1);
 555     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetLayergroupVisibility uint32:44 boolean:true")).c_str()));
 556 }
 557
 558 MATCHER_P2(SurfacegroupAddSurfaceCommandEq, surfaceid, surfacegroupid, "%(*)s"){
 559     return ((SurfacegroupAddSurfaceCommand*)arg)->m_surfacegroupid == surfacegroupid
 560         && ((SurfacegroupAddSurfaceCommand*)arg)->m_surfaceid == surfaceid;
 561
 562 }
 563 TEST_F(DBUSCommunicatorTest, AddSurfaceToSurfaceGroup) {
 564
 565     EXPECT_CALL(this->mockCommandExecutor, execute( SurfacegroupAddSurfaceCommandEq(36u,77u))).Times(1);
 566     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("AddSurfaceToSurfaceGroup uint32:36 uint32:77")).c_str()));
 567 }
 568
 569 MATCHER_P2(SurfacegroupRemoveSurfaceCommandEq, surfacegroupid, surfaceid, "%(*)s"){
 570     return ((SurfacegroupRemoveSurfaceCommand*)arg)->m_surfacegroupid == surfacegroupid
 571         && ((SurfacegroupRemoveSurfaceCommand*)arg)->m_surfaceid == surfaceid;
 572 }
 573
 574 TEST_F(DBUSCommunicatorTest, RemoveSurfaceFromSurfaceGroup) {
 575
 576     EXPECT_CALL(this->mockCommandExecutor, execute( SurfacegroupAddSurfaceCommandEq(36u,77u))).Times(1);
 577     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveSurfaceFromSurfaceGroup uint32:36 uint32:77")).c_str()));
 578 }
 579
 580 MATCHER_P2(LayergroupAddLayerCommandEq, layerid, layergroupid, "%(*)s"){
 581     return ((LayergroupAddLayerCommand*)arg)->m_layergroupid == layergroupid
 582         && ((LayergroupAddLayerCommand*)arg)->m_layerid == layerid;
 583 }
 584
 585 TEST_F(DBUSCommunicatorTest, AddlayerTolayerGroup) {
 586
 587     EXPECT_CALL(this->mockCommandExecutor, execute( LayergroupAddLayerCommandEq(36u,77u))).Times(1);
 588     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("AddLayerToLayerGroup uint32:36 uint32:77")).c_str()));
 589 }
 590
 591 MATCHER_P2(LayergroupRemoveLayerCommandEq, layerid,layergroupid, "%(*)s"){
 592     return ((LayergroupRemoveLayerCommand*)arg)->m_layergroupid == layergroupid
 593         && ((LayergroupRemoveLayerCommand*)arg)->m_layerid == layerid;
 594 }
 595
 596 TEST_F(DBUSCommunicatorTest, RemovelayerFromlayerGroup) {
 597
 598     EXPECT_CALL(this->mockCommandExecutor, execute( LayergroupRemoveLayerCommandEq(36u,77u))).Times(1);
 599     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveLayerFromLayerGroup uint32:36 uint32:77")).c_str()));
 600 }
 601
 602 MATCHER_P2(LayerAddSurfaceCommandEq, surfaceid, layerid, "%(*)s"){
 603     return ((LayerAddSurfaceCommand*)arg)->m_layerid == layerid
 604         && ((LayerAddSurfaceCommand*)arg)->m_surfaceid == surfaceid;
 605 }
 606
 607 TEST_F(DBUSCommunicatorTest, AddSurfaceTolayer) {
 608
 609     EXPECT_CALL(this->mockCommandExecutor, execute( LayerAddSurfaceCommandEq(36u,77u))).Times(1);
 610     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("AddSurfaceToLayer uint32:36 uint32:77")).c_str()));
 611 }
 612
 613 MATCHER_P2(LayerRemoveSurfaceCommandEq, surfaceid, layerid, "%(*)s"){
 614     return ((LayerRemoveSurfaceCommand*)arg)->m_layerid == layerid
 615         && ((LayerRemoveSurfaceCommand*)arg)->m_surfaceid == surfaceid;
 616 }
 617
 618 TEST_F(DBUSCommunicatorTest, RemoveSurfaceFromlayer) {
 619
 620     EXPECT_CALL(this->mockCommandExecutor, execute( LayerRemoveSurfaceCommandEq(36u,77u))).Times(1);
 621     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveSurfaceFromLayer uint32:36 uint32:77")).c_str()));
 622 }
 623
 624 /*
 625 TEST_F(DBUSCommunicatorTest, CreateSurfaceGroup) {
 626
 627     EXPECT_CALL(this->mockCommandExecutor, execute()).Times(1);
 628     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateSurfaceGroup")).c_str()));
 629
 630     EXPECT_CALL(this->mockCommandExecutor, execute( CreateCommandEq(0u,0u,0u,TypeSurfaceGroup,PIXELFORMAT_R8))).Times(1);
 631     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateSurfaceGroup")).c_str()));
 632 }
 633 */
 634
 635 MATCHER_P(SurfacegroupRemoveCommandEq, idToRemove, "%(*)s") {
 636     return ((SurfacegroupRemoveCommand*)arg)->m_idToRemove == idToRemove;
 637 }
 638
 639 TEST_F(DBUSCommunicatorTest, RemoveSurfaceGroup) {
 640
 641     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupRemoveCommandEq(8554u))).Times(1);
 642     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveSurfaceGroup uint32:8554")).c_str()));
 643
 644     EXPECT_CALL(this->mockCommandExecutor, execute(SurfacegroupRemoveCommandEq(34589u))).Times(1);
 645     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveSurfaceGroup uint32:34589")).c_str()));
 646 }
 647
 648 /*
 649 TEST_F(DBUSCommunicatorTest, CreatelayerGroup) {
 650
 651     EXPECT_CALL(this->mockCommandExecutor, execute( CreateCommandEq(0u,0u,0u,TypeLayerGroup,PIXELFORMAT_R8))).Times(1);
 652     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateLayerGroup")).c_str()));
 653
 654     EXPECT_CALL(this->mockCommandExecutor, execute( CreateCommandEq(0u,0u,0u,TypeLayerGroup,PIXELFORMAT_R8))).Times(1);
 655     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateLayerGroup")).c_str()));
 656 }
 657 */
 658
 659 MATCHER_P(LayergroupRemoveCommandEq, idToRemove, "%(*)s") {
 660     return ((LayergroupRemoveCommand*)arg)->m_idToRemove == idToRemove;
 661 }
 662
 663 TEST_F(DBUSCommunicatorTest, RemovelayerGroup) {
 664
 665     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupRemoveCommandEq(8554u))).Times(1);
 666     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveLayerGroup uint32:8554")).c_str()));
 667
 668     EXPECT_CALL(this->mockCommandExecutor, execute(LayergroupRemoveCommandEq(34589u))).Times(1);
 669     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("RemoveLayerGroup uint32:34589")).c_str()));
 670 }
 671
 672 MATCHER_P(LayerGetDimensionCommandEq, id, "%(*)s") {
 673     return ((LayerGetDimensionCommand*)arg)->m_id == id;
 674 }
 675
 676 TEST_F(DBUSCommunicatorTest, GetlayerDimension) {
 677     EXPECT_CALL(this->mockCommandExecutor, execute(LayerGetDimensionCommandEq(8554u))).Times(1);
 678     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerDimension uint32:8554")).c_str()));
 679
 680     EXPECT_CALL(this->mockCommandExecutor, execute(LayerGetDimensionCommandEq(34589u))).Times(1);
 681     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerDimension uint32:34589")).c_str()));
 682 }
 683
 684 MATCHER_P(SurfaceGetDimensionCommandEq, id, "%(*)s") {
 685     return ((SurfaceGetDimensionCommand*)arg)->m_id == id;
 686 }
 687
 688 TEST_F(DBUSCommunicatorTest, GetSurfaceDimension) {
 689
 690     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetDimensionCommandEq(8554u))).Times(1);
 691     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfaceDimension uint32:8554")).c_str()));
 692
 693     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetDimensionCommandEq(34589u))).Times(1);
 694     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfaceDimension uint32:34589")).c_str()));
 695 }
 696
 697 MATCHER_P(SurfaceGetPixelformatCommandEq, id, "%(*)s"){
 698     return ((SurfaceGetPixelformatCommand*)arg)->m_id == id;
 699 }
 700
 701 TEST_F(DBUSCommunicatorTest, GetSurfacePixelformat) {
 702     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetPixelformatCommandEq(8554u))).Times(1);
 703     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfacePixelformat uint32:8554")).c_str()));
 704
 705     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetPixelformatCommandEq(34589u))).Times(1);
 706     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfacePixelformat uint32:34589")).c_str()));
 707 }
 708
 709 MATCHER_P(SurfaceGetOpacityCommandEq, id, "%(*)s"){
 710     return ((SurfaceGetOpacityCommand*)arg)->m_id == id;
 711 }
 712
 713 TEST_F(DBUSCommunicatorTest, GetSurfaceOpacity) {
 714     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetOpacityCommandEq(8554u))).Times(1);
 715     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfaceOpacity uint32:8554")).c_str()));
 716
 717     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetOpacityCommandEq(34589u))).Times(1);
 718     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfaceOpacity uint32:34589")).c_str()));
 719 }
 720
 721 MATCHER_P(SurfaceGetVisibilityCommandEq, id, "%(*)s") {
 722     return ((SurfaceGetVisibilityCommand*)arg)->m_id == id;
 723 }
 724
 725 TEST_F(DBUSCommunicatorTest, GetSurfaceVisibility) {
 726     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetVisibilityCommandEq(8554u))).Times(1);
 727     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfaceVisibility uint32:8554")).c_str()));
 728
 729     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceGetVisibilityCommandEq(34589u))).Times(1);
 730     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetSurfaceVisibility uint32:34589")).c_str()));
 731 }
 732
 733 MATCHER_P(LayerGetVisibilityCommandEq, id, "%(*)s"){
 734     return ((LayerGetVisibilityCommand*)arg)->m_id == id;
 735 }
 736
 737 TEST_F(DBUSCommunicatorTest, GetlayerVisibility) {
 738     EXPECT_CALL(this->mockCommandExecutor, execute(LayerGetVisibilityCommandEq(8554u))).Times(1);
 739     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerVisibility uint32:8554")).c_str()));
 740
 741     EXPECT_CALL(this->mockCommandExecutor, execute(LayerGetVisibilityCommandEq(34589u))).Times(1);
 742     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerVisibility uint32:34589")).c_str()));
 743 }
 744
 745 /*
 746 MATCHER_P2(RenderOrderTester,commandtype,list, "") {
 747     LOG_ERROR("in tester",0);
 748     commandtype_type command = (commandtype_type)arg;
 749     testing::internal::ElementsAreArrayMatcher<int> matcher = ElementsAreArray(command->array,3);
 750     std::vector<uint> l;
 751     testing::Matcher<std::vector<uint, std::allocator<uint> > > matcher2 = matcher.operator Matcher<std::vector<uint> >();
 752     bool result = matcher2.Matches(list);
 753     return result;
 754 }
 755
 756 TEST_F(DBUSCommunicatorTest, SetRenderOrderOflayers) {
 757
 758 //  DBUSClient* client = dbus_helper();
 759 //  if (NULL== client)
 760 //      LOG_ERROR("TEST", "client is null");
 761 //
 762 //  std::vector<uint> expected;
 763 //  expected.push_back(4);
 764 //  expected.push_back(47);
 765 //  expected.push_back(49);
 766 //  SetLayerOrderCommand * p;
 767 // EXPECT_CALL(this->mockCommandExecutor,execute(RenderOrderTester(p,expected))).Times(1);
 768 //  uint display = 0;
 769 //  client->SetRenderOrderOfLayers(expected,display);
 770
 771 }
 772
 773 TEST_F(DBUSCommunicatorTest, SetRenderOrderWithinlayer) {
 774 //  DBUSClient* client = dbus_helper();
 775 //
 776 //  std::vector<uint> expected;
 777 //  expected.push_back(4);
 778 //  expected.push_back(47);
 779 //  expected.push_back(49);
 780 //  SetOrderWithinLayerCommand * p;
 781 // EXPECT_CALL(this->mockCommandExecutor,execute(AllOf(
 782 //                          RenderOrderTester(p,expected),
 783 //                          FieldCast(&SetOrderWithinLayerCommand::layerid,55))
 784 //                          )).Times(1);
 785 //  client->SetSurfaceRenderOrderWithinLayer(55,expected);
 786 }
 787 */
 788
 789 TEST_F(DBUSCommunicatorTest, GetlayerType) {
 790     DefaultValue<Scene*>::Set((Scene*) &layerlist);
 791     EXPECT_CALL(this->layerlist, getLayer(Eq(8554u))).Times(1);
 792     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerType uint32:8554")).c_str()));
 793 }
 794
 795 TEST_F(DBUSCommunicatorTest, GetlayertypeCapabilities) {
 796     EXPECT_CALL(this->mockCommandExecutor, getLayerTypeCapabilities(Eq(367))).Times(1);
 797     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayertypeCapabilities uint32:367")).c_str()));
 798 }
 799
 800 TEST_F(DBUSCommunicatorTest, GetlayerCapabilities) {
 801     Scene scene;
 802     DefaultValue<Scene*>::Set((Scene*) &layerlist);
 803     EXPECT_CALL(this->layerlist, getLayer(Eq(367u))).Times(1);
 804     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("GetLayerCapabilities uint32:367")).c_str()));
 805
 806 }
 807
 808 MATCHER_P2(ShaderCreateCommandEq, _vertName,_fragName, "%(*)s") {
 809     return ((ShaderCreateCommand*)arg)->getVertName() == _vertName
 810         && ((ShaderCreateCommand*)arg)->getFragName() == _fragName;
 811 }
 812
 813 TEST_F(DBUSCommunicatorTest, CreateShader) {
 814     EXPECT_CALL(this->mockCommandExecutor, execute(ShaderCreateCommandEq(std::string("test123.glslv"),std::string("differentshader.glslv")))).Times(1);
 815     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateShader string:test123.glslv string:differentshader.glslv")).c_str()));
 816
 817     EXPECT_CALL(this->mockCommandExecutor, execute(ShaderCreateCommandEq(std::string("/usr/lib/shadertest.glslv"),std::string("foobar")))).Times(1);
 818     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("CreateShader string:/usr/lib/shadertest.glslv string:foobar")).c_str()));
 819 }
 820
 821 MATCHER_P(ShaderDestroyCommandEq, id, "%(*)s") {
 822     return ((ShaderDestroyCommand*)arg)->getShaderID() == id;
 823 }
 824
 825 TEST_F(DBUSCommunicatorTest, DestroyShaderCommand) {
 826     EXPECT_CALL(this->mockCommandExecutor, execute(ShaderDestroyCommandEq(567u))).Times(1);
 827     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("DestroyShader uint32:567")).c_str()));
 828
 829     EXPECT_CALL(this->mockCommandExecutor, execute(ShaderDestroyCommandEq(185u))).Times(1);
 830     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("DestroyShader uint32:185")).c_str()));
 831 }
 832
 833 MATCHER_P2(SurfaceSetShaderCommandEq, id, shaderid, "%(*)s") {
 834     return ((SurfaceSetShaderCommand*)arg)->getID() == id
 835         && ((SurfaceSetShaderCommand*)arg)->getShaderID() == shaderid;
 836 }
 837
 838 TEST_F(DBUSCommunicatorTest, SetShaderCommand) {
 839
 840     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetShaderCommandEq(987u, 567u))).Times(1);
 841     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetShader uint32:987 uint32:567")).c_str()));
 842
 843     EXPECT_CALL(this->mockCommandExecutor, execute(SurfaceSetShaderCommandEq(1u, 998877u))).Times(1);
 844     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetShader uint32:1 uint32:998877")).c_str()));
 845 }
 846
 847 MATCHER_P(ShaderUniformsMatcher,expectedlist,"") {
 848     ShaderSetUniformsCommand* command = (ShaderSetUniformsCommand*)arg;
 849     std::vector<std::string> uniforms = command->getUniforms();
 850
 851     EXPECT_THAT(uniforms,ElementsAreArray(*expectedlist));
 852     //EXPECT_THAT(uniforms,ElementsAreArray(expectedlist));
 853     return true;
 854 }
 855
 856 MATCHER_P(ShaderSetUniformsCommandEq, _shaderid, "%(*)s"){
 857     return ((ShaderSetUniformsCommand*)arg)->getShaderId() == _shaderid;
 858 }
 859
 860 TEST_F(DBUSCommunicatorTest, ShaderSetUniformsCommand) {
 861
 862     std::string expected1[] = { "uRotAngle 1f 1 0", "uRotVector 3f 1 1 0 0" };
 863     EXPECT_CALL(this->mockCommandExecutor, execute( AllOf(ShaderSetUniformsCommandEq(1u), ShaderUniformsMatcher(&expected1)))).Times(1);
 864     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetUniforms uint32:1 array:string:\"uRotAngle 1f 1 0\",\"uRotVector 3f 1 1 0 0\"")).c_str()));
 865
 866     std::string expected2[] = { "teststring foobar" };
 867     EXPECT_CALL(this->mockCommandExecutor, execute(AllOf(ShaderSetUniformsCommandEq(17346u), ShaderUniformsMatcher(&expected2)))).Times(1);
 868     ASSERT_NE(-1, system((DBUSCOMMAND + std::string("SetUniforms uint32:17346 array:string:\"teststring foobar\"")).c_str()));
 869 }
 870
 871 #endif /* DBUSCommunicatorTest_H_ */