Use GTEST_SKIP in unsupported tests (#604)

scpeters · scpeters · commit c8159af0a0e5 · 2026-04-17T14:44:29.000-07:00
Also includes the following changes: * distortion_camera test: reference github issue * [fix] dvl test: check pointer in TearDown The TearDown unconditionally dereferences the engine pointer, which segfaults if the engine failed to load. Check the pointer before dereferencing. Signed-off-by: Steve Peters <scpeters@intrinsic.ai> (cherry picked from commit fc58044)
diff --git a/test/integration/boundingbox_camera.cc b/test/integration/boundingbox_camera.cc
@@ -216,18 +216,16 @@ void BoundingBoxCameraSensorTest::BoxesWithBuiltinSDF(
   // Skip unsupported engines
   if (_renderEngine != "ogre2")
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' doesn't support bounding box cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -385,18 +383,16 @@ void BoundingBoxCameraSensorTest::Boxes3DWithBuiltinSDF(
   // Skip unsupported engines
   if (_renderEngine != "ogre2")
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' doesn't support bounding box cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/camera.cc b/test/integration/camera.cc
@@ -116,9 +116,8 @@ void CameraSensorTest::ImagesWithBuiltinSDF(const std::string &_renderEngine)
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -218,9 +217,8 @@ void CameraSensorTest::CameraIntrinsics(const std::string &_renderEngine)
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
           << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -515,9 +513,8 @@ void CameraSensorTest::CameraProjection(const std::string &_renderEngine)
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
           << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -807,9 +804,8 @@ void CameraSensorTest::ImageFormatLInt8LInt16(const std::string &_renderEngine)
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/depth_camera.cc b/test/integration/depth_camera.cc
@@ -198,9 +198,8 @@ void DepthCameraSensorTest::ImagesWithBuiltinSDF(
   if ((_renderEngine.compare("ogre") != 0) &&
       (_renderEngine.compare("ogre2") != 0))
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' doesn't support depth cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
diff --git a/test/integration/distortion_camera.cc b/test/integration/distortion_camera.cc
@@ -81,18 +81,18 @@ void DistortionCameraSensorTest::ImagesWithBuiltinSDF(
 
   if (_renderEngine == "ogre2")
   {
-    gzdbg << "Distortion camera not supported yet in rendering engine: "
-            << _renderEngine << std::endl;
-    return;
+    GTEST_SKIP() << "Distortion camera not supported yet in rendering engine: "
+                 << _renderEngine
+                 << ", see https://github.com/gazebosim/gz-rendering/issues/697"
+                 << std::endl;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/dvl.cc b/test/integration/dvl.cc
@@ -239,8 +239,11 @@ class DopplerVelocityLogTest : public testing::Test,
   // Documentation inherited
   protected: void TearDown() override
   {
-    engine->DestroyScene(scene);
-    rendering::unloadEngine(engine->Name());
+    if (engine)
+    {
+      engine->DestroyScene(scene);
+      rendering::unloadEngine(engine->Name());
+    }
   }
 
   rendering::RenderEngine *engine{nullptr};
diff --git a/test/integration/gpu_lidar_sensor.cc b/test/integration/gpu_lidar_sensor.cc
@@ -209,9 +209,8 @@ void GpuLidarSensorTest::CreateGpuLidar(const std::string &_renderEngine)
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -330,9 +329,8 @@ void GpuLidarSensorTest::DetectBox(const std::string &_renderEngine)
     gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -502,9 +500,8 @@ void GpuLidarSensorTest::TestThreeBoxes(const std::string &_renderEngine)
     gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -651,9 +648,8 @@ void GpuLidarSensorTest::VerticalLidar(const std::string &_renderEngine)
     gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -787,9 +783,8 @@ void GpuLidarSensorTest::ManualUpdate(const std::string &_renderEngine)
     gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -897,9 +892,8 @@ void GpuLidarSensorTest::Topic(const std::string &_renderEngine)
   auto engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
   auto scene = engine->CreateScene("scene");
   EXPECT_NE(nullptr, scene);
diff --git a/test/integration/rgbd_camera.cc b/test/integration/rgbd_camera.cc
@@ -211,18 +211,16 @@ void RgbdCameraSensorTest::ImagesWithBuiltinSDF(
   if ((_renderEngine.compare("ogre") != 0) &&
       (_renderEngine.compare("ogre2") != 0))
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' doesn't support rgbd cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/segmentation_camera.cc b/test/integration/segmentation_camera.cc
@@ -191,17 +191,15 @@ void SegmentationCameraSensorTest::ImagesWithBuiltinSDF(
   // If ogre2 is not the engine, don't run the test
   if (_renderEngine.compare("ogre2") != 0)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
       << "' doesn't support segmentation cameras" << std::endl;
-    return;
   }
   // Setup gz-rendering with an empty scene
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/thermal_camera.cc b/test/integration/thermal_camera.cc
@@ -151,18 +151,16 @@ void ThermalCameraSensorTest::ImagesWithBuiltinSDF(
   if ((_renderEngine.compare("ogre") != 0) &&
       (_renderEngine.compare("ogre2") != 0))
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' doesn't support thermal cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -421,18 +419,16 @@ void ThermalCameraSensorTest::Images8BitWithBuiltinSDF(
   // If ogre2 is not the engine, don't run the test
   if ((_renderEngine.compare("ogre2") != 0))
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' doesn't support 8 bit thermal cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/triggered_boundingbox_camera.cc b/test/integration/triggered_boundingbox_camera.cc
@@ -135,18 +135,16 @@ void TriggeredBoundingBoxCameraTest::BoxesWithBuiltinSDF(
     // Skip unsupported engines
   if (_renderEngine != "ogre2")
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
            << "' doesn't support bounding box cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
            << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -238,18 +236,16 @@ void TriggeredBoundingBoxCameraTest::EmptyTriggerTopic(
     // Skip unsupported engines
   if (_renderEngine != "ogre2")
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
            << "' doesn't support bounding box cameras" << std::endl;
-    return;
   }
 
   // Setup gz-rendering with an empty scene
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
            << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/triggered_camera.cc b/test/integration/triggered_camera.cc
@@ -87,9 +87,8 @@ void TriggeredCameraTest::ImagesWithBuiltinSDF(const std::string &_renderEngine)
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
            << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
@@ -182,9 +181,8 @@ void TriggeredCameraTest::EmptyTriggerTopic(const std::string &_renderEngine)
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
            << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");
diff --git a/test/integration/wide_angle_camera.cc b/test/integration/wide_angle_camera.cc
@@ -120,9 +120,8 @@ void WideAngleCameraSensorTest::ImagesWithBuiltinSDF(
   auto *engine = gz::rendering::engine(_renderEngine);
   if (!engine)
   {
-    gzdbg << "Engine '" << _renderEngine
+    GTEST_SKIP() << "Engine '" << _renderEngine
               << "' is not supported" << std::endl;
-    return;
   }
 
   gz::rendering::ScenePtr scene = engine->CreateScene("scene");

Original file line number	Diff line number	Diff line change
`@@ -216,18 +216,16 @@ void BoundingBoxCameraSensorTest::BoxesWithBuiltinSDF(`
`216`	`216`	`// Skip unsupported engines`
`217`	`217`	`if (_renderEngine != "ogre2")`
`218`	`218`	`{`
`219`		`- gzdbg << "Engine '" << _renderEngine`
	`219`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`220`	`220`	`<< "' doesn't support bounding box cameras" << std::endl;`
`221`		`- return;`
`222`	`221`	`}`
`223`	`222`
`224`	`223`	`// Setup gz-rendering with an empty scene`
`225`	`224`	`auto *engine = rendering::engine(_renderEngine);`
`226`	`225`	`if (!engine)`
`227`	`226`	`{`
`228`		`- gzdbg << "Engine '" << _renderEngine`
	`227`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`229`	`228`	`<< "' is not supported" << std::endl;`
`230`		`- return;`
`231`	`229`	`}`
`232`	`230`
`233`	`231`	`rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -385,18 +383,16 @@ void BoundingBoxCameraSensorTest::Boxes3DWithBuiltinSDF(`
`385`	`383`	`// Skip unsupported engines`
`386`	`384`	`if (_renderEngine != "ogre2")`
`387`	`385`	`{`
`388`		`- gzdbg << "Engine '" << _renderEngine`
	`386`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`389`	`387`	`<< "' doesn't support bounding box cameras" << std::endl;`
`390`		`- return;`
`391`	`388`	`}`
`392`	`389`
`393`	`390`	`// Setup gz-rendering with an empty scene`
`394`	`391`	`auto *engine = rendering::engine(_renderEngine);`
`395`	`392`	`if (!engine)`
`396`	`393`	`{`
`397`		`- gzdbg << "Engine '" << _renderEngine`
	`394`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`398`	`395`	`<< "' is not supported" << std::endl;`
`399`		`- return;`
`400`	`396`	`}`
`401`	`397`
`402`	`398`	`rendering::ScenePtr scene = engine->CreateScene("scene");`
Original file line number	Diff line number	Diff line change
`@@ -116,9 +116,8 @@ void CameraSensorTest::ImagesWithBuiltinSDF(const std::string &_renderEngine)`
`116`	`116`	`auto *engine = gz::rendering::engine(_renderEngine);`
`117`	`117`	`if (!engine)`
`118`	`118`	`{`
`119`		`- gzdbg << "Engine '" << _renderEngine`
	`119`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`120`	`120`	`<< "' is not supported" << std::endl;`
`121`		`- return;`
`122`	`121`	`}`
`123`	`122`
`124`	`123`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -218,9 +217,8 @@ void CameraSensorTest::CameraIntrinsics(const std::string &_renderEngine)`
`218`	`217`	`auto *engine = gz::rendering::engine(_renderEngine);`
`219`	`218`	`if (!engine)`
`220`	`219`	`{`
`221`		`- gzdbg << "Engine '" << _renderEngine`
	`220`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`222`	`221`	`<< "' is not supported" << std::endl;`
`223`		`- return;`
`224`	`222`	`}`
`225`	`223`
`226`	`224`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -515,9 +513,8 @@ void CameraSensorTest::CameraProjection(const std::string &_renderEngine)`
`515`	`513`	`auto *engine = gz::rendering::engine(_renderEngine);`
`516`	`514`	`if (!engine)`
`517`	`515`	`{`
`518`		`- gzdbg << "Engine '" << _renderEngine`
	`516`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`519`	`517`	`<< "' is not supported" << std::endl;`
`520`		`- return;`
`521`	`518`	`}`
`522`	`519`
`523`	`520`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -807,9 +804,8 @@ void CameraSensorTest::ImageFormatLInt8LInt16(const std::string &_renderEngine)`
`807`	`804`	`auto *engine = gz::rendering::engine(_renderEngine);`
`808`	`805`	`if (!engine)`
`809`	`806`	`{`
`810`		`- gzdbg << "Engine '" << _renderEngine`
	`807`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`811`	`808`	`<< "' is not supported" << std::endl;`
`812`		`- return;`
`813`	`809`	`}`
`814`	`810`
`815`	`811`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
Original file line number	Diff line number	Diff line change
`@@ -198,9 +198,8 @@ void DepthCameraSensorTest::ImagesWithBuiltinSDF(`
`198`	`198`	`if ((_renderEngine.compare("ogre") != 0) &&`
`199`	`199`	`(_renderEngine.compare("ogre2") != 0))`
`200`	`200`	`{`
`201`		`- gzdbg << "Engine '" << _renderEngine`
	`201`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`202`	`202`	`<< "' doesn't support depth cameras" << std::endl;`
`203`		`- return;`
`204`	`203`	`}`
`205`	`204`
`206`	`205`	`// Setup gz-rendering with an empty scene`
Original file line number	Diff line number	Diff line change
`@@ -81,18 +81,18 @@ void DistortionCameraSensorTest::ImagesWithBuiltinSDF(`
`81`	`81`
`82`	`82`	`if (_renderEngine == "ogre2")`
`83`	`83`	`{`
`84`		`- gzdbg << "Distortion camera not supported yet in rendering engine: "`
`85`		`- << _renderEngine << std::endl;`
`86`		`- return;`
	`84`	`+ GTEST_SKIP() << "Distortion camera not supported yet in rendering engine: "`
	`85`	`+ << _renderEngine`
	`86`	`+ << ", see https://github.com/gazebosim/gz-rendering/issues/697"`
	`87`	`+ << std::endl;`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`// Setup gz-rendering with an empty scene`
`90`	`91`	`auto *engine = gz::rendering::engine(_renderEngine);`
`91`	`92`	`if (!engine)`
`92`	`93`	`{`
`93`		`- gzdbg << "Engine '" << _renderEngine`
	`94`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`94`	`95`	`<< "' is not supported" << std::endl;`
`95`		`- return;`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
Original file line number	Diff line number	Diff line change
`@@ -239,8 +239,11 @@ class DopplerVelocityLogTest : public testing::Test,`
`239`	`239`	`// Documentation inherited`
`240`	`240`	`protected: void TearDown() override`
`241`	`241`	`{`
`242`		`- engine->DestroyScene(scene);`
`243`		`- rendering::unloadEngine(engine->Name());`
	`242`	`+ if (engine)`
	`243`	`+ {`
	`244`	`+ engine->DestroyScene(scene);`
	`245`	`+ rendering::unloadEngine(engine->Name());`
	`246`	`+ }`
`244`	`247`	`}`
`245`	`248`
`246`	`249`	`rendering::RenderEngine *engine{nullptr};`
Original file line number	Diff line number	Diff line change
`@@ -209,9 +209,8 @@ void GpuLidarSensorTest::CreateGpuLidar(const std::string &_renderEngine)`
`209`	`209`	`auto *engine = gz::rendering::engine(_renderEngine);`
`210`	`210`	`if (!engine)`
`211`	`211`	`{`
`212`		`- gzdbg << "Engine '" << _renderEngine`
	`212`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`213`	`213`	`<< "' is not supported" << std::endl;`
`214`		`- return;`
`215`	`214`	`}`
`216`	`215`
`217`	`216`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -330,9 +329,8 @@ void GpuLidarSensorTest::DetectBox(const std::string &_renderEngine)`
`330`	`329`	`gz::rendering::engine(_renderEngine);`
`331`	`330`	`if (!engine)`
`332`	`331`	`{`
`333`		`- gzdbg << "Engine '" << _renderEngine`
	`332`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`334`	`333`	`<< "' is not supported" << std::endl;`
`335`		`- return;`
`336`	`334`	`}`
`337`	`335`
`338`	`336`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -502,9 +500,8 @@ void GpuLidarSensorTest::TestThreeBoxes(const std::string &_renderEngine)`
`502`	`500`	`gz::rendering::engine(_renderEngine);`
`503`	`501`	`if (!engine)`
`504`	`502`	`{`
`505`		`- gzdbg << "Engine '" << _renderEngine`
	`503`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`506`	`504`	`<< "' is not supported" << std::endl;`
`507`		`- return;`
`508`	`505`	`}`
`509`	`506`
`510`	`507`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -651,9 +648,8 @@ void GpuLidarSensorTest::VerticalLidar(const std::string &_renderEngine)`
`651`	`648`	`gz::rendering::engine(_renderEngine);`
`652`	`649`	`if (!engine)`
`653`	`650`	`{`
`654`		`- gzdbg << "Engine '" << _renderEngine`
	`651`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`655`	`652`	`<< "' is not supported" << std::endl;`
`656`		`- return;`
`657`	`653`	`}`
`658`	`654`
`659`	`655`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -787,9 +783,8 @@ void GpuLidarSensorTest::ManualUpdate(const std::string &_renderEngine)`
`787`	`783`	`gz::rendering::engine(_renderEngine);`
`788`	`784`	`if (!engine)`
`789`	`785`	`{`
`790`		`- gzdbg << "Engine '" << _renderEngine`
	`786`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`791`	`787`	`<< "' is not supported" << std::endl;`
`792`		`- return;`
`793`	`788`	`}`
`794`	`789`
`795`	`790`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -897,9 +892,8 @@ void GpuLidarSensorTest::Topic(const std::string &_renderEngine)`
`897`	`892`	`auto engine = gz::rendering::engine(_renderEngine);`
`898`	`893`	`if (!engine)`
`899`	`894`	`{`
`900`		`- gzdbg << "Engine '" << _renderEngine`
	`895`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`901`	`896`	`<< "' is not supported" << std::endl;`
`902`		`- return;`
`903`	`897`	`}`
`904`	`898`	`auto scene = engine->CreateScene("scene");`
`905`	`899`	`EXPECT_NE(nullptr, scene);`
Original file line number	Diff line number	Diff line change
`@@ -211,18 +211,16 @@ void RgbdCameraSensorTest::ImagesWithBuiltinSDF(`
`211`	`211`	`if ((_renderEngine.compare("ogre") != 0) &&`
`212`	`212`	`(_renderEngine.compare("ogre2") != 0))`
`213`	`213`	`{`
`214`		`- gzdbg << "Engine '" << _renderEngine`
	`214`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`215`	`215`	`<< "' doesn't support rgbd cameras" << std::endl;`
`216`		`- return;`
`217`	`216`	`}`
`218`	`217`
`219`	`218`	`// Setup gz-rendering with an empty scene`
`220`	`219`	`auto *engine = rendering::engine(_renderEngine);`
`221`	`220`	`if (!engine)`
`222`	`221`	`{`
`223`		`- gzdbg << "Engine '" << _renderEngine`
	`222`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`224`	`223`	`<< "' is not supported" << std::endl;`
`225`		`- return;`
`226`	`224`	`}`
`227`	`225`
`228`	`226`	`rendering::ScenePtr scene = engine->CreateScene("scene");`
Original file line number	Diff line number	Diff line change
`@@ -191,17 +191,15 @@ void SegmentationCameraSensorTest::ImagesWithBuiltinSDF(`
`191`	`191`	`// If ogre2 is not the engine, don't run the test`
`192`	`192`	`if (_renderEngine.compare("ogre2") != 0)`
`193`	`193`	`{`
`194`		`- gzdbg << "Engine '" << _renderEngine`
	`194`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`195`	`195`	`<< "' doesn't support segmentation cameras" << std::endl;`
`196`		`- return;`
`197`	`196`	`}`
`198`	`197`	`// Setup gz-rendering with an empty scene`
`199`	`198`	`auto *engine = gz::rendering::engine(_renderEngine);`
`200`	`199`	`if (!engine)`
`201`	`200`	`{`
`202`		`- gzdbg << "Engine '" << _renderEngine`
	`201`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`203`	`202`	`<< "' is not supported" << std::endl;`
`204`		`- return;`
`205`	`203`	`}`
`206`	`204`
`207`	`205`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
Original file line number	Diff line number	Diff line change
`@@ -151,18 +151,16 @@ void ThermalCameraSensorTest::ImagesWithBuiltinSDF(`
`151`	`151`	`if ((_renderEngine.compare("ogre") != 0) &&`
`152`	`152`	`(_renderEngine.compare("ogre2") != 0))`
`153`	`153`	`{`
`154`		`- gzdbg << "Engine '" << _renderEngine`
	`154`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`155`	`155`	`<< "' doesn't support thermal cameras" << std::endl;`
`156`		`- return;`
`157`	`156`	`}`
`158`	`157`
`159`	`158`	`// Setup gz-rendering with an empty scene`
`160`	`159`	`auto *engine = gz::rendering::engine(_renderEngine);`
`161`	`160`	`if (!engine)`
`162`	`161`	`{`
`163`		`- gzdbg << "Engine '" << _renderEngine`
	`162`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`164`	`163`	`<< "' is not supported" << std::endl;`
`165`		`- return;`
`166`	`164`	`}`
`167`	`165`
`168`	`166`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -421,18 +419,16 @@ void ThermalCameraSensorTest::Images8BitWithBuiltinSDF(`
`421`	`419`	`// If ogre2 is not the engine, don't run the test`
`422`	`420`	`if ((_renderEngine.compare("ogre2") != 0))`
`423`	`421`	`{`
`424`		`- gzdbg << "Engine '" << _renderEngine`
	`422`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`425`	`423`	`<< "' doesn't support 8 bit thermal cameras" << std::endl;`
`426`		`- return;`
`427`	`424`	`}`
`428`	`425`
`429`	`426`	`// Setup gz-rendering with an empty scene`
`430`	`427`	`auto *engine = gz::rendering::engine(_renderEngine);`
`431`	`428`	`if (!engine)`
`432`	`429`	`{`
`433`		`- gzdbg << "Engine '" << _renderEngine`
	`430`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`434`	`431`	`<< "' is not supported" << std::endl;`
`435`		`- return;`
`436`	`432`	`}`
`437`	`433`
`438`	`434`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
Original file line number	Diff line number	Diff line change
`@@ -135,18 +135,16 @@ void TriggeredBoundingBoxCameraTest::BoxesWithBuiltinSDF(`
`135`	`135`	`// Skip unsupported engines`
`136`	`136`	`if (_renderEngine != "ogre2")`
`137`	`137`	`{`
`138`		`- gzdbg << "Engine '" << _renderEngine`
	`138`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`139`	`139`	`<< "' doesn't support bounding box cameras" << std::endl;`
`140`		`- return;`
`141`	`140`	`}`
`142`	`141`
`143`	`142`	`// Setup gz-rendering with an empty scene`
`144`	`143`	`auto *engine = gz::rendering::engine(_renderEngine);`
`145`	`144`	`if (!engine)`
`146`	`145`	`{`
`147`		`- gzdbg << "Engine '" << _renderEngine`
	`146`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`148`	`147`	`<< "' is not supported" << std::endl;`
`149`		`- return;`
`150`	`148`	`}`
`151`	`149`
`152`	`150`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`
`@@ -238,18 +236,16 @@ void TriggeredBoundingBoxCameraTest::EmptyTriggerTopic(`
`238`	`236`	`// Skip unsupported engines`
`239`	`237`	`if (_renderEngine != "ogre2")`
`240`	`238`	`{`
`241`		`- gzdbg << "Engine '" << _renderEngine`
	`239`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`242`	`240`	`<< "' doesn't support bounding box cameras" << std::endl;`
`243`		`- return;`
`244`	`241`	`}`
`245`	`242`
`246`	`243`	`// Setup gz-rendering with an empty scene`
`247`	`244`	`auto *engine = gz::rendering::engine(_renderEngine);`
`248`	`245`	`if (!engine)`
`249`	`246`	`{`
`250`		`- gzdbg << "Engine '" << _renderEngine`
	`247`	`+ GTEST_SKIP() << "Engine '" << _renderEngine`
`251`	`248`	`<< "' is not supported" << std::endl;`
`252`		`- return;`
`253`	`249`	`}`
`254`	`250`
`255`	`251`	`gz::rendering::ScenePtr scene = engine->CreateScene("scene");`