automated-tests/src/dali-physics3d/utc-Dali-PhysicsActor.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <bullet/btBulletDynamicsCommon.h>
  18 #include <stdlib.h>
  19 #include <iostream>
  20
  21 // Need to override adaptor classes for toolkit test harness, so include
  22 // test harness headers before dali headers.
  23 #include <dali-toolkit-test-suite-utils.h>
  24 #include <toolkit-event-thread-callback.h>
  25
  26 #include <dali-physics/dali-physics.h>
  27 #include <dali-toolkit/dali-toolkit.h>
  28 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
  29
  30 using namespace Dali;
  31 using namespace Dali::Toolkit::Physics;
  32
  33 extern btRigidBody* CreateBody(btDiscreteDynamicsWorld* bulletWorld);
  34
  35 const char* BALL_IMAGE = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  36
  37 int UtcDaliPhysics3DActorNew(void)
  38 {
  39   ToolkitTestApplication application;
  40
  41   btRigidBody* body{nullptr};
  42
  43   Matrix         transform(true);
  44   Uint16Pair     size(640, 480);
  45   PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
  46
  47   auto accessor         = adaptor.GetPhysicsAccessor();
  48   auto bulletWorld      = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
  49   body                  = CreateBody(bulletWorld);
  50   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
  51
  52   PhysicsActor physicsActor = PhysicsActor::New(ballActor, body, adaptor);
  53
  54   DALI_TEST_CHECK(physicsActor);
  55   END_TEST;
  56 }
  57
  58 int UtcDaliPhysics3DActorDownCastP(void)
  59 {
  60   ToolkitTestApplication application;
  61
  62   Matrix         transform(true);
  63   Uint16Pair     size(640, 480);
  64   PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
  65
  66   btRigidBody* body{nullptr};
  67   auto         accessor     = adaptor.GetPhysicsAccessor();
  68   auto         bulletWorld  = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
  69   body                      = CreateBody(bulletWorld);
  70   Dali::Actor  ballActor    = Toolkit::ImageView::New(BALL_IMAGE);
  71   PhysicsActor physicsActor = PhysicsActor::New(ballActor, body, adaptor);
  72   BaseHandle   handle(physicsActor);
  73
  74   PhysicsActor actor2 = PhysicsActor::DownCast(handle);
  75   DALI_TEST_CHECK(actor2);
  76   DALI_TEST_EQUALS(physicsActor.GetId(), actor2.GetId(), TEST_LOCATION);
  77
  78   END_TEST;
  79 }
  80
  81 int UtcDaliPhysics3DActorDownCastN(void)
  82 {
  83   BaseHandle   uninitializedHandle;
  84   PhysicsActor actor = PhysicsActor::DownCast(uninitializedHandle);
  85   DALI_TEST_CHECK(!actor);
  86   END_TEST;
  87 }
  88
  89 int UtcDaliPhysics3DActorMoveConstructor(void)
  90 {
  91   ToolkitTestApplication application;
  92   tet_infoline("Testing the move constructor");
  93
  94   Matrix         transform(true);
  95   Uint16Pair     size(640, 480);
  96   PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
  97
  98   btRigidBody* body{nullptr};
  99   auto         accessor     = adaptor.GetPhysicsAccessor();
 100   auto         bulletWorld  = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 101   body                      = CreateBody(bulletWorld);
 102   Dali::Actor  ballActor    = Toolkit::ImageView::New(BALL_IMAGE);
 103   PhysicsActor physicsActor = PhysicsActor::New(ballActor, body, adaptor);
 104
 105   DALI_TEST_CHECK(physicsActor);
 106   uint32_t id = physicsActor.GetId();
 107
 108   PhysicsActor moved = std::move(physicsActor);
 109   DALI_TEST_CHECK(moved);
 110   DALI_TEST_CHECK(!physicsActor);
 111   DALI_TEST_CHECK(moved != physicsActor);
 112   DALI_TEST_EQUALS(moved.GetId(), id, TEST_LOCATION);
 113
 114   END_TEST;
 115 }
 116
 117 int UtcDaliPhysics3DActorCopyConstructor(void)
 118 {
 119   ToolkitTestApplication application;
 120   tet_infoline("Testing the move constructor");
 121
 122   Matrix         transform(true);
 123   Uint16Pair     size(640, 480);
 124   PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
 125
 126   btRigidBody* body{nullptr};
 127   auto         accessor     = adaptor.GetPhysicsAccessor();
 128   auto         bulletWorld  = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 129   body                      = CreateBody(bulletWorld);
 130   Dali::Actor  ballActor    = Toolkit::ImageView::New(BALL_IMAGE);
 131   PhysicsActor physicsActor = PhysicsActor::New(ballActor, body, adaptor);
 132
 133   DALI_TEST_CHECK(physicsActor);
 134   uint32_t id = physicsActor.GetId();
 135
 136   PhysicsActor selectedActor(physicsActor);
 137   DALI_TEST_CHECK(selectedActor);
 138   DALI_TEST_CHECK(physicsActor);
 139   DALI_TEST_CHECK(selectedActor == physicsActor); // should point at same object
 140   DALI_TEST_EQUALS(selectedActor.GetId(), id, TEST_LOCATION);
 141
 142   END_TEST;
 143 }
 144
 145 int UtcDaliPhysics3DActorCopyAssign(void)
 146 {
 147   ToolkitTestApplication application;
 148   tet_infoline("Testing the copy assign");
 149
 150   Matrix         transform(true);
 151   Uint16Pair     size(640, 480);
 152   PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
 153
 154   btRigidBody* body{nullptr};
 155   auto         accessor     = adaptor.GetPhysicsAccessor();
 156   auto         bulletWorld  = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 157   body                      = CreateBody(bulletWorld);
 158   Dali::Actor  ballActor    = Toolkit::ImageView::New(BALL_IMAGE);
 159   PhysicsActor physicsActor = PhysicsActor::New(ballActor, body, adaptor);
 160
 161   DALI_TEST_CHECK(physicsActor);
 162   uint32_t id = physicsActor.GetId();
 163
 164   PhysicsActor selectedActor = physicsActor;
 165   DALI_TEST_CHECK(selectedActor);
 166   DALI_TEST_CHECK(physicsActor);
 167   DALI_TEST_CHECK(selectedActor == physicsActor); // should point at same object
 168   DALI_TEST_EQUALS(selectedActor.GetId(), id, TEST_LOCATION);
 169
 170   END_TEST;
 171 }
 172
 173 int UtcDaliPhysics3DActorMoveAssignment(void)
 174 {
 175   ToolkitTestApplication application;
 176   tet_infoline("Testing the move constructor");
 177
 178   Matrix         transform(true);
 179   Uint16Pair     size(640, 480);
 180   PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
 181
 182   btRigidBody* body{nullptr};
 183   auto         accessor     = adaptor.GetPhysicsAccessor();
 184   auto         bulletWorld  = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 185   body                      = CreateBody(bulletWorld);
 186   Dali::Actor  ballActor    = Toolkit::ImageView::New(BALL_IMAGE);
 187   PhysicsActor physicsActor = PhysicsActor::New(ballActor, body, adaptor);
 188
 189   DALI_TEST_CHECK(physicsActor);
 190   uint32_t id = physicsActor.GetId();
 191
 192   PhysicsActor moved;
 193   moved = std::move(physicsActor);
 194   DALI_TEST_CHECK(moved);
 195   DALI_TEST_CHECK(!physicsActor);
 196   DALI_TEST_EQUALS(moved.GetId(), id, TEST_LOCATION);
 197
 198   END_TEST;
 199 }
 200
 201 int UtcDaliPhysics3DActorGetIdP(void)
 202 {
 203   ToolkitTestApplication application;
 204   tet_infoline("Testing the ID Getter");
 205
 206   Matrix         transform(true);
 207   Uint16Pair     size(640, 480);
 208   PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
 209
 210   btRigidBody* body{nullptr};
 211   auto         accessor     = adaptor.GetPhysicsAccessor();
 212   auto         bulletWorld  = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 213   body                      = CreateBody(bulletWorld);
 214   Dali::Actor  ballActor    = Toolkit::ImageView::New(BALL_IMAGE);
 215   PhysicsActor physicsActor = adaptor.AddActorBody(ballActor, body);
 216   int          id           = physicsActor.GetId();
 217   int          actorId      = ballActor[Actor::Property::ID];
 218   DALI_TEST_EQUALS(id, actorId, TEST_LOCATION);
 219
 220   END_TEST;
 221 }
 222
 223 int UtcDaliPhysics3DActorGetIdN(void)
 224 {
 225   ToolkitTestApplication application;
 226   tet_infoline("Testing the ID Getter");
 227
 228   PhysicsActor physicsActor;
 229   try
 230   {
 231     uint32_t id __attribute__((unused)) = physicsActor.GetId();
 232     tet_result(TET_FAIL);
 233   }
 234   catch(DaliException e)
 235   {
 236     DALI_TEST_ASSERT(e, "Physics actor handle is empty", TEST_LOCATION);
 237   }
 238
 239   END_TEST;
 240 }
 241
 242 int UtcDaliPhysics3DActorGetBodyP(void)
 243 {
 244   ToolkitTestApplication application;
 245   tet_infoline("Testing the body Getter");
 246
 247   Matrix         transform(true);
 248   Uint16Pair     size(640, 480);
 249   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 250   Actor          rootActor = adaptor.GetRootActor();
 251   auto           scene     = application.GetScene();
 252   scene.Add(rootActor);
 253
 254   PhysicsActor physicsActor;
 255   btRigidBody* body{nullptr};
 256   {
 257     auto accessor         = adaptor.GetPhysicsAccessor();
 258     auto bulletWorld      = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 259     body                  = CreateBody(bulletWorld);
 260     Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 261
 262     physicsActor = adaptor.AddActorBody(ballActor, body);
 263   }
 264
 265   application.Render();
 266   Test::WaitForEventThreadTrigger(1);
 267
 268   Dali::Any any = physicsActor.GetBody();
 269   DALI_TEST_EQUALS(any.Get<btRigidBody*>(), body, TEST_LOCATION);
 270
 271   END_TEST;
 272 }
 273
 274 int UtcDaliPhysics3DActorGetBodyN(void)
 275 {
 276   ToolkitTestApplication application;
 277   tet_infoline("Testing the ID Getter");
 278
 279   PhysicsActor physicsActor;
 280   try
 281   {
 282     Dali::Any any __attribute__((unused)) = physicsActor.GetBody();
 283     tet_result(TET_FAIL);
 284   }
 285   catch(DaliException e)
 286   {
 287     DALI_TEST_ASSERT(e, "Physics actor handle is empty", TEST_LOCATION);
 288   }
 289   END_TEST;
 290 }
 291
 292 int UtcDaliPhysics3DActorSetPosition(void)
 293 {
 294   tet_infoline("Test the AsyncSetPhysicsPosition() function");
 295
 296   ToolkitTestApplication application;
 297   Matrix                 transform(false);
 298   transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
 299   Uint16Pair     size(640, 480);
 300   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 301   Actor          rootActor = adaptor.GetRootActor();
 302   auto           scene     = application.GetScene();
 303   scene.Add(rootActor);
 304
 305   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 306
 307   btRigidBody* body{nullptr};
 308   PhysicsActor physicsActor;
 309   {
 310     auto accessor    = adaptor.GetPhysicsAccessor();
 311     auto bulletWorld = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 312     body             = CreateBody(bulletWorld);
 313     physicsActor     = adaptor.AddActorBody(ballActor, body);
 314     physicsActor.AsyncSetPhysicsPosition(Vector3(10, 20, -30));
 315   }
 316
 317   Test::WaitForEventThreadTrigger(1);
 318   adaptor.CreateSyncPoint();
 319   application.SendNotification();
 320   application.Render();
 321
 322   // Run 2 frames to ensure both buffers are set.
 323   application.SendNotification();
 324   application.Render();
 325   {
 326     auto accessor = adaptor.GetPhysicsAccessor();
 327     auto actor    = rootActor.FindChildById(physicsActor.GetId());
 328     // Warning - physics properties are never reflected in the event size cache.
 329     // Have to use GetCurrentProperty to see the updated values.
 330     DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(10, 20, -30), 0.0001f, TEST_LOCATION);
 331   }
 332
 333   END_TEST;
 334 }
 335
 336 int UtcDaliPhysics3DActorSetRotation1(void)
 337 {
 338   tet_infoline("Test the AsyncSetPhysicsRotation() function");
 339
 340   ToolkitTestApplication application;
 341   Matrix                 transform(false);
 342   transform.SetIdentityAndScale(Vector3(2.0f, -2.0f, 2.0f));
 343   Uint16Pair     size(640, 480);
 344   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 345   Actor          rootActor = adaptor.GetRootActor();
 346   auto           scene     = application.GetScene();
 347   scene.Add(rootActor);
 348
 349   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 350
 351   btRigidBody* body{nullptr};
 352   PhysicsActor physicsActor;
 353   {
 354     auto accessor    = adaptor.GetPhysicsAccessor();
 355     auto bulletWorld = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 356     body             = CreateBody(bulletWorld);
 357     physicsActor     = adaptor.AddActorBody(ballActor, body);
 358     physicsActor.AsyncSetPhysicsRotation(Quaternion(Degree(30), Vector3::YAXIS));
 359   }
 360
 361   Test::WaitForEventThreadTrigger(1);
 362   adaptor.CreateSyncPoint();
 363   application.SendNotification();
 364   application.Render();
 365
 366   // Run 2 frames to ensure both buffers are set.
 367   application.SendNotification();
 368   application.Render();
 369   {
 370     auto accessor = adaptor.GetPhysicsAccessor();
 371     auto actor    = rootActor.FindChildById(physicsActor.GetId());
 372     // Warning - physics properties are never reflected in the event size cache.
 373     // Have to use GetCurrentProperty to see the updated values.
 374     Quaternion q = actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION);
 375     Quaternion expected(Degree(30), Vector3::YAXIS);
 376     DALI_TEST_EQUALS(q, expected, 0.0001f, TEST_LOCATION);
 377   }
 378
 379   END_TEST;
 380 }
 381
 382 int UtcDaliPhysics3DActorSetRotation2(void)
 383 {
 384   tet_infoline("Test the AsyncSetPhysicsRotation() function");
 385
 386   ToolkitTestApplication application;
 387   Matrix                 transform(false);
 388   transform.SetIdentityAndScale(Vector3(2.0f, -2.0f, 2.0f));
 389   Uint16Pair     size(640, 480);
 390   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 391   Actor          rootActor = adaptor.GetRootActor();
 392   auto           scene     = application.GetScene();
 393   scene.Add(rootActor);
 394
 395   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 396
 397   btRigidBody* body{nullptr};
 398   PhysicsActor physicsActor;
 399   {
 400     auto accessor    = adaptor.GetPhysicsAccessor();
 401     auto bulletWorld = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 402     body             = CreateBody(bulletWorld);
 403     physicsActor     = adaptor.AddActorBody(ballActor, body);
 404     physicsActor.AsyncSetPhysicsRotation(Quaternion(Degree(30), Vector3::ZAXIS));
 405   }
 406
 407   Test::WaitForEventThreadTrigger(1);
 408   adaptor.CreateSyncPoint();
 409   application.SendNotification();
 410   application.Render();
 411
 412   // Run 2 frames to ensure both buffers are set.
 413   application.SendNotification();
 414   application.Render();
 415   {
 416     auto accessor = adaptor.GetPhysicsAccessor();
 417     auto actor    = rootActor.FindChildById(physicsActor.GetId());
 418     // Warning - physics properties are never reflected in the event size cache.
 419     // Have to use GetCurrentProperty to see the updated values.
 420     Quaternion q = actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION);
 421     Quaternion expected(Degree(30), Vector3::ZAXIS);
 422     DALI_TEST_EQUALS(q, expected, 0.0001f, TEST_LOCATION);
 423   }
 424
 425   END_TEST;
 426 }
 427
 428 int UtcDaliPhysics3DActorGetActorPosition(void)
 429 {
 430   tet_infoline("Test the GetActorPosition() function");
 431
 432   ToolkitTestApplication application;
 433   Matrix                 transform(false);
 434   transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
 435   Uint16Pair     size(640, 480);
 436   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 437   Actor          rootActor = adaptor.GetRootActor();
 438   auto           scene     = application.GetScene();
 439   scene.Add(rootActor);
 440
 441   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 442
 443   btRigidBody* body{nullptr};
 444   PhysicsActor physicsActor;
 445   {
 446     auto accessor    = adaptor.GetPhysicsAccessor();
 447     auto bulletWorld = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 448     body             = CreateBody(bulletWorld);
 449     physicsActor     = adaptor.AddActorBody(ballActor, body);
 450     physicsActor.AsyncSetPhysicsPosition(Vector3(10, 20, -30));
 451   }
 452
 453   Test::WaitForEventThreadTrigger(1);
 454   adaptor.CreateSyncPoint();
 455   application.SendNotification();
 456   application.Render();
 457
 458   // Run 2 frames to ensure both buffers are set.
 459   application.SendNotification();
 460   application.Render();
 461   {
 462     auto accessor = adaptor.GetPhysicsAccessor();
 463     DALI_TEST_EQUALS(physicsActor.GetActorPosition(), Vector3(10, 20, -30), 0.0001f, TEST_LOCATION);
 464   }
 465
 466   END_TEST;
 467 }
 468
 469 int UtcDaliPhysics3DActorGetActorRotation(void)
 470 {
 471   tet_infoline("Test the GetActorRotation() function");
 472
 473   ToolkitTestApplication application;
 474   Matrix                 transform(false);
 475   transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
 476   Uint16Pair     size(640, 480);
 477   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 478   Actor          rootActor = adaptor.GetRootActor();
 479   auto           scene     = application.GetScene();
 480   scene.Add(rootActor);
 481
 482   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 483
 484   btRigidBody* body{nullptr};
 485   PhysicsActor physicsActor;
 486   {
 487     auto accessor    = adaptor.GetPhysicsAccessor();
 488     auto bulletWorld = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 489     body             = CreateBody(bulletWorld);
 490     physicsActor     = adaptor.AddActorBody(ballActor, body);
 491     physicsActor.AsyncSetPhysicsRotation(Quaternion(Degree(30), Vector3::ZAXIS));
 492   }
 493
 494   Test::WaitForEventThreadTrigger(1);
 495   adaptor.CreateSyncPoint();
 496   application.SendNotification();
 497   application.Render();
 498
 499   // Run 2 frames to ensure both buffers are set.
 500   application.SendNotification();
 501   application.Render();
 502   {
 503     auto accessor = adaptor.GetPhysicsAccessor();
 504     DALI_TEST_EQUALS(physicsActor.GetActorRotation(), Quaternion(Degree(30), Vector3::ZAXIS), 0.0001f, TEST_LOCATION);
 505   }
 506
 507   END_TEST;
 508 }
 509
 510 int UtcDaliPhysics3DActorGetPhysicsPosition(void)
 511 {
 512   tet_infoline("Test the GetPhysicsPosition() function");
 513
 514   ToolkitTestApplication application;
 515   Matrix                 transform(false);
 516   transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
 517
 518   Uint16Pair     size(640, 480);
 519   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 520   Actor          rootActor = adaptor.GetRootActor();
 521   auto           scene     = application.GetScene();
 522   scene.Add(rootActor);
 523
 524   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 525
 526   btRigidBody* body{nullptr};
 527   PhysicsActor physicsActor;
 528   {
 529     auto accessor    = adaptor.GetPhysicsAccessor();
 530     auto bulletWorld = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 531     body             = CreateBody(bulletWorld);
 532     physicsActor     = adaptor.AddActorBody(ballActor, body);
 533     physicsActor.AsyncSetPhysicsPosition(Vector3(10, 20, -30));
 534   }
 535
 536   Test::WaitForEventThreadTrigger(1);
 537   adaptor.CreateSyncPoint();
 538   application.SendNotification();
 539   application.Render();
 540
 541   // Run 2 frames to ensure both buffers are set.
 542   application.SendNotification();
 543   application.Render();
 544   {
 545     auto    accessor = adaptor.GetPhysicsAccessor();
 546     Vector4 pos      = transform * Vector4(10, 20, -30, 1);
 547     DALI_TEST_EQUALS(physicsActor.GetPhysicsPosition(), Vector3(pos), 0.0001f, TEST_LOCATION);
 548   }
 549
 550   END_TEST;
 551 }
 552
 553 int UtcDaliPhysics3DActorGetPhysicsRotation(void)
 554 {
 555   tet_infoline("Test the GetPhysicsRotation() function");
 556
 557   ToolkitTestApplication application;
 558   Matrix                 transform(false);
 559   transform.SetIdentityAndScale(Vector3(2.0f, -2.0f, 2.0f));
 560   Uint16Pair     size(640, 480);
 561   PhysicsAdaptor adaptor   = PhysicsAdaptor::New(transform, size);
 562   Actor          rootActor = adaptor.GetRootActor();
 563   auto           scene     = application.GetScene();
 564   scene.Add(rootActor);
 565
 566   Dali::Actor ballActor = Toolkit::ImageView::New(BALL_IMAGE);
 567
 568   btRigidBody* body{nullptr};
 569   PhysicsActor physicsActor;
 570   {
 571     auto accessor    = adaptor.GetPhysicsAccessor();
 572     auto bulletWorld = accessor->GetNative().Get<btDiscreteDynamicsWorld*>();
 573     body             = CreateBody(bulletWorld);
 574     physicsActor     = adaptor.AddActorBody(ballActor, body);
 575     physicsActor.AsyncSetPhysicsRotation(Quaternion(Degree(30), Vector3::ZAXIS));
 576   }
 577
 578   Test::WaitForEventThreadTrigger(1);
 579   adaptor.CreateSyncPoint();
 580   application.SendNotification();
 581   application.Render();
 582
 583   // Run 2 frames to ensure both buffers are set.
 584   application.SendNotification();
 585   application.Render();
 586   {
 587     auto accessor = adaptor.GetPhysicsAccessor();
 588     DALI_TEST_EQUALS(physicsActor.GetPhysicsRotation(), Quaternion(Degree(-30), Vector3::ZAXIS), 0.0001f, TEST_LOCATION);
 589   }
 590
 591   END_TEST;
 592 }