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